Rumah >pembangunan bahagian belakang >Tutorial Python >Cara menggunakan algoritma kecerdasan buatan python rangkaian saraf tiruan

Cara menggunakan algoritma kecerdasan buatan python rangkaian saraf tiruan

王林
王林ke hadapan
2023-05-02 19:40:091826semak imbas

Rangkaian Neural Buatan

(Rangkaian Neural Buatan, ANN) ialah model matematik yang meniru struktur dan fungsi rangkaian saraf biologi Tujuannya adalah untuk dapat memproses data input yang tidak diketahui melalui pembelajaran dan latihan. Menjalankan hubungan pemetaan tak linear yang kompleks untuk mencapai pembuatan keputusan pintar adaptif. Boleh dikatakan bahawa ANN adalah algoritma yang paling asas dan teras antara algoritma kecerdasan buatan.

Struktur asas model ANN termasuk lapisan input, lapisan tersembunyi dan lapisan output. Lapisan input menerima data input, lapisan tersembunyi bertanggungjawab untuk transformasi dan pemprosesan data berbilang peringkat, dimensi tinggi, dan lapisan output mengeluarkan data yang diproses. Proses latihan ANN adalah untuk terus melaraskan berat setiap lapisan dalam rangkaian saraf melalui pelbagai lelaran, supaya rangkaian saraf boleh meramal dan mengklasifikasikan data input dengan betul.

Contoh Algoritma Rangkaian Neural Tiruan

Seterusnya lihat contoh Algoritma Rangkaian Neural Tiruan yang mudah:

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

Gunakan contoh kod berikut untuk membuat serta-merta dan menggunakan rangkaian algoritma rangkaian saraf mudah ini kelas:

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)

Hasil keluaran:

Ramalan: [0.011602156431658403, 0.9852717774725432, 0.9838472025 2387]
Sebenar: [0, 1, 1, 0]

Atas ialah kandungan terperinci Cara menggunakan algoritma kecerdasan buatan python rangkaian saraf tiruan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Kenyataan:
Artikel ini dikembalikan pada:yisu.com. Jika ada pelanggaran, sila hubungi admin@php.cn Padam