def __init__(self, population_size, lamda, archive, landscape,
select_meth):
self.population_size = population_size
self.lamda = lamda
self.select_meth = select_meth
self.archive = archive
self.initializer = Initializer.Initializer(landscape, population_size)
self.landscape = landscape
def __init__(self, master=None, stages={}):
# Initialise GUI
tk.Frame.__init__(self, master)
self.master.title("Prober Control")
self.grid()
# Get instance of Global_MeasureHandler
if g.instance != None:
self.gh = g.instance
# Get Dictionaries of Handles of Stages
self.Stages = stages
# Set Active Stage to first Stage in Dictionary
self.ActiveStage = '-1'
if self.Stages != {}:
dev_names = sorted(self.Stages.keys())
for st in dev_names:
if st[0] == 'O' or st[0] == 'E':
self.ActiveStage = st
break
#print 'Active Stage: ' + self.ActiveStage # why are we printing this?
# Initialize Procedure Handler
self.Maitre = Maitre()
#Gain access to Initializer singleton
self.init = i.Initializer()
# Initialize Standard Values for GUI
self.StatusText = tk.StringVar()
self.CommandText = tk.StringVar()
self.StepText = tk.StringVar()
self.ProcMod = tk.StringVar()
self.ProcFunc = tk.StringVar()
self.ArgText = tk.StringVar()
self.StageMod = tk.StringVar()
self.StageFunc = tk.StringVar()
self.StageArgText = tk.StringVar()
self.Script_Path = ''
self.FileText = tk.StringVar()
if self.ActiveStage != '-1':
self.StepText.set(self.Stages[self.ActiveStage].stepsize)
self.createWidgets()
# Bind Key Strokes To Function
self.bind('<KeyRelease-Left>', self.leftKey)
self.bind('<KeyRelease-Right>', self.rightKey)
self.bind('<KeyRelease-Up>', self.forwardKey)
self.bind('<KeyRelease-Down>', self.backwardKey)
self.bind('<Shift-KeyRelease-Up>',self.upKey)
self.bind('<Shift-KeyRelease-Down>',self.downKey)
def __init__(self,
population_size,
lamda,
archive,
target_structure,
init_depth=10):
self.population_size = population_size
self.init_depth = init_depth
self.lamda = lamda
self.archive = archive
self.initializer = Initializer.Initializer(target_structure,
population_size)
def init(self,
numpy_rng,
theano_rng=None,
l_rate=0.01,
optimization="sgd",
tied=False,
n_visible_left=None,
n_visible_right=None,
n_visible_pivot=None,
n_hidden=None,
lamda=5,
W_left=None,
W_right=None,
W_pivot=None,
b=None,
W_left_prime=None,
W_right_prime=None,
W_pivot_prime=None,
b_prime_left=None,
b_prime_right=None,
b_prime_pivot=None,
input_left=None,
input_right=None,
input_pivot=None,
hidden_activation="sigmoid",
output_activation="sigmoid",
loss_fn="squarrederror",
op_folder=None):
self.numpy_rng = numpy_rng
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2**30))
self.theano_rng = theano_rng
self.optimization = optimization
self.l_rate = l_rate
self.optimizer = get_optimizer(self.optimization, self.l_rate)
self.Initializer = Initializer(self.numpy_rng)
self.n_visible_left = n_visible_left
self.n_visible_right = n_visible_right
self.n_visible_pivot = n_visible_pivot
self.n_hidden = n_hidden
self.lamda = lamda
self.hidden_activation = hidden_activation
self.output_activation = output_activation
self.loss_fn = loss_fn
self.tied = tied
self.op_folder = op_folder
self.W_left = self.Initializer.fan_based_sigmoid(
"W_left", W_left, n_visible_left, n_hidden)
self.optimizer.register_variable("W_left", n_visible_left, n_hidden)
self.W_right = self.Initializer.fan_based_sigmoid(
"W_right", W_right, n_visible_right, n_hidden)
self.optimizer.register_variable("W_right", n_visible_right, n_hidden)
self.W_pivot = self.Initializer.fan_based_sigmoid(
"W_pivot", W_pivot, n_visible_pivot, n_hidden)
self.optimizer.register_variable("W_pivot", n_visible_pivot, n_hidden)
if not tied:
self.W_left_prime = self.Initializer.fan_based_sigmoid(
"W_left_prime", W_left_prime, n_hidden, n_visible_left)
self.optimizer.register_variable("W_left_prime", n_hidden,
n_visible_left)
self.W_right_prime = self.Initializer.fan_based_sigmoid(
"W_right_prime", W_right_prime, n_hidden, n_visible_right)
self.optimizer.register_variable("W_right_prime", n_hidden,
n_visible_right)
self.W_pivot_prime = self.Initializer.fan_based_sigmoid(
"W_pivot_prime", W_pivot_prime, n_hidden, n_visible_pivot)
self.optimizer.register_variable("W_pivot_prime", n_hidden,
n_visible_pivot)
else:
self.W_left_prime = self.W_left.T
self.W_right_prime = self.W_right.T
self.W_pivot_prime = self.W_pivot.T
self.b = self.Initializer.zero_vector("b", b, n_hidden)
self.optimizer.register_variable("b", 1, n_hidden)
self.b_prime_left = self.Initializer.zero_vector(
"b_prime_left", b_prime_left, n_visible_left)
self.optimizer.register_variable("b_prime_left", 1, n_visible_left)
self.b_prime_right = self.Initializer.zero_vector(
"b_prime_right", b_prime_right, n_visible_right)
self.optimizer.register_variable("b_prime_right", 1, n_visible_right)
self.b_prime_pivot = self.Initializer.zero_vector(
"b_prime_pivot", b_prime_pivot, n_visible_pivot)
self.optimizer.register_variable("b_prime_pivot", 1, n_visible_pivot)
if input_left is None:
self.x_left = T.matrix(name='x_left')
else:
self.x_left = input_left
if input_right is None:
self.x_right = T.matrix(name='x_right')
else:
self.x_right = input_right
if input_pivot is None:
self.x_pivot = T.matrix(name='x_pivot')
else:
self.x_pivot = input_pivot
if not tied:
self.params = [
self.W_left, self.W_right, self.W_pivot, self.b,
self.b_prime_left, self.b_prime_right, self.b_prime_pivot,
self.W_left_prime, self.W_right_prime, self.W_pivot_prime
]
self.param_names = [
"W_left", "W_right", "W_pivot", "b", "b_prime_left",
"b_prime_right", "b_prime_pivot", "W_left_prime",
"W_right_prime", "W_pivot_prime"
]
else:
self.params = [
self.W_left, self.W_right, self.W_pivot, self.b,
self.b_prime_left, self.b_prime_right, self.b_prime_pivot
]
self.param_names = [
"W_left", "W_right", "W_pivot", "b", "b_prime_left",
"b_prime_right", "b_prime_pivot"
]
self.proj_from_left = theano.function([self.x_left],
self.project_from_sources([LEFT
]))
self.proj_from_right = theano.function([self.x_right],
self.project_from_sources(
[RIGHT]))
self.proj_from_pivot = theano.function([self.x_pivot],
self.project_from_sources(
[PIVOT]))
self.proj_from_left_pivot = theano.function(
[self.x_left, self.x_pivot],
self.project_from_sources([LEFT, PIVOT]))
self.proj_from_right_pivot = theano.function(
[self.x_right, self.x_pivot],
self.project_from_sources([RIGHT, PIVOT]))
self.proj_from_left_right = theano.function(
[self.x_right, self.x_left],
self.project_from_sources([RIGHT, LEFT]))
self.proj_from_all = theano.function(
[self.x_right, self.x_left, self.x_pivot],
self.project_from_sources([RIGHT, LEFT, PIVOT]))
self.recon_from_left = theano.function([self.x_left],
self.reconstruct_from_sources(
[LEFT]))
self.recon_from_right = theano.function([self.x_right],
self.reconstruct_from_sources(
[RIGHT]))
self.recon_from_pivot = theano.function([self.x_pivot],
self.reconstruct_from_sources(
[PIVOT]))
self.recon_from_left_pivot = theano.function(
[self.x_left, self.x_pivot],
self.reconstruct_from_sources([LEFT, PIVOT]))
self.recon_from_right_pivot = theano.function(
[self.x_right, self.x_pivot],
self.reconstruct_from_sources([RIGHT, PIVOT]))
self.recon_from_right_left = theano.function(
[self.x_right, self.x_left],
self.reconstruct_from_sources([RIGHT, LEFT]))
self.recon_from_all = theano.function(
[self.x_right, self.x_left, self.x_pivot],
self.reconstruct_from_sources([RIGHT, LEFT, PIVOT]))
self.save_params()
def init(self, network, x_left = None, x_right = None, load = False):
self.network = network
numpy_rng = numpy.random.RandomState(123)
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
# Random number generators
self.numpy_rng = numpy_rng
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
self.theano_rng = theano_rng
# Optimization metadata
self.optimizer = get_optimizer(network['optimization'], network['learning_rate']) # Optimizer-object, with containers for weights, learning rate (shared)
# Initialization
self.Initializer = Initializer(self.numpy_rng)
# Set inputs
if x_left != None:
self.x_left = x_left
else:
self.x_left = T.matrix('x_left')
if x_right != None:
self.x_right = x_right
else:
self.x_right = T.matrix('x_right')
self.y_proj = T.matrix('y_proj')
self.params = {}
preload_params = {}
# Initialize/Load params
for layer_name, layer in network['layers'].iteritems():
# Initialize/Load params
for param in layer['params']:
if param + '.npy' in os.listdir(network['params_folder']):
print 'loaded %s' % param
preload_params = os.path.join(network['params_folder'], param)
else:
preload_params = None
if layer_name == 'layer_1' and load == False:
preload_params = None
# Encode weights
if 'W' in param and 'prime' not in param:
self.params[param] = self.Initializer.fan_based_sigmoid(param, preload_params,\
layer['n_in_%s' % param[-1]], layer['n_out'])
self.optimizer.register_variable(param, layer['n_in_%s' % param[-1]], layer['n_out'])
# Decode weights
if 'W_prime' in param:
self.params[param] = self.params[param[0] + 'W_' + param[-1]].T
# Decod Biases
if 'b_prime' in param:
self.params[param] = self.Initializer.zero_vector(param, preload_params,\
layer['n_in_%s' % param[-1]])
self.optimizer.register_variable(param, 1, layer['n_in_%s' % param[-1]])
# Encode bias
if 'b' in param and 'prime' not in param:
self.params[param] = self.Initializer.zero_vector(param, preload_params,\
layer['n_out'])
self.optimizer.register_variable(param, 1, layer['n_out'])
self.proj_from_left = theano.function([self.x_left], self.project_from_left())
self.proj_from_right = theano.function([self.x_right], self.project_from_right())
self.recon_left = theano.function([self.y_proj], self.reconstruct_left())
self.recon_right = theano.function([self.y_proj], self.reconstruct_right())
def init(self, numpy_rng, theano_rng=None, l_rate=0.01, optimization="sgd",
tied=False, n_visible_left=None, n_visible_right=None, n_hidden=None, n_hidden_left=None,
n_hidden_right=None, lamda=5, W_left=None, W_right=None, W_left1=None, W_right1=None,
b=None, W_left_prime=None, W_right_prime=None, W_left_prime1=None, W_right_prime1=None,
b_prime_left=None, b_prime_right=None, b_prime_left1=None, b_prime_right1=None,
input_left=None, input_right=None, hidden_activation_left="sigmoid", hidden_activation_right="sigmoid",
hidden_activation="sigmoid", output_activation="sigmoid", loss_fn = "squarrederror",
op_folder=None):
self.numpy_rng = numpy_rng
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
self.theano_rng = theano_rng
self.optimization = optimization
self.l_rate = l_rate
self.optimizer = get_optimizer(self.optimization, self.l_rate)
self.Initializer = Initializer(self.numpy_rng)
# 2. assign addtional hidden layers here
self.n_visible_left = n_visible_left
self.n_visible_right = n_visible_right
self.n_hidden = n_hidden
self.n_hidden_left = n_hidden_left
self.n_hidden_right = n_hidden_right
# 3. assign activation functions to addditional hidden layers
self.lamda = lamda
self.hidden_activation = hidden_activation
self.output_activation = output_activation
self.hidden_activation_left = hidden_activation_left
self.hidden_activation_right = hidden_activation_right
self.loss_fn = loss_fn
self.tied = tied
self.op_folder = op_folder
# 4. Add 4 weight matrices
self.W_left1 = self.Initializer.fan_based_sigmoid("W_left1", W_left1, n_visible_left, n_hidden_left)
self.optimizer.register_variable("W_left1",n_visible_left,n_hidden_left)
self.W_left = self.Initializer.fan_based_sigmoid("W_left", W_left, n_hidden_left, n_hidden)
self.optimizer.register_variable("W_left",n_hidden_left,n_hidden)
self.W_right1 = self.Initializer.fan_based_sigmoid("W_right1", W_right1, n_visible_right, n_hidden_right)
self.optimizer.register_variable("W_right1",n_visible_right,n_hidden_right)
self.W_right = self.Initializer.fan_based_sigmoid("W_right", W_right, n_hidden_right, n_hidden)
self.optimizer.register_variable("W_right",n_hidden_right,n_hidden)
if not tied:
self.W_left_prime = self.Initializer.fan_based_sigmoid("W_left_prime1", W_left_prime1, n_hidden_left, n_visible_left)
self.optimizer.register_variable("W_left_prime1",n_hidden_left, n_visible_left)
self.W_left_prime = self.Initializer.fan_based_sigmoid("W_left_prime", W_left_prime, n_hidden, n_hidden_left)
self.optimizer.register_variable("W_left_prime",n_hidden, n_hidden_left)
self.W_right_prime = self.Initializer.fan_based_sigmoid("W_right_prime1", W_right_prime1, n_hidden_right, n_visible_right)
self.optimizer.register_variable("W_right_prime1",n_hidden_right, n_visible_right)
self.W_right_prime = self.Initializer.fan_based_sigmoid("W_right_prime", W_right_prime, n_hidden, n_hidden_right)
self.optimizer.register_variable("W_right_prime",n_hidden, n_hidden_right)
else:
self.W_left_prime = self.W_left.T
self.W_right_prime = self.W_right.T
self.W_left_prime1 = self.W_left1.T
self.W_right_prime1 = self.W_right1.T
#5. Add hidden to zero_vector
self.b = self.Initializer.zero_vector("b", b, n_hidden)
self.optimizer.register_variable("b",1,n_hidden)
self.b_prime_left = self.Initializer.zero_vector("b_prime_left", b_prime_left, n_visible_left)
self.optimizer.register_variable("b_prime_left",1,n_visible_left)
self.b_prime_right = self.Initializer.zero_vector("b_prime_right", b_prime_right, n_visible_right)
self.optimizer.register_variable("b_prime_right",1,n_visible_right)
self.b_prime_left1 = self.Initializer.zero_vector("b_prime_left1", b_prime_left1, n_hidden_left)
self.optimizer.register_variable("b_prime_left1",1,n_hidden_left)
self.b_prime_right1 = self.Initializer.zero_vector("b_prime_right1", b_prime_right1, n_hidden_right)
self.optimizer.register_variable("b_prime_right1",1,n_hidden_right)
if input_left is None:
self.x_left = T.matrix(name='x_left')
else:
self.x_left = input_left
if input_right is None:
self.x_right = T.matrix(name='x_right')
else:
self.x_right = input_right
if tied:
self.params = [self.W_left, self.W_right, self.W_right1, self.W_left1, self.b, self.b_prime_left, self.b_prime_right, self.b_prime_left1, self.b_prime_right1]
self.param_names = ["W_left", "W_right", "W_right1", "W_left1," "b", "b_prime_left", "b_prime_right", "b_prime_left1", "b_prime_right1"]
else:
self.params = [self.W_left, self.W_right, self.W_right1, self.W_left1, self.b, self.b_prime_left, self.b_prime_right, self.b_prime_left1, self.b_prime_right1, self.W_left_prime, self.W_right_prime, self.W_left_prime1, self.W_right_prime1]
self.param_names = ["W_left", "W_right", "W_right1", "W_left1," "b", "b_prime_left", "b_prime_right", "b_prime_left1", "b_prime_right1", "W_left_prime", "W_right_prime", "W_left_prime1", "W_right_prime1"]
self.proj_from_left = theano.function([self.x_left],self.project_from_left())
self.proj_from_right = theano.function([self.x_right],self.project_from_right())
self.recon_from_left = theano.function([self.x_left],self.reconstruct_from_left())
self.recon_from_right = theano.function([self.x_right],self.reconstruct_from_right())
self.save_params()
