So verwenden Sie den Python-Algorithmus für künstliche Intelligenz, ein künstliches neuronales Netzwerk

Künstliches neuronales Netzwerk

(Artificial Neural Network, ANN) ist ein mathematisches Modell, das die Struktur und Funktion biologischer neuronaler Netzwerke nachahmt. Sein Zweck besteht darin, bei der Verarbeitung unbekannter Eingabedaten durch Lern- und Trainingsbeziehungen eine komplexe nichtlineare Zuordnung durchzuführen um eine adaptive intelligente Entscheidungsfindung zu erreichen. Man kann sagen, dass ANN der grundlegendste und wichtigste Algorithmus unter den Algorithmen der künstlichen Intelligenz ist.

Die Grundstruktur des ANN-Modells umfasst die Eingabeschicht, die verborgene Schicht und die Ausgabeschicht. Die Eingabeschicht empfängt Eingabedaten, die verborgene Schicht ist für die mehrstufige, hochdimensionale Transformation und Verarbeitung von Daten verantwortlich und die Ausgabeschicht gibt die verarbeiteten Daten aus. Der Trainingsprozess von ANN besteht darin, die Gewichte jeder Schicht im neuronalen Netzwerk durch mehrere Iterationen kontinuierlich anzupassen, damit das neuronale Netzwerk die Eingabedaten korrekt vorhersagen und klassifizieren kann.

Beispiel für einen Algorithmus für ein künstliches neuronales Netzwerk

Schauen Sie sich als nächstes ein einfaches Beispiel für einen Algorithmus für ein künstliches neuronales Netzwerk an:

import numpy as np
class NeuralNetwork():
    def __init__(self, layers):
        """
        layers: 数组，包含每个层的神经元数量，例如 [2, 3, 1] 表示 3 层神经网络，第一层 2 个神经元，第二层 3 个神经元，第三层 1 个神经元。
        weights: 数组，包含每个连接的权重矩阵，默认值随机生成。
        biases: 数组，包含每个层的偏差值，默认值为 0。
        """
        self.layers = layers
        self.weights = [np.random.randn(a, b) for a, b in zip(layers[1:], layers[:-1])]
        self.biases = [np.zeros((a, 1)) for a in layers[1:]]
    def sigmoid(self, z):
        """Sigmoid 激活函数."""
        return 1 / (1 + np.exp(-z))
    def forward_propagation(self, a):
        """前向传播."""
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            a = self.sigmoid(z)
        return a
    def backward_propagation(self, x, y):
        """反向传播."""
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        a = x
        activations = [x]
        zs = []
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, a) + b
            zs.append(z)
            a = self.sigmoid(z)
            activations.append(a)
        delta = self.cost_derivative(activations[-1], y) * self.sigmoid_prime(zs[-1])
        nabla_b[-1] = delta
        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
        for l in range(2, len(self.layers)):
            z = zs[-l]
            sp = self.sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
            nabla_b[-l] = delta
            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
        return (nabla_w, nabla_b)
    def train(self, x_train, y_train, epochs, learning_rate):
        """训练网络."""
        for epoch in range(epochs):
            nabla_w = [np.zeros(w.shape) for w in self.weights]
            nabla_b = [np.zeros(b.shape) for b in self.biases]
            for x, y in zip(x_train, y_train):
                delta_nabla_w, delta_nabla_b = self.backward_propagation(np.array([x]).transpose(), np.array([y]).transpose())
                nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
                nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
            self.weights = [w-(learning_rate/len(x_train))*nw for w, nw in zip(self.weights, nabla_w)]
            self.biases = [b-(learning_rate/len(x_train))*nb for b, nb in zip(self.biases, nabla_b)]
    def predict(self, x_test):
        """预测."""
        y_predictions = []
        for x in x_test:
            y_predictions.append(self.forward_propagation(np.array([x]).transpose())[0][0])
        return y_predictions
    def cost_derivative(self, output_activations, y):
        """损失函数的导数."""
        return output_activations - y
    def sigmoid_prime(self, z):
        """Sigmoid 函数的导数."""
        return self.sigmoid(z) * (1 - self.sigmoid(z))

Verwenden Sie das folgende Codebeispiel, um diese einfache neuronale Netzwerkklasse zu instanziieren und zu verwenden:

x_train = [[0, 0], [1, 0], [0, 1], [1, 1]]
y_train = [0, 1, 1, 0]
# 创建神经网络
nn = NeuralNetwork([2, 3, 1])
# 训练神经网络
nn.train(x_train, y_train, 10000, 0.1)
# 测试神经网络
x_test = [[0, 0], [1, 0], [0, 1], [1, 1]]
y_test = [0, 1, 1, 0]
y_predictions = nn.predict(x_test)
print("Predictions:", y_predictions)
print("Actual:", y_test)

Ausgabeergebnisse:

Vorhersagen: [ 0,011602156431658403, 0,9852717774725432, 0,9839448924887225, 0,020026540429992387]
Aktuell: [0, 1, 1, 0]

Das obige ist der detaillierte Inhalt vonSo verwenden Sie den Python-Algorithmus für künstliche Intelligenz, ein künstliches neuronales Netzwerk. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!