Esempio n. 1
0
  def __init__(self, hidden_neuron_num=1, hidden_type='sigmoid'):
    self.hidden_neuron_num = hidden_neuron_num
    self.hidden_type = hidden_type

    self.net = FeedForwardNetwork()
    self.samples = SupervisedDataSet(784, 784)

    self.vectorizer = ImageVectorizer()

    self.add_layers()
    self.add_connections()
    self.sort()
Esempio n. 2
0
class NeuralNet:
  def __init__(self, hidden_neuron_num=1, hidden_type='sigmoid'):
    self.hidden_neuron_num = hidden_neuron_num
    self.hidden_type = hidden_type

    self.net = FeedForwardNetwork()
    self.samples = SupervisedDataSet(784, 784)

    self.vectorizer = ImageVectorizer()

    self.add_layers()
    self.add_connections()
    self.sort()

  def add_layers(self):
    self.inLayer = LinearLayer(784, name='in')
    self.outLayer = LinearLayer(784, name='out')

    if self.hidden_type == 'sigmoid':
      self.hiddenLayer = SigmoidLayer(self.hidden_neuron_num, name='hidden')
    else:
      # I found I had to overwrite the output layer to sigmoid to get the 
      # hidden layer to work as linear
      self.hiddenLayer = LinearLayer(self.hidden_neuron_num, name='hidden')
      self.outLayer = SigmoidLayer(784, name='out')

    self.net.addInputModule(self.inLayer)
    self.net.addModule(self.hiddenLayer)
    self.net.addOutputModule(self.outLayer)

  def add_connections(self):
    self.in_to_hidden = FullConnection(self.inLayer, self.hiddenLayer)
    self.hidden_to_out = FullConnection(self.hiddenLayer, self.outLayer)

    self.net.addConnection(self.in_to_hidden)
    self.net.addConnection(self.hidden_to_out)

  def sort(self):
    self.net.sortModules()

  def activate(self, vector):
    return self.net.activate(vector)

  def train(self, paths):
    for path in paths:
      vector = self.vectorizer.image_to_vector(path) 
      vector = numpy.float64([el / 255.0 for el in vector])
      self.samples.addSample(vector, vector)

    trainer = BackpropTrainer(self.net, self.samples, learningrate=.5, lrdecay=0.98)
    for i in range(1,20):
      error = trainer.train()
      print "error for %(i)ith iteration: %(error)f" % locals()

  def input_weights_of_hidden_layer(self):
    weights = self.in_to_hidden.params
    hidden_weights_by_neuron = numpy.split(weights, self.hidden_neuron_num)
    return hidden_weights_by_neuron

  def input_weights_of_out_layer(self):
    weights = self.hidden_to_out.params
    hidden_weights_by_neuron = numpy.split(weights, self.hidden_neuron_num)
    return hidden_weights_by_neuron
Esempio n. 3
0
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), "lib"))

from IPython import embed
from neural_net import NeuralNet
from image_vectorizer import ImageVectorizer


vectorizer = ImageVectorizer()
paths = vectorizer.get_image_paths()

############################################################
################### Assignment Questions ###################
############################################################

############################################################
# Train a feedforward neural network with one hidden layer #
# of size 3 to learn representations of those digits.      #
# Try using (a) Linear transform function                  #
############################################################ 

net_3lin = NeuralNet(3, 'linear')
net_3lin.train(paths)
weights = net_3lin.input_weights_of_hidden_layer()
vectorizer.vectors_to_images(weights, '3_hidden_layer_linear')

############################################################
# (b) Sigmoid transform function for the hidden layer      #
############################################################

net_3sig = NeuralNet(3, 'sigmoid')