drop out continue

Author: tinayz

1.JPG

@@ -35,9 +35,9 @@ def setWeightsUpdated(self , updatedWeights):
 for i in range(0 , len(self.neurons)):
 updatedWeightsTemp = updatedWeights[i*x:(i+1)*x]
 self.neurons[i].updateWeights(updatedWeightsTemp)
-#
-#
-#
+
+def dropOut(self , delta):
+self.neurons[delta].
 
 def getOutput(self):
 return self.outputValues

hidden_layer.py

@@ -0,0 +1,46 @@
+import time, random
+import math
+from collections import deque
+
+start = time.time()
+
+class RealtimePlot:
+ def __init__(self, axes, max_entries = 100):
+ self.axis_x = deque(maxlen=max_entries)
+ self.axis_y = deque(maxlen=max_entries)
+ self.axes = axes
+ self.max_entries = max_entries
+ 
+ self.lineplot, = axes.plot([], [], "ro-")
+ self.axes.set_autoscaley_on(True)
+
+ def add(self, x, y):
+ self.axis_x.append(x)
+ self.axis_y.append(y)
+ self.lineplot.set_data(self.axis_x, self.axis_y)
+ self.axes.set_xlim(self.axis_x[0], self.axis_x[-1] + 1e-15)
+ self.axes.relim(); self.axes.autoscale_view() # rescale the y-axis
+
+ def animate(self, figure, callback, interval = 50):
+ import matplotlib.animation as animation
+ def wrapper(frame_index):
+ self.add(*callback(frame_index))
+ self.axes.relim(); self.axes.autoscale_view() # rescale the y-axis
+ return self.lineplot
+ animation.FuncAnimation(figure, wrapper, interval=interval)
+
+def main():
+ from matplotlib import pyplot as plt
+
+ fig, axes = plt.subplots()
+ display = RealtimePlot(axes)
+ display.animate(fig, lambda frame_index: (time.time() - start, random.random() * 100))
+ plt.show()
+
+ fig, axes = plt.subplots()
+ display = RealtimePlot(axes)
+ while True:
+ display.add(time.time() - start, random.random() * 100)
+ plt.pause(0.001)
+
+if __name__ == "__main__": main()

loss_plot.py

@@ -4,6 +4,7 @@
 import math
 from activationFunctions import *
 import random 
+import plot
 
 HIDDEN_LAYER = 2*int(math.sqrt(28*28))
 ROUND = 4
@@ -118,6 +119,10 @@ def runTests(self):
 elif self.choice=='2':
 self.sgdTrain()
 
+else:
+plot.mainFunc(self.hidlay.getWeights(), self.outlay.getWeights())
+
+
 
 
 
@@ -188,9 +193,13 @@ def updateWeights(self, l2_error):
 l1_delta = l1_error*sigmoidDeriv(l1)
 
 syn2 += np.asarray(l1).T.dot(np.asarray(l2_delta))
+<<<<<<< HEAD
 print("len syn2: " , syn2.size)
 # print ("size l1-delta: " , len(l1_delta))
 # syn1 += np.asarray(l0).T.dot(np.asarray(l1_delta))
+=======
+syn1 += l0.T.dot(np.asarray(l1_delta))
+>>>>>>> cce863fbf432d5c05ad85147555395f00eb1812a
 
 self.hidlay.setWeightsUpdated(syn1)
 self.outlay.setWeightsUpdated(syn2)
@@ -218,6 +227,7 @@ def sgdCreateNetworkAndTrain(self):
 self.output_layer_output = self.outlay.getOutput()
 self.sgdTrain()
 
+
 
 
 

neural_net.pdf

@@ -7,25 +7,22 @@ def __init__(self, pixel_values, weights):
 self.weights = np.asarray(weights)
 self.sigma = 0.0
 self.output = 0
+self.dropOut = 0
 
 def calc_sigma(self):
-#print("len of pixel_values",self.pixel_values.size)
-#print("len of weights",self.weights.size)
-#print(type(self.pixel_values))
-#if self.pixel_values == 'null':
-#print("NULL")
-#print("dot : " , np.dot(self.pixel_values, self.weights))
 self.sigma = np.dot(self.pixel_values, self.weights)
-#self.sigma = np.dot(np.squeeze(self.pixel_values), self.weights)
 
 def calc_activation(self):
 self.output = sigmoid(self.sigma)
 
 
 def calc_output(self):
-self.calc_sigma()
-self.calc_activation()
-return self.output
+if self.dropOut==0:
+self.calc_sigma()
+self.calc_activation()
+return self.output
+elif self.dropOut==1:
+return 0
 
 def updateWeights(self, updatedWeights):
 #self.weights = np.array([])
@@ -34,16 +31,18 @@ def updateWeights(self, updatedWeights):
 
 def setNewInput(self, newInput):
 cnt = 0
-#print ("newInput in Neuron: " ,newInput)
 self.pixel_values = np.array([])
-#print("pixel" , self.pixel_values)
 self.pixel_values = np.asarray(newInput)
-#print(len(newInput))
-#print(self.pixel_values.size)
-#print("pixel_values in neuron: " , self.pixel_values)
+
 
 def getWeights(self):
 return self.weights
 
 def getNumOfWeights(self):
 return self.weights.size
+
+def setDropOut(self):
+self.dropOut = 1
+
+def resetDropOut(self):
+self.dropOut = 0

neural_network.png

@@ -1,34 +1,74 @@
-import igraph as ig
+import networkx as nx
+import matplotlib.pyplot as plt
 
 class NetworkShape:
 def __init__(self):
 self.layerOne = 0 
 self.layerTwo = 0
 self.layerThree = 0
+self.G = nx.Graph()
 
 def setLayerNeuronCount(self, lay1=28*28, lay2 = 2*28, lay3 = 10):
 self.layerOne = lay1
 self.layerTwo = lay2
 self.layerThree = lay3
 
 def drawImage(self):
-N = self.layerThree + self.layerTwo + self.layerOne
-Edges = [(i , j) for i in range(self.layerOne) for j in range(self.layerTwo)]
-Edges23 = [(i , j) for i in range(self.layerTwo) for j in range(self.layerThree)]
-Edges.extend(Edges23)
-G=ig.Graph(Edges, directed=False)
-layt=G.layout('kk', dim=3)
+edge=[(u,v) for (u,v,d) in self.G.edges(data=True)]
 
+pos=nx.spring_layout(self.G)
 
-def createNetworkShape():
+nx.draw_networkx_nodes(self.G,pos,node_size=500)
+nx.draw_networkx_edges(self.G,pos,edgelist=edge,
+width=0.5)
+
+labels = nx.get_edge_attributes(self.G,'weight')
+edge_labels=dict([((u,v,),d['weight']) for u,v,d in self.G.edges(data=True)])
+nx.draw_networkx_edge_labels(self.G,pos,edge_labels=edge_labels)
+
+nx.draw_networkx_labels(self.G,pos,font_size=5,font_family='sans-serif')
+
+plt.axis('off')
+plt.savefig("neural_net.pdf") # save as pdf
+plt.show()
+
+def createNodesEdges(self, syn1, syn2):
+for x in range(self.layerOne):
+name = "in "+str(x)
+self.G.add_node(name)
+
+for x in range(self.layerTwo):
+name = "hid "+str(x)
+self.G.add_node(name)
+
+for x in range(self.layerThree):
+name = "out "+str(x)
+self.G.add_node(name)
+
+for x in range(self.layerOne):
+for y in range(self.layerTwo):
+lx = "in "+str(x)
+ly = "hid "+str(y)
+self.G.add_edge(lx, ly,color='r', weight=syn1[x+y])
+
+for x in range(self.layerTwo):
+for y in range(self.layerThree):
+lx = "hid "+str(x)
+ly = "out "+str(y)
+self.G.add_edge(lx, ly, color='b', weight=syn1[x+y])
+
+
+
+
+
+def createNetworkShape(syn1, syn2):
+print("Plot the Network")
 nn = NetworkShape()
 nn.setLayerNeuronCount()
+nn.createNodesEdges(syn1, syn2)
 nn.drawImage()
 
 
 
-def mainFunc():
-createNetworkShape()
-
-if __name__ == '__main__':
-mainFunc()
+def mainFunc(syn1, syn2):
+createNetworkShape(syn1, syn2)