问用于识别手写数字的神经网络:处理多个输出

EN

    # Import our dependencies

    import numpy as np
    from sklearn import datasets

    class Neural_Network():

        #Initalising function
        def __init__(self, input_size, output_size, niteration = 100000):

            np.random.seed(1)

            self.niteration = niteration
            self.layer_sizes = np.array([input_size, output_size])
            self.weights = list()
            self.error = np.array([])

            # initialise random weights
            self._recreate_weights()


        def _recreate_weights(self):
            # Recreate the weights after adding a hidden layer
            self.weights = list()

            for i in np.arange(len(self.layer_sizes) - 1):

                weights = np.random.rand(self.layer_sizes[i], self.layer_sizes[i+1]) * 2 - 1
                self.weights.append(weights)
            self.momentum = [i * 0 for i in self.weights]


        def add_hidden_layer(self,size):
            # Add a new hidden layer to our neural network
            self.layer_sizes = np.insert(self.layer_sizes, -1, size)
            self._recreate_weights()



        def _sigmoid(self, x, deriv=False):

            if deriv:
                return self._sigmoid(x, deriv=False)*(1-self._sigmoid(x, deriv=False))
            else:
                return 1.0/(1+np.exp(-x))



        def predict(self, input_single, deriv=False, layer_output = False):

            data_current_layer = input_single
            output_list = list()
            output_list.append(np.array([data_current_layer]))
            for i in np.arange(len(self.layer_sizes) - 1):
                data_current_layer = self._sigmoid(np.dot(data_current_layer, self.weights[i]), deriv)
                output_list.append(np.array([data_current_layer]))

            return(output_list)



        def train2(self, input_training_data, input_training_labels):

            for iterations in np.arange(self.niteration):
                # Loop over all training sets niteration times

                updates = [i * 0 for i in network.weights] # Used for storing the update to the weights
                mean_error = np.array([]) # used for calculating the mean error

                for i in np.arange(len(input_training_data)): # For each training example

                    activations = list() # Store all my activations in a list
                    activations.append(np.array([input_training_data[i]]))

                    for j in np.arange(len(self.layer_sizes) - 1):
                        # Calculate all the activations for every layer

                        z = np.dot(activations[-1], self.weights[j])
                        a = self._sigmoid(z, deriv = False)
                        activations.append(a)

                    error = list()
                    error.append(a[-1] - np.array([input_training_labels[i]]))

                    for j in np.arange(len(self.layer_sizes) - 2):
                        # Calculate the error term for each layer

                        j2 = (-1 * j) - 1
                        j3 = j2 - 1
                        d = np.dot(error[j], self.weights[j2].T) * activations[j3] * (1 - activations[j3])
                        error.append(d)

                    for j in np.arange(len(self.layer_sizes) - 1):
                        # calculate the gradient for the error with respect to the weights

                        j2 = (-1 * j) - 1
                        updates[j] += np.dot(activations[j].T, error[j2])


                    mean_error = np.append(mean_error, np.sum(np.abs(error[0])))

                updates = [0.001*i/len(input_training_data) for i in updates] # Add in a learning rate
                self.error = np.append(self.error,np.mean(mean_error))

                for i in np.arange(len(self.weights)):
                    # update using a momentum term
                    self.momentum[i] -= updates[i]
                    self.weights[i]  += self.momentum[i]
                    self.momentum[i] *= 0.9

                if np.mod(iterations, 1000) == 0:
                    # Visually keep track of the error
                    print(iterations, self.error[-1])


    # Main Loop


    # Read in the dataset and divide into a training and test set
    data = datasets.load_digits()
    images = data.images
    labels = data.target
    targets = data.target_names

    training_images = images[:int(len(labels*0.8))]
    training_labels = labels[:int(len(labels*0.8))]

    training_images = images[:10]
    training_labels = labels[:10]

    test_images = images[int(len(labels*0.8)):]
    test_labels = labels[int(len(labels*0.8)):]

    # Flatten the training and test images using ravel. CAN PROBABLY DO THIS BEFORE DIVIDING THEM UP.
    training_images_list = list()
    for i in training_images:
        training_images_list.append(np.ravel(i))

    test_images_list = list()
    for i in test_images:
        test_images_list.append(np.ravel(i))


    # Change the training and test labels into a more usable format.

    training_labels_temp=np.zeros([np.size(training_labels), 10])
    for i in np.arange(np.size(training_labels)):
        training_labels_temp[i, training_labels[i]] = 1
    training_labels = training_labels_temp

    test_labels_temp=np.zeros([np.size(test_labels), 10])
    for i in np.arange(np.size(test_labels)):
        test_labels_temp[i, test_labels[i]] = 1
    test_labels = test_labels_temp


    # Build a 3 layered neural network, input - hidden - output

    if True:
        network = Neural_Network(input_size=64, output_size=10)

        network.add_hidden_layer(size=4)
        network.add_hidden_layer(size=4)
        network.add_hidden_layer(size=4)



        # Train the network on our training set
        #print(network.weights)
        network.train2(input_training_data = training_images_list, input_training_labels = training_labels)
        #print(network.weights)

        # Calculate the error on our test set

        #network.calculate_error(test_set = test_images, test_labels = test_labels)