파이썬 인공지능 알고리즘 인공신경망 활용법

Artificial Neural Network

(Artificial Neural Network, ANN)은 학습 및 훈련을 통해 알려지지 않은 입력 데이터를 처리할 때 복잡한 비선형 매핑을 수행할 수 있도록 하는 생물학적 신경망의 구조와 기능을 모방하는 수학적 모델입니다. 적응형 지능적 의사결정을 달성합니다. ANN은 인공지능 알고리즘 중 가장 기본적이고 핵심적인 알고리즘이라고 할 수 있다.

ANN 모델의 기본 구조에는 입력 레이어, 숨겨진 레이어 및 출력 레이어가 포함됩니다. 입력 계층은 입력 데이터를 수신하고, 은닉 계층은 데이터의 다단계, 고차원 변환 및 처리를 담당하며, 출력 계층은 처리된 데이터를 출력합니다. ANN의 훈련 과정은 신경망이 입력 데이터를 정확하게 예측하고 분류할 수 있도록 여러 번의 반복을 통해 신경망의 각 계층의 가중치를 지속적으로 조정하는 것입니다.

인공 신경망 알고리즘 예제

다음으로 간단한 인공 신경망 알고리즘 예제를 살펴보세요.

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))

다음 코드 예제를 사용하여 이 간단한 신경망 클래스를 인스턴스화하고 사용합니다.

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)

출력 결과:

예측: [ 0.011602156431658403, 0.9852717774725432, 0.9839448924887225, 0.020026540429992387]
실제: [0, 1, 1, 0]

위 내용은 파이썬 인공지능 알고리즘 인공신경망 활용법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!