Python描述的神经网络模型

nn.py

@@ -0,0 +1,124 @@
+import numpy as np
+
+
+# Create a neural net
+def create_neural_net(layer_array, input_dims):
+    weights = []
+    biases = []
+    activations = []
+
+    for i in range(len(layer_array)):
+        node_num = layer_array[i][0]
+        weights_of_layer = []
+        biases_of_layer = []
+        if i == 0:
+            last_layer_node_number = input_dims
+        else:
+            last_layer_node_number = layer_array[i - 1][0]
+
+        for n in range(0, node_num):
+            weights_of_node = []
+            for l in range(0, last_layer_node_number):
+                weights_of_node.append(1)
+            weights_of_layer.append(weights_of_node)
+            biases_of_layer.append(0)
+
+        weights.append(weights_of_layer)
+        biases.append(biases_of_layer)
+        activations.append(layer_array[i][1])
+    return [weights, biases, activations]
+
+
+# Activations
+def sigmoid(x):
+    return 1 / (1 + np.exp(-x))
+
+
+def sigmoid_deriv(x):
+    return x * (1 - x)
+
+
+def relu(x):
+    if x < 0:
+        return 0
+    else:
+        return x
+
+
+# prediction
+def predict_ratio(data, neural_net):
+    weights = neural_net[0]
+    biases = neural_net[1]
+    activations = neural_net[2]
+
+    layer_num = len(weights)
+
+    for l in range(0, layer_num):
+        data = np.dot(weights[l], data)
+        for t in range(len(data)):
+            data[t] += biases[l][t]
+        if activations[l] == 'sigmoid':
+            data = sigmoid(data)
+        elif activations[l] == 'relu':
+            data = relu(data)
+        else:
+            # If not identified, do it with sigmoid
+            data = sigmoid(data)
+            print('activation function', activations[l], 'cannot be found. Sigmoid is used')
+    return data
+
+
+def predict(data, neural_net):
+    data = predict_ratio(data, neural_net)
+
+    class_num = len(data)
+
+    highest_class = None
+    highest_class_probability = -1
+
+    for i in range(0, class_num):
+        if highest_class == None:
+            highest_class = i
+            highest_class_probability = data[i]
+        elif data[i] > highest_class_probability:
+            highest_class = i
+            highest_class_probability = data[i]
+
+    return highest_class, highest_class_probability
+
+
+# Training
+def train_network(X, Y, labels, neural_net, epochs=1000):
+    for epoch in range(0, epochs):
+        for d in range(0, len(X)):
+            prediction = predict_ratio(X[d], neural_net)
+
+            # Calculate total error per label
+            true_prediction = []
+            for i in range(0, len(labels)):
+                true_prediction.append(0)
+            true_prediction[labels.index(Y[d])] = 1
+
+            errors = []
+            for t in range(len(prediction)):
+                errors.append(true_prediction[t] - prediction[t])
+            adjust_deriv = errors * sigmoid_deriv(prediction)
+
+            for k in range(0, len(adjust_deriv)):
+                adjustment = np.dot(X[d], adjust_deriv[k])
+                neural_net[0][0][k] += adjustment
+    return neural_net
+
+
+if __name__ == '__main__':
+    X = [[1, 1, 0, 0, 1, 1, 1, 1], [1, 1, 0, 0, 0, 1, 1, 1], [1, 0, 0, 0, 1, 1, 1, 1], [0, 1, 1, 1, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0]]
+    Y = [1, 1, 1, 0, 0, 0]
+    labels = [0, 1]
+    layer_array = [[len(labels), 'sigmoid']]
+    input_dims = 8
+    neural_net = create_neural_net(layer_array, input_dims)
+
+    print('weights:', neural_net[0], '\nbiases:', neural_net[1], '\nactivations:', neural_net[2])
+    neural_net = train_network(X, Y, labels, neural_net, epochs=1000)
+    for i in range(len(X)):
+        print(predict(X[i], neural_net))