def main(): training_data, validation_data, test_data = mnist_loader_with_unknowns.load_data_wrapper( ) size = 10 print len(training_data) hidden_neurons = 30 #input("Enter the number of hidden neurons:") net = network.Network([784, hidden_neurons, 11]) num_of_epochs = 20 #input("Enter the number of epochs:") min_batch_size = 50 #input("Enter the mini-batch size:") net.SGD(training_data, num_of_epochs, min_batch_size, 3.0) #, test_data=test_data) win = GraphWin('Number', size * 28, size * 28) # give title and dimensions entry = input("Which number to display?") while entry <> 0: graphical_output.update_number(training_data[entry][0], size, win) counter = 0 answer = 0 #print("counter", counter) for numeral in training_data[entry][1]: #print ("numeral", numeral) if numeral == 1: answer = counter counter += 1 #print("answer", answer) #print("counter", counter) if answer == 10: answer = "unknown" #print("answer", answer) print("This is supposed to be a ", answer) activations = [] for layer1 in range(hidden_neurons): #activation = sigmoid(np.dot(net.weights[0][layer1], np.transpose(new_number))) activation = sigmoid( np.dot(net.weights[0][layer1], training_data[entry][0])) activations.append(activation) outputs = [] for output_neuron in range(11): output = sigmoid(np.dot(net.weights[1][output_neuron], activations)) outputs.append(output) #print outputs counter = 0 for digit in outputs: print(counter, " ", "|" * int(digit * 100)) counter += 1 entry = input("Which number to display?") for item in win.items[:]: item.undraw()
def update_line(win, cur_layer, prev_layer, i, j): line = Line(cur_layer.neurons[i].position, prev_layer.neurons[j].position) if cur_layer.weights[i][j] < 0: line.setOutline("red") else: line.setOutline("blue") line.setWidth(8 * (sigmoid(abs(cur_layer.weights[i][j])) - 0.5)) line.draw(win)
def backprop(self, x, y): """Return a tuple ``(nabla_b, nabla_w)`` representing the gradient for the cost function C_x. ``nabla_b`` and ``nabla_w`` are layer-by-layer lists of numpy arrays, similar to ``self.biases`` and ``self.weights``.""" # x is a matrix of test data, with each test case indexed in the column direction # y is a matrix of test data answers, with each answer indexed in the column direction # nabla_b represent the derivitives of the biases for each layer # nabla_w represent the derivatives of the weights for each layer nabla_b = [np.zeros(b.shape) for b in self.biases] nabla_w = [np.zeros(w.shape) for w in self.weights] nabla_b = [] nabla_w = [] test_data_len = x.shape[1] for b, w in zip(self.biases, self.weights): nabla_b.append(np.zeros((b.shape[0], test_data_len))) nabla_w.append(np.zeros(w.shape)) # feedforward activation = x activations = [x] # list to store all the activations, layer by layer zs = [] # list to store all the z vectors, layer by layer for b, w in zip(self.biases, self.weights): z = np.dot(w, activation) + b zs.append(z) activation = sigmoid(z) activations.append(activation) # backward pass delta = self.cost_derivative(activations[-1], y) * sigmoid_prime( zs[-1]) nabla_b[-1] = delta nabla_w[-1] = np.dot(delta, activations[-2].transpose()) # Note that the variable l in the loop below is used a little # differently to the notation in Chapter 2 of the book. Here, # l = 1 means the last layer of neurons, l = 2 is the # second-last layer, and so on. It's a renumbering of the # scheme in the book, used here to take advantage of the fact # that Python can use negative indices in lists. for l in xrange(2, self.num_layers): z = zs[-l] sp = 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_b, nabla_w)
def main(): training_data, validation_data, test_data = mnist_loader_with_unknowns.load_data_wrapper( ) print len(training_data) #print len(validation_data) #print len(test_data) hidden_neurons = 100 #input("Enter the number of hidden neurons:") net = network.Network([784, hidden_neurons, 11]) num_of_epochs = 20 #input("Enter the number of epochs:") min_batch_size = 50 #input("Enter the mini-batch size:") net.SGD(training_data, num_of_epochs, min_batch_size, 3.0) #, test_data=test_data) #graphical_output.draw_new_number(training_data[0][0], 10) #print training_data[0][1] size = 20 win = GraphWin('Number', size * 28, size * 28) # give title and dimensions #print type(new_number) new_number = training_data[0][0] graphical_output.update_number(new_number, size, win) revised_training_pairs = [] for new in range(10): new_number = training_data[new][0] target = new #random.randrange(0,10) #int(input("What number do you want to draw?:")) print "Target = ", target #nu2 = 20 #input("Input the learning rate:") #new_number = np.random.rand(784) for gradient in range(20): activations = [] for layer1 in range(hidden_neurons): #activation = sigmoid(np.dot(net.weights[0][layer1], np.transpose(new_number))) activation = sigmoid(np.dot(net.weights[0][layer1], new_number)) activations.append(activation) outputs = [] for output_neuron in range(11): output = sigmoid( np.dot(net.weights[1][output_neuron], activations)) outputs.append(output) #print outputs cost = np.zeros(784) for edit_pixel in range(784): for output_neuron in range(11): level0weights = [] for j in range(hidden_neurons): level0weights.append(net.weights[0][j][edit_pixel]) #print level0weights #print vprime(activations) partial_derivative = np.multiply( level0weights, np.transpose(vprime(activations))) partial_output = prime(outputs[output_neuron]) * np.dot( net.weights[1][output_neuron], np.transpose(partial_derivative)) #print partial_output if output_neuron == target: cost[edit_pixel] = -2 * ( 1 - outputs[output_neuron]) * partial_output else: cost[edit_pixel] = 2 * outputs[ output_neuron] * partial_output nu2 = 0.5 / (np.amax(cost) - np.amin(cost)) for edit_pixel in range(784): new_number[edit_pixel] = min( 1, max(0, new_number[edit_pixel] - nu2 * cost[edit_pixel])) for item in win.items[:]: item.undraw() update_number(new_number, size, win) revised_training_pairs.append((new_number, 10)) for item in win.items[:]: item.undraw() #win = GraphWin('Number', size*28, size*28) # give title and dimensions #print len(revised_training_pairs[0][0]) #print type(revised_training_pairs[0][0]) #graphical_output.update_number(revised_training_pairs[0][0],size,win) #win.getMouse() #for x in range(10): #graphical_output.update_number(revised_training_pairs[x][0],size,win) #win.getMouse() #print outputs #e = np.zeros((11, 1)) #e[10] = 1.0 enter = 1 #input("Do you want to save this back to the MNIST data? (1=y/0=n):") if enter == 1: f = gzip.open('../data/revised-mnist.pkl.gz', 'rb') training_data, validation_data, test_data = cPickle.load(f) f.close() #print type(training_data[1]) #print type(change_to_number(training_data[1])) #print len(change_to_number(training_data[1])) for x, y in zip(training_data[0], training_data[1]): revised_training_pairs.append((x, y)) #revised_training_pairs.append((new_number, 10)) #revised_validation_pairs = [] #for x, y in zip(validation_data[0], validation_data[1]): # revised_validation_pairs.append((x, y)) #revised_test_pairs = [] #for x, y in zip(test_data[0], test_data[1]): # revised_test_pairs.append((x, y)) revised_training_data = [list(d) for d in zip(*revised_training_pairs)] #revised_validation_data = [list(d) for d in zip(*revised_validation_pairs)] #revised_test_data = [list(d) for d in zip(*revised_test_pairs)] #print len(revised_training_data) #print len(revised_validation_data) #print len(revised_test_data) print("Saving expanded data. This may take a few minutes.") f = gzip.open("../data/revised-mnist.pkl.gz", "w") cPickle.dump((revised_training_data, validation_data, test_data), f) f.close()
import network as n p = n.sigmoid(2) print p
def feedforward(a, weight0, weight1): l = a.T b1 = net.sigmoid(np.dot(l, weight0)) b2 = net.sigmoid(np.dot(b1, weight1)) return b2