学习ChatGPT原理，人工智能神经网络Python实现

import math  
import random  
   
# 神经网络3层, 1个隐藏层; 4个input和1个output  
network = [4, [16], 1]  

population = 50  
elitism = 0.2   
random_behaviour = 0.1  
mutation_rate = 0.5  
mutation_range = 2  
historic = 0  
low_historic = False  
score_sort = -1  
n_child = 1  
# 激活函数  
def sigmoid(z):  
    return 1.0/(1.0+math.exp(-z))  
# random number  
def random_clamped():  
    return random.random()*2-1  
   
# "神经元"  
class Neuron():  
    def __init__(self):  
        self.biase = 0  
        self.weights = []  
   
    def init_weights(self, n):  
        self.weights = []  
        for i in range(n):  
            self.weights.append(random_clamped())  
    def __repr__(self):  
        return 'Neuron weight size:{}  biase value:{}'.format(len(self.weights), self.biase)  
   
# 层  
class Layer():  
    def __init__(self, index):  
        self.index = index  
        self.neurons = []  
   
    def init_neurons(self, n_neuron, n_input):  
        self.neurons = []  
        for i in range(n_neuron):  
            neuron = Neuron()  
            neuron.init_weights(n_input)  
            self.neurons.append(neuron)  
   
    def __repr__(self):  
        return 'Layer ID:{}  Layer neuron size:{}'.format(self.index, len(self.neurons))  
   
# 神经网络  
class NeuroNetwork():  
    def __init__(self):  
        self.layers = []  
   
    # input:输入层神经元数 hiddens:隐藏层 output:输出层神经元数  
    def init_neuro_network(self, input, hiddens , output):  
        index = 0  
        previous_neurons = 0  
        # input  
        layer = Layer(index)  
        layer.init_neurons(input, previous_neurons)  
        previous_neurons = input  
        self.layers.append(layer)  
        index += 1  
        # hiddens  
        for i in range(len(hiddens)):  
            layer = Layer(index)  
            layer.init_neurons(hiddens[i], previous_neurons)  
            previous_neurons = hiddens[i]  
            self.layers.append(layer)  
            index += 1  
        # output  
        layer = Layer(index)  
        layer.init_neurons(output, previous_neurons)  
        self.layers.append(layer)  
   
    def get_weights(self):  
        data = { 'network':[], 'weights':[] }  
        for layer in self.layers:  
            data['network'].append(len(layer.neurons))  
            for neuron in layer.neurons:  
                for weight in neuron.weights:  
                    data['weights'].append(weight)  
        return data  
   
    def set_weights(self, data):  
        previous_neurons = 0  
        index = 0  
        index_weights = 0  
   
        self.layers = []  
        for i in data['network']:  
            layer = Layer(index)  
            layer.init_neurons(i, previous_neurons)  
            for j in range(len(layer.neurons)):  
                for k in range(len(layer.neurons[j].weights)):  
                    layer.neurons[j].weights[k] = data['weights'][index_weights]  
                    index_weights += 1  
            previous_neurons = i  
            index += 1  
            self.layers.append(layer)  
   
    def feed_forward(self, inputs):  
        for i in range(len(inputs)):  
            self.layers[0].neurons[i].biase = inputs[i]  
   
        prev_layer = self.layers[0]  
        for i in range(len(self.layers)):  
            # 第一层没有weights  
            if i == 0:  
                continue  
            for j in range(len(self.layers[i].neurons)):  
                sum = 0  
                for k in range(len(prev_layer.neurons)):  
                    sum += prev_layer.neurons[k].biase * self.layers[i].neurons[j].weights[k]  
                self.layers[i].neurons[j].biase = sigmoid(sum)  
            prev_layer = self.layers[i]  
   
        out = []  
        last_layer = self.layers[-1]  
        for i in range(len(last_layer.neurons)):  
            out.append(last_layer.neurons[i].biase)  
        return out  
   
    def print_info(self):  
        for layer in self.layers:  
            print(layer)