def run_recognition():
training_data_path = "training-data/"
test_data_path = "test-data"
# detection_classifier_path = "opencv/sources/data/lbpcascades/lbpcascade_frontalface_improved.xml"
detection_classifier_path = "opencv/sources/data/haarcascades/haarcascade_frontalface_default.xml"
# detection_classifier_path = "opencv/sources/data/haarcascades_cuda/haarcascade_frontalface_default.xml"
detection_classifier = Initializer.load_detection_classifier(
detection_classifier_path)
name_list = get_name_list(training_data_path)
face_list, label_list = preprocess(training_data_path,
detection_classifier)
trained_recognizer = train_recognizer(face_list,
label_list,
opencv_recognizer_type="LBPH")
for image_name in os.listdir(test_data_path):
image_path = Path(test_data_path, image_name)
img = Initializer.load_image(image_path)
ret_img, ret_code = get_recognition(img, name_list,
detection_classifier,
trained_recognizer)
Initializer.display_img("title", ret_img)
def get_net_pair(self):
net_pair = []
for i in range(len(init.gridParameters(grid_info)['netInfo'])):
twoPinNum = twoPinNum + (
init.gridParameters(grid_info)['netInfo'][i]['numPins'] - 1)
twoPinNumEachNet.append(
init.gridParameters(grid_info)['netInfo'][i]['numPins'] - 1)
def unit_test():
weka_file = "genevia_default.arff"
weka_data = WekaData()
Initializer.init_weka_data(weka_data)
for a in AVAILABLE_ALGORITHMS.keys():
weka_data.addAlgorithm(AVAILABLE_ALGORITHMS[a])
WekaPrimer.write_to_file(weka_data, weka_file)
run_weka(weka_data, weka_file=weka_file)
def test_subgraph_sum(self):
random_graph = ini.make_random_topology(400, 3)
subgraph = ini.find_subgraph(random_graph)
storage_capacity = ini.find_storage_capacity(random_graph, subgraph)
subgraph_capacity_sum = ini.subgraph_capacity_sum(storage_capacity)
self.assertTrue(subgraph_capacity_sum,
type(subgraph_capacity_sum) == list)
def __init__(self, n_in, n_out, ini):
self.input = None
#init W and b using the given initializer
self.W = ini.get_W(n_in, n_out)
self.b = ini.get_b(n_out)
#create instance variables for grad_w and grad_b
self.grad_W = np.zeros(self.W.shape)
self.grad_b = np.zeros(self.b.shape)
def get_num_discarded(data_path, detection_classifier):
discard_total = 0
image_total = 0
dirs = os.listdir(
data_path
) # get names of everything one level below training_data_path
for dir in dirs:
dir_path = Path(data_path, dir)
if os.path.isdir(dir_path): # only keep directories
images = os.listdir(str(dir_path))
for image in images:
image_path = Path(dir_path, image)
if imghdr.what(image_path
) != None: # check to make sure it's an image
img = Initializer.load_image(image_path)
image_total += 1
face_tuple = FaceDetector.get_faces(
img, detection_classifier)
if len(
face_tuple
) <= 0: # if one face detected, keep in training data, else skip
discard_total += 1
continue
return discard_total, image_total
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 detect_faces(img, opencv_classifier):
gray_img = Initializer.cvt2GRAY(
img) # convert to grayscale bc opencv classifiers expect
# get list of coordinates (rectangle) for all faces
#face_list = opencv_classifier.detectMultiScale(gray_img, scaleFactor=1.2, minNeighbors=3) # scalefactor is 1.2 to rescale for faces closer to camera
face_list = opencv_classifier.detectMultiScale(gray_img,
scaleFactor=1.3,
minNeighbors=3)
#print("#faces found: " + str(len(face_list)))
return face_list
def get_faces(img, opencv_classifier):
gray_image = Initializer.cvt2GRAY(img)
face_list = detect_faces(img, opencv_classifier)
ret_list = []
#loop through detected faces
for (x, y, w, h) in face_list:
face_only = gray_image[y:y + w, x:x + h]
face_coord = (x, y, w, h)
ret_list.append((face_only, face_coord))
return ret_list
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 test_anneal_DS(self):
storage_requirments = [1,3,5,6,10,3,20]
random_graph = ini.make_random_topology(400,3)
subgraph = ini.find_subgraph(random_graph)
storage_capacity = ini.find_storage_capacity(random_graph, subgraph)
subgraph_capacity_sum = ini.subgraph_capacity_sum(storage_capacity)
clustered_topology = ini.mark_cluster_in_graph(random_graph, subgraph)
allocated_network_topology = ini.allocate_DS(storage_requirments, subgraph_capacity_sum, storage_capacity, clustered_topology)
solution = sa_ds.solution(allocated_network_topology)
annealed_solution = sa_ds.anneal_DS(solution, allocated_network_topology)
def preprocess(training_data_path, detection_classifier):
face_list = []
label_list = []
dirs = os.listdir(
training_data_path
) # get names of everything one level below training_data_path
label = 0
for dir in dirs:
dir_path = Path(training_data_path, dir)
if os.path.isdir(dir_path): # only keep directories
images = os.listdir(str(dir_path))
discard_count = 0
image_count = 0
for image in images:
image_path = Path(dir_path, image)
if imghdr.what(
image_path) != None: #check to make sure it's an image
img = Initializer.load_image(image_path)
image_count += 1
face_tuple = FaceDetector.get_faces(
img, detection_classifier)
if len(
face_tuple
) == 1: # if one face detected, keep in training data, else skip
face_tuple = face_tuple[0]
else:
#print("No faces or more than one face found in "+ str(image_path) + " so not used")
discard_count += 1
continue
if face_tuple[
0] is not None: # face_tuple[0] = face image in grayscale
face_list.append(face_tuple[0])
label_list.append(label)
else:
print("No face was detected in " + str(image_path) +
" so the image is not used")
print(
str(discard_count) + "/" + str(image_count) +
" images discarded for " + dir)
label += 1
if len(face_list) <= 0:
print("No faces detected in training data -> cannot proceed")
raise SystemExit
return face_list, label_list
def test_neighbour(self):
storage_requirments = [1,3,5,6,10,3,20]
random_graph = ini.make_random_topology(400,3)
subgraph = ini.find_subgraph(random_graph)
storage_capacity = ini.find_storage_capacity(random_graph, subgraph)
subgraph_capacity_sum = ini.subgraph_capacity_sum(storage_capacity)
clustered_topology = ini.mark_cluster_in_graph(random_graph,subgraph)
allocated_network_topology = ini.allocate_DS(storage_requirments, subgraph_capacity_sum, storage_capacity, clustered_topology)
solution = sa_ds.solution(allocated_network_topology)
new_solution = sa_ds.neighbor(solution, allocated_network_topology)
self.assertTrue(new_solution, type(new_solution) == list)
self.assertTrue(len(new_solution) == len(solution))
def test_cost(self):
storage_requirments = [1,3,5,6,10,3,20]
random_graph = ini.make_random_topology(400,3)
subgraph = ini.find_subgraph(random_graph)
storage_capacity = ini.find_storage_capacity(random_graph, subgraph)
subgraph_capacity_sum = ini.subgraph_capacity_sum(storage_capacity)
clustered_topology = ini.mark_cluster_in_graph(random_graph,subgraph)
allocated_network_topology = ini.allocate_DS(storage_requirments, subgraph_capacity_sum, storage_capacity, clustered_topology)
solution = sa_ds.solution(allocated_network_topology)
new_solution = sa_ds.neighbor(solution, allocated_network_topology)
cost = sa_ds.cost(new_solution,allocated_network_topology)
self.assertIsInstance(cost, int)
print(cost)
def run_recog_video():
training_data_path = "vid_train_data/HP_troll_start2/HP_troll_start"
# detection_classifier_path = "opencv/sources/data/lbpcascades/lbpcascade_frontalface_improved.xml"
detection_classifier_path = "opencv/sources/data/haarcascades/haarcascade_frontalface_default.xml"
# detection_classifier_path = "opencv/sources/data/haarcascades_cuda/haarcascade_frontalface_default.xml"
detection_classifier = Initializer.load_detection_classifier(
detection_classifier_path)
name_list = get_name_list(training_data_path)
face_list, label_list = preprocess(training_data_path,
detection_classifier)
trained_recognizer = train_recognizer(face_list,
label_list,
opencv_recognizer_type="LBPH")
video_path = "vid_test_data/HP_troll_trim_start.mp4"
ouput_path = "vid_test_data/HP_troll_trim_start_out.avi"
video_get_recognition(video_path, name_list, detection_classifier,
trained_recognizer, ouput_path)
def test_allocate_DS(self):
storage_requirments = [1, 3, 5, 6, 10, 3, 20]
random_graph = ini.make_random_topology(400, 3)
subgraph = ini.find_subgraph(random_graph)
storage_capacity = ini.find_storage_capacity(random_graph, subgraph)
subgraph_capacity_sum = ini.subgraph_capacity_sum(storage_capacity)
clustered_topology = ini.mark_cluster_in_graph(random_graph, subgraph)
allocated_network_topology = ini.allocate_DS(storage_requirments,
subgraph_capacity_sum,
storage_capacity,
clustered_topology)
self.assertTrue(allocated_network_topology,
type(allocated_network_topology) == nx.Graph)
#!/usr/bin/env python2
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Fri Aug 21 15:56:13 2015
##################################################
from optparse import OptionParser
import Initializer
Initializer.init_path()
from gnuradio import gr
from gnuradio.eng_option import eng_option
from grc_gnuradio import blks2 as grc_blks2
from InputHandlerThread import InputHandlerThread
import osmosdr
from gnuradio import zeromq
class top_block(gr.top_block):
def __init__(self, samp_rate, freq, gain, bw, port):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate
self.gain = gain
self.freq = freq
self.bw = bw
class CorrNet(object):
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, lamda=5,
W_left=None, W_right=None, b=None, W_left_prime=None, W_right_prime=None,
b_prime_left=None, b_prime_right=None, input_left=None, input_right=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_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)
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)
else:
self.W_left_prime = self.W_left.T
self.W_right_prime = self.W_right.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)
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.b, self.b_prime_left, self.b_prime_right]
self.param_names = ["W_left", "W_right", "b", "b_prime_left", "b_prime_right"]
else:
self.params = [self.W_left, self.W_right, self.b, self.b_prime_left, self.b_prime_right, self.W_left_prime, self.W_right_prime]
self.param_names = ["W_left", "W_right", "b", "b_prime_left", "b_prime_right", "W_left_prime", "W_right_prime"]
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()
def train_common(self,mtype="1111"):
y1_pre = T.dot(self.x_left, self.W_left) + self.b
y1 = activation(y1_pre, self.hidden_activation)
z1_left_pre = T.dot(y1, self.W_left_prime) + self.b_prime_left
z1_right_pre = T.dot(y1,self.W_right_prime) + self.b_prime_right
z1_left = activation(z1_left_pre, self.output_activation)
z1_right = activation(z1_right_pre, self.output_activation)
L1 = loss(z1_left, self.x_left, self.loss_fn) + loss(z1_right, self.x_right, self.loss_fn)
y2_pre = T.dot(self.x_right, self.W_right) + self.b
y2 = activation(y2_pre, self.hidden_activation)
z2_left_pre = T.dot(y2, self.W_left_prime) + self.b_prime_left
z2_right_pre = T.dot(y2,self.W_right_prime) + self.b_prime_right
z2_left = activation(z2_left_pre, self.output_activation)
z2_right = activation(z2_right_pre, self.output_activation)
L2 = loss(z2_left, self.x_left, self.loss_fn) + loss(z2_right, self.x_right, self.loss_fn)
y3_pre = T.dot(self.x_left, self.W_left) + T.dot(self.x_right, self.W_right) + self.b
y3 = activation(y3_pre, self.hidden_activation)
z3_left_pre = T.dot(y3, self.W_left_prime) + self.b_prime_left
z3_right_pre = T.dot(y3,self.W_right_prime) + self.b_prime_right
z3_left = activation(z3_left_pre, self.output_activation)
z3_right = activation(z3_right_pre, self.output_activation)
L3 = loss(z3_left, self.x_left, self.loss_fn) + loss(z3_right, self.x_right, self.loss_fn)
y1_mean = T.mean(y1, axis=0)
y1_centered = y1 - y1_mean
y2_mean = T.mean(y2, axis=0)
y2_centered = y2 - y2_mean
corr_nr = T.sum(y1_centered * y2_centered, axis=0)
corr_dr1 = T.sqrt(T.sum(y1_centered * y1_centered, axis=0)+1e-8)
corr_dr2 = T.sqrt(T.sum(y2_centered * y2_centered, axis=0)+1e-8)
corr_dr = corr_dr1 * corr_dr2
corr = corr_nr/corr_dr
L4 = T.sum(corr) * self.lamda
ly4_pre = T.dot(self.x_left, self.W_left) + self.b
ly4 = activation(ly4_pre, self.hidden_activation)
lz4_right_pre = T.dot(ly4,self.W_right_prime) + self.b_prime_right
lz4_right = activation(lz4_right_pre, self.output_activation)
ry4_pre = T.dot(self.x_right, self.W_right) + self.b
ry4 = activation(ry4_pre, self.hidden_activation)
rz4_left_pre = T.dot(ry4,self.W_left_prime) + self.b_prime_left
rz4_left = activation(rz4_left_pre, self.output_activation)
L5 = loss(lz4_right, self.x_right, self.loss_fn) + loss(rz4_left, self.x_left, self.loss_fn)
if mtype=="1111":
print "1111"
L = L1 + L2 + L3 - L4
elif mtype=="1110":
print "1110"
L = L1 + L2 + L3
elif mtype=="1101":
print "1101"
L = L1 + L2 - L4
elif mtype == "0011":
print "0011"
L = L3 - L4
elif mtype == "1100":
print "1100"
L = L1 + L2
elif mtype == "0010":
print "0010"
L = L3
elif mtype == "euc":
print "euc"
L = L5
elif mtype == "euc-cor":
print "euc-cor"
L = L5 - L4
cost = T.mean(L)
gradients = T.grad(cost, self.params)
updates = []
for p,g,n in zip(self.params, gradients, self.param_names):
gr, upd = self.optimizer.get_grad_update(n,g)
updates.append((p,p+gr))
updates.extend(upd)
return cost, updates
def train_left(self):
y_pre = T.dot(self.x_left, self.W_left) + self.b
y = activation(y_pre, self.hidden_activation)
z_left_pre = T.dot(y, self.W_left_prime) + self.b_prime_left
z_left = activation(z_left_pre, self.output_activation)
L = loss(z_left, self.x_left, self.loss_fn)
cost = T.mean(L)
if self.tied:
curr_params = [self.W_left, self.b, self.b_prime_left]
curr_param_names = ["W_left", "b", "b_prime_left"]
else:
curr_params = [self.W_left, self.b, self.b_prime_left, self.W_left_prime]
curr_param_names = ["W_left", "b", "b_prime_left", "W_left_prime"]
gradients = T.grad(cost, curr_params)
updates = []
for p,g,n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(n,g)
updates.append((p,p+gr))
updates.extend(upd)
return cost, updates
def train_right(self):
y_pre = T.dot(self.x_right, self.W_right) + self.b
y = activation(y_pre, self.hidden_activation)
z_right_pre = T.dot(y, self.W_right_prime) + self.b_prime_right
z_right = activation(z_right_pre, self.output_activation)
L = loss(z_right, self.x_right, self.loss_fn)
cost = T.mean(L)
if self.tied:
curr_params = [self.W_right, self.b, self.b_prime_right]
curr_param_names = ["W_right", "b", "b_prime_right"]
else:
curr_params = [self.W_right, self.b, self.b_prime_right, self.W_right_prime]
curr_param_names = ["W_right", "b", "b_prime_right", "W_right_prime"]
gradients = T.grad(cost, curr_params)
updates = []
for p,g,n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(n,g)
updates.append((p,p+gr))
updates.extend(upd)
return cost, updates
def project_from_left(self):
y_pre = T.dot(self.x_left, self.W_left) + self.b
y = activation(y_pre, self.hidden_activation)
return y
def project_from_right(self):
y_pre = T.dot(self.x_right, self.W_right) + self.b
y = activation(y_pre, self.hidden_activation)
return y
def reconstruct_from_left(self):
y_pre = T.dot(self.x_left, self.W_left) + self.b
y = activation(y_pre, self.hidden_activation)
z_left_pre = T.dot(y, self.W_left_prime) + self.b_prime_left
z_right_pre = T.dot(y,self.W_right_prime) + self.b_prime_right
z_left = activation(z_left_pre, self.output_activation)
z_right = activation(z_right_pre, self.output_activation)
return z_left, z_right
def reconstruct_from_right(self):
y_pre = T.dot(self.x_right, self.W_right) + self.b
y = activation(y_pre, self.hidden_activation)
z_left_pre = T.dot(y, self.W_left_prime) + self.b_prime_left
z_right_pre = T.dot(y,self.W_right_prime) + self.b_prime_right
z_left = activation(z_left_pre, self.output_activation)
z_right = activation(z_right_pre, self.output_activation)
return z_left, z_right
def get_lr_rate(self):
return self.optimizer.get_l_rate()
def set_lr_rate(self,new_lr):
self.optimizer.set_l_rate(new_lr)
def save_matrices(self, path):
for p,nm in zip(self.params, self.param_names):
numpy.save(self.op_folder+nm, p.get_value(borrow=True))
def save_params(self):
params = {}
params["optimization"] = self.optimization
params["l_rate"] = self.l_rate
params["n_visible_left"] = self.n_visible_left
params["n_visible_right"] = self.n_visible_right
params["n_hidden"] = self.n_hidden
params["lamda"] = self.lamda
params["hidden_activation"] = self.hidden_activation
params["output_activation"] = self.output_activation
params["loss_fn"] = self.loss_fn
params["tied"] = self.tied
params["numpy_rng"] = self.numpy_rng
params["theano_rng"] = self.theano_rng
# pickle.dump(params,open(self.op_folder+"params.pck","wb"),-1)
def load(self, folder, input_left=None, input_right=None):
plist = pickle.load(open(folder+"params.pck","rb"))
self.init(plist["numpy_rng"], theano_rng=plist["theano_rng"], l_rate=plist["l_rate"],
optimization=plist["optimization"], tied=plist["tied"],
n_visible_left=plist["n_visible_left"], n_visible_right=plist["n_visible_right"],
n_hidden=plist["n_hidden"], lamda=plist["lamda"], W_left=folder+"W_left",
W_right=folder+"W_right", b=folder+"b", W_left_prime=folder+"W_left_prime",
W_right_prime=folder+"W_right_prime", b_prime_left=folder+"b_prime_left",
b_prime_right=folder+"b_prime_right", input_left=input_left, input_right=input_right,
hidden_activation=plist["hidden_activation"], output_activation=plist["output_activation"],
loss_fn = plist["loss_fn"], op_folder=folder)
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, lamda=5,
W_left=None, W_right=None, b=None, W_left_prime=None, W_right_prime=None,
b_prime_left=None, b_prime_right=None, input_left=None, input_right=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_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)
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)
else:
self.W_left_prime = self.W_left.T
self.W_right_prime = self.W_right.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)
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.b, self.b_prime_left, self.b_prime_right]
self.param_names = ["W_left", "W_right", "b", "b_prime_left", "b_prime_right"]
else:
self.params = [self.W_left, self.W_right, self.b, self.b_prime_left, self.b_prime_right, self.W_left_prime, self.W_right_prime]
self.param_names = ["W_left", "W_right", "b", "b_prime_left", "b_prime_right", "W_left_prime", "W_right_prime"]
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()
'q'
): # wait key is time(ms) between frames, press q to exit
break
else:
break
# Release everything if job is finished
cap.release()
out.release()
cv2.destroyAllWindows()
if __name__ == '__main__':
image_path = "HP_test_detect.jpg"
opencv_classifier_path = "opencv/sources/data/haarcascades/haarcascade_frontalface_default.xml"
img = Initializer.load_image(image_path)
#Initializer.display_img("title",img)a
opencv_classifier = Initializer.load_detection_classifier(
opencv_classifier_path)
video_path = "vid_test_data/HP_troll_trim_start2.mp4"
output_path = "vid_test_data/HP_troll_trim_start2_out.mp4"
boxed_img = get_boxed_faces(img, opencv_classifier)
face_only_list = get_faces(img, opencv_classifier)
#Initializer.display_img("boxed", boxed_img)
#for img, coord in face_only_list:
# print(coord)
# Initializer.display_img("face_only", img)
#!/usr/bin/env python2
##################################################
# GNU Radio Python Flow Graph
# Title: Top Block
# Generated: Fri Aug 21 17:31:13 2015
##################################################
from optparse import OptionParser
import Initializer
Initializer.init_path()
from gnuradio import gr
from gnuradio.eng_option import eng_option
from grc_gnuradio import blks2 as grc_blks2
import osmosdr
from gnuradio import blocks
from gnuradio import zeromq
class top_block(gr.top_block):
def __init__(self, samp_rate, freq, gain, bw, port):
gr.top_block.__init__(self, "Top Block")
##################################################
# Variables
##################################################
self.samp_rate = samp_rate
self.gain = gain
self.freq = freq
self.bw = bw
return action
def newFunction():
pass
if __name__ == '__main__':
# Filename corresponds to benchmark to route
# filename = 'small.gr'
filename = '4by4small.gr'
# filename = 'adaptec1.capo70.2d.35.50.90.gr'
# filename = 'sampleBenchmark'
# Getting Net Info
grid_info = init.read(filename)
print(grid_info)
# # # print(init.gridParameters(grid_info)['netInfo'])
#
for item in init.gridParameters(grid_info).items():
print(item)
# # for net in init.gridParameters(grid_info)['netInfo']:
# # print (net)
# init.GridGraph(init.gridParameters(grid_info)).show_grid()
# init.GridGraph(init.gridParameters(grid_info)).pin_density_plot()
#
capacity = GridGraph(init.gridParameters(grid_info)).generate_capacity()
# print(capacity[:,:,0,1])
# gridX, gridY, gridZ= GridGraph(init.gridParameters(grid_info)).generate_grid()
import Initializer, Mutator, Recombiner, Selector, Replacer, Terminator, LocalSearcher
from GeneticAlgorithm import GeneticAlgorithm
from ProblemDefinition import ProblemDefinition
from Benchmark import Benchmark
# Choose your operators
initializer = Initializer.RandomInitializer()
mutator = Mutator.RandomMutator(0.2, dynAdapt=True)
recombiner = Recombiner.CrossoverRecombiner()
selector = Selector.TournamentSelector(s=20, dynAdapt=True)
replacer = Replacer.bottomReplacer()
terminator = Terminator.maxRuntimeTerminator(10)
# Add a local searcher if you want LocalSearcher.Idle() does nothing
localSearcher = LocalSearcher.Idle()
# Set up an example problem
nrMachines, jobRuntimes = Benchmark.benchmark1()
probDef = ProblemDefinition(nrMachines, jobRuntimes)
# Set up GA parameters
popSize = 100
nrOffspring = int(popSize / 10)
# Create Genetic Algorithm instance
GA = GeneticAlgorithm(initializer, selector, recombiner, mutator, replacer,
terminator, probDef, popSize, nrOffspring, localSearcher)
bestIndividual, results = GA.run()
print("best Individuals fitness: ", bestIndividual.fitness)
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())
G[neighbor] = candidateG
H = graph.heuristic(neighbor,pinEnd)
F[neighbor] = G[neighbor] + H
# update capacity
# capacity = gridgraph.updateCapacityRL(capacity,state,action)
raise RuntimeError("A* failed to find a solution")
if __name__ == "__main__":
filename = 'small.gr'
# filename = 'adaptec1.capo70.2d.35.50.90.gr'
# filename = 'sampleBenchmark'
# # Getting Net Info
grid_info = init.read(filename)
# print(grid_info)
# # print(init.gridParameters(grid_info)['netInfo'])
for item in init.gridParameters(grid_info).items():
print(item)
gridParameters = init.gridParameters(grid_info)
# # for net in init.gridParameters(grid_info)['netInfo']:
# init.GridGraph(init.gridParameters(grid_info)).show_grid()
# init.GridGraph(init.gridParameters(grid_info)).pin_density_plot()
# # GridGraph
capacity = gridgraph.GridGraph(init.gridParameters(grid_info)).generate_capacity()
# print(capacity[:,:,0,0])
gridX,gridY,gridZ = gridgraph.GridGraph(init.gridParameters(grid_info)).generate_grid()
# print(gridX[1,1,0])
# print(gridY[1,1,0])
class CorrNet(object):
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 train(self):
y1 = self.x_left
y2 = self.x_right
for layer_count in reversed(range(self.network['num_layers'])):
if layer_count + 1 == 1:
y3 = activation(T.dot(y1, self.params[str(layer_count + 1) + 'W_1']) +\
T.dot(y2, self.params[str(layer_count + 1) + 'W_2']) +\
self.params[str(layer_count + 1) + 'b'],\
self.network['activation'])
y1 = activation(T.dot(y1, self.params[str(layer_count + 1) + 'W_1']) + self.params[str(layer_count + 1) + 'b'], self.network['activation'])
y2 = activation(T.dot(y2, self.params[str(layer_count + 1) + 'W_2']) + self.params[str(layer_count + 1) + 'b'], self.network['activation'])
[z1_left, z2_left, z3_left] = [y1, y2, y3]
[z1_right, z2_right, z3_right] = [y1, y2, y3]
for layer_count in range(self.network['num_layers']):
z1_left = activation(T.dot(z1_left, self.params[str(layer_count + 1) + 'W_prime_1']) + self.params[str(layer_count + 1) + 'b_prime_1'],\
self.network['activation'])
z1_right = activation(T.dot(z1_right, self.params[str(layer_count + 1) + 'W_prime_2']) + self.params[str(layer_count + 1) + 'b_prime_2'],\
self.network['activation'])
z2_left = activation(T.dot(z2_left, self.params[str(layer_count + 1) + 'W_prime_1']) + self.params[str(layer_count + 1) + 'b_prime_1'],\
self.network['activation'])
z2_right = activation(T.dot(z2_right, self.params[str(layer_count + 1) + 'W_prime_2']) + self.params[str(layer_count + 1) + 'b_prime_2'],\
self.network['activation'])
z3_left = activation(T.dot(z3_left, self.params[str(layer_count + 1) + 'W_prime_1']) + self.params[str(layer_count + 1) + 'b_prime_1'],\
self.network['activation'])
z3_right = activation(T.dot(z3_right, self.params[str(layer_count + 1) + 'W_prime_2']) + self.params[str(layer_count + 1) + 'b_prime_2'],\
self.network['activation'])
y1_mean = T.mean(y1, axis=0)
y1_centered = y1 - y1_mean
y2_mean = T.mean(y2, axis=0)
y2_centered = y2 - y2_mean
corr_nr = T.sum(y1_centered * y2_centered, axis=0)
corr_dr1 = T.sqrt(T.sum(y1_centered * y1_centered, axis=0)+1e-8)
corr_dr2 = T.sqrt(T.sum(y2_centered * y2_centered, axis=0)+1e-8)
corr_dr = corr_dr1 * corr_dr2
corr = corr_nr/corr_dr
# Mean is for the batch
recon_loss = {'view1_self' : T.mean(loss(z1_left, self.x_left, self.network['loss_function'])),\
'view1_cross' : T.mean(loss(z1_right, self.x_right, self.network['loss_function'])),\
'view2_self' : T.mean(loss(z2_right, self.x_right, self.network['loss_function'])),\
'view2_cross' : T.mean(loss(z2_left, self.x_left, self.network['loss_function'])),\
'view12_left' : T.mean(loss(z3_left, self.x_left, self.network['loss_function'])),\
'view12_right': T.mean(loss(z3_right, self.x_right, self.network['loss_function']))}
# L1, L2 and L3 are the reconstruction losses, L4 is the correlation loss
L1 = recon_loss['view1_self'] + recon_loss['view1_cross']
L2 = recon_loss['view2_self'] + recon_loss['view2_cross']
L3 = recon_loss['view12_left'] + recon_loss['view12_right']
L4 = T.mean(T.sum(corr)) * self.network['lambda']
# Sum correlation across all dimensions; mean is for the batch
only_corr = T.mean(T.sum(corr))
# Mean cost for this batch
cost = L1 + L2 + L3 - L4
self.param_values = []
self.param_names = []
for param_name, param_value in self.params.iteritems():
if 'W_prime' in param_name:
continue
self.param_values.append(param_value)
self.param_names.append(param_name)
gradients = T.grad(cost, self.param_values)
updates = []
for p,g,n in zip(self.param_values, gradients, self.param_names):
gr, upd = self.optimizer.get_grad_update(n,g)
updates.append((p,p+gr))
updates.extend(upd)
#return cost, updates, T.mean(L1 + L2 + L3), T.mean(only_corr)
return cost, updates, only_corr,\
recon_loss['view1_self'], recon_loss['view1_cross'],\
recon_loss['view2_self'], recon_loss['view2_cross'],\
recon_loss['view12_left'], recon_loss['view12_right']
def project_from_left(self):
y1 = self.x_left
for layer_count in reversed(range(self.network['num_layers'])):
y1 = activation(T.dot(y1, self.params[str(layer_count + 1) + 'W_1']) + self.params[str(layer_count + 1) + 'b'], self.network['activation'])
return y1
def project_from_right(self):
y2 = self.x_right
for layer_count in reversed(range(self.network['num_layers'])):
y2 = activation(T.dot(y2, self.params[str(layer_count + 1) + 'W_2']) + self.params[str(layer_count + 1) + 'b'], self.network['activation'])
return y2
def reconstruct_left(self):
z1 = self.y_proj
for layer_count in range(self.network['num_layers']):
z1 = activation(T.dot(z1, self.params[str(layer_count + 1) + 'W_prime_1']) + self.params[str(layer_count + 1) + 'b_prime_1'], self.network['activation'])
return z1
def reconstruct_right(self):
z2 = self.y_proj
for layer_count in range(self.network['num_layers']):
z2 = activation(T.dot(z2, self.params[str(layer_count + 1) + 'W_prime_2']) + self.params[str(layer_count + 1) + 'b_prime_2'], self.network['activation'])
return z2
def get_lr_rate(self):
return self.optimizer.get_l_rate()
def set_lr_rate(self,new_lr):
self.optimizer.set_l_rate(new_lr)
def save_matrices(self):
print 'saving matrices'
for p,nm in zip(self.param_values, self.param_names):
numpy.save(os.path.join(self.network['params_folder'], nm), p.get_value(borrow=True))
def test_initialization(self):
storage_requirments = [1,3,5]
random_graph = ini.make_random_topology(100,3)
print('hje')
nx.write_edgelist(random_graph, '/home/christopher/IdeaProjects/Genetic_algortihm/graph.gz')
def executePlan(plan):
global poseNumRecorder
start = 0
stop = len(plan)
PRINT("Preparing prescript variables")
for n in range(start, len(plan)):
if "begin" in plan[n]:
if (plan[n]["begin"]) and (start == 0):
start = n
if "end" in plan[n]:
if plan[n]["end"]:
if (n > start and n < stop):
stop = n
PRINT("Start point determined")
commonFolder = CONSTANTS["commonFolder"]
targetFilename = CONSTANTS["targetProtein"]
targetPDBFile = "%s/%s" % (commonFolder, targetFilename)
#radius = CONSTANTS["cullRadiusMeasure"]
#centerResidue = CONSTANTS["cullRadiusResidue"]
permLogLoc = CONSTANTS.get("permLogLoc", None)
#PRINT("Target Alpha Carbon consideration radius: "+str(radius)+" from residue "+str(centerResidue))
#Creates a searchable tree with all the atoms in the target protein
targetAll = PDBTools.Peptide(
PDBTools.readPDBSelectively(targetPDBFile,
CONSTANTS["targetProteinChain"])
) #PDBTools.readPDBFile(commonFolder+"/"+targetFilename)[0]
targetTree = KDTree.KDTree.loadAtomArray(targetAll.atoms)
PRINT("Ensuring base water file exists")
if BaseWaters.shouldGenerateBaseWaterFile(CONSTANTS):
PRINT("Creating base waters")
baseWaters = BaseWaters.makeBaseWaters(CONSTANTS, targetTree,
targetAll)
baseWaters = BaseWaters.setupBaseWaters(CONSTANTS)
PRINT("Base Waters Scored")
fixvarfile = None
currentPoseData = None
waterData = None
if (start > 0):
PRINT("Prior Quant Record " + str(start))
seq = priorSeq(plan, start)
currentFolder = priorPlanFolder(plan, start)
if (currentFolder != "__START__"):
poseNumRecorder = Log.QuantityLog(plan[start], seq)
poseNumRecorder.top = top
os.chdir(currentFolder)
PRINT("Loading Fixvar")
fixvarfile = Fixvar.Fixvar()
fixvarfile.setBB(ZMAT.ZMAT(zmatLoc(priorTMDstep(plan, start))))
PRINT("Trying to load CPF")
try:
currentPoseData = Permutations.PeptidePermutations.readCPF(
"all.cpf")
currentPoseData.linkToFixvar(fixvarfile)
except:
PRINT(traceback.format_exc())
PRINT("Could not load CPF")
priorCullType = priorCullStep(plan, start)
if (priorCullType is not None):
cullFilename = priorCullType + "Cull.pos"
print("PCT ", priorCullType)
PRINT("Loading which poses were culled during last " +
priorCullType + " cull")
currentPoseData.applySavedCull(cullFilename)
else:
print("No prior cull")
#if not "sequence" in plan[start]:
#poseNumRecorder.setSequence()
#poseNumRecorder.alignStep(plan[start]):
else:
poseNumRecorder = Log.QuantityLog()
PRINT("New Quant Record")
for n in range(start, stop):
if (plan[n]["type"] in TMD_Like_Steps):
currentFolder = top + "/" + plan[n]["folder"]
try:
os.stat(currentFolder)
except:
os.mkdir(currentFolder)
PRINT("\n\n\n")
poseNumRecorder.setSequence(plan[n]["sequence"])
recorder.write("********************\n")
PRINT("Starting Script on Peptide " + plan[n]["sequence"])
recorder.write("********************\n")
os.chdir(currentFolder)
PRINT(Log.timeString())
if (plan[n]["type"] == "TMD"):
ZMAT.createZMAT(zmatLoc(plan[n]))
numNewPoses = TMD.runTMD(CONSTANTS, plan[n], fixvarfile, recorder)
poseNumRecorder.recordStep(Log.QuantityLog.TMD, numNewPoses)
PRINT("TMD Calcs finished at " + Log.timeString())
PRINT("\tPoses created " + str(numNewPoses))
if isBBGrow(plan, n):
if (n == 0):
fixvarfile = Fixvar.Fixvar()
PRINT(Log.timeString())
recorder.copyLog()
seeker = HBond.PerfectHydrogenBondSeeker(
CONSTANTS, plan[n], fixvarfile, targetTree)
seeker.analyzeAllPoses()
fixvarfile = seeker.conclude()
del seeker
poseNumRecorder.recordStep(Log.QuantityLog.HBSEEK,
fixvarfile.numGood())
else:
fixvarfile = Fixvar.Fixvar()
fixvarfile.setBB(ZMAT.ZMAT(zmatLoc(plan[n])))
PRINT("")
recorder.copyLog()
PRINT(Log.timeString())
#makeOnePDB(plan[n],fixvarfile)
PRINT("Calculating Pose Coordinates")
#currentPoseData = Permutations.PeptidePermutations.readPDB("makeOnePDB/All.pdb")
currentPoseData = createPeptidePermutations(
plan[n], fixvarfile, targetTree)
#PRINT("GOOD POSES: "+str(currentPoseData.numGood()))
#currentPoseData.linkToFixvar(fixvarfile)
PRINT("Saving dense pose file")
currentPoseData.saveFile("all.cpf")
if isBBGrow(plan, n):
PRINT("Running extendibility cull")
extendibilityCull(targetTree, getNextBBGrowStep(plan, n),
currentPoseData)
shutil.copy(getHelperScriptPath("GUI"),
CONSTANTS["HelperScripts"]["GUI"]["file"])
PRINT("")
recorder.copyLog()
PRINT(Log.timeString())
PRINT("TMD step Complete")
elif (plan[n]["type"] == "initCTerminal"):
import Initializer
Initializer.initCTerminal(plan[n], CONSTANTS, targetAll)
PRINT("Initial Routine Sucessful")
fixvarfile = Fixvar.Fixvar()
PRINT("")
recorder.copyLog()
PRINT(Log.timeString())
PRINT("Calculating Pose Coordinates")
currentPoseData = createPeptidePermutations(
plan[n], fixvarfile, targetTree)
PRINT("GOOD POSES: " + str(currentPoseData.numGood()))
#currentPoseData.linkToFixvar(fixvarfile)
PRINT("Saving dense pose file")
currentPoseData.saveFile("all.cpf")
shutil.copy(getHelperScriptPath("GUI"),
CONSTANTS["HelperScripts"]["GUI"]["file"])
PRINT("")
recorder.copyLog()
PRINT(Log.timeString())
PRINT("Initiation step Complete")
else:
if "folder" in plan[n]:
currentFolder = top + "/" + plan[n]["folder"]
os.chdir(currentFolder)
else:
currentFolder = priorPlanFolder(plan, n)
if (currentFolder != "__START__"):
os.chdir(currentFolder)
if (plan[n]["type"] == "seekHB"):
raise Exception("Classic Hbond seek feature removed")
if (plan[n]["type"] == "water"):
recorder.write("********************\n")
PRINT("Starting water on Peptide " + priorSeq(plan, n))
recorder.write("********************\n")
PRINT(Log.timeString())
recorder.copyLog()
highRes = PDBTools.lastResidueNum()
hydrogenPoseData, waterData = RunWatGen(currentPoseData)
PRINT(Log.timeString())
os.chdir(currentFolder)
zzz = ZMAT.ZMAT(zmatLoc(priorSeq(plan, n, False)))
zzz.readReference(CONSTANTS)
scorePoses(currentPoseData, hydrogenPoseData, waterData, zzz,
baseWaters)
#RunWatAnalysis(currentPoseData,hydrogenPoseData,waterData,fixvarfile,targetTree)
PRINT(Log.timeString())
os.chdir(currentFolder)
PRINT("")
recorder.copyLog()
os.chdir(currentFolder)
#applyEnergyToFixvar(currentPoseData)
if (plan[n]["type"] == "noWater"):
recorder.write("********************\n")
PRINT("Faking water on Peptide " + priorSeq(plan, n))
recorder.write("********************\n")
PRINT(Log.timeString())
recorder.copyLog()
highRes = PDBTools.lastResidueNum()
hydrogenPoseData, waterData = FakeWatGen(currentPoseData)
PRINT(Log.timeString())
os.chdir(currentFolder)
zzz = ZMAT.ZMAT(zmatLoc(priorSeq(plan, n, False)))
zzz.readReference(CONSTANTS)
scorePoses(currentPoseData, hydrogenPoseData, waterData, zzz,
baseWaters)
#RunWatAnalysis(currentPoseData,hydrogenPoseData,waterData,fixvarfile,targetTree)
PRINT(Log.timeString())
os.chdir(currentFolder)
PRINT("")
recorder.copyLog()
os.chdir(currentFolder)
#applyEnergyToFixvar(currentPoseData)
if (plan[n]["type"] == "analysis"):
recorder.write("********************\n")
PRINT("Starting only analysis on Peptide " + priorSeq(plan, n))
recorder.write("********************\n")
if (waterData is None):
PRINT("NEED TO LOAD CURRENT POSE DATA")
#currentPoseData = Permutations.PeptidePermutations.readCPF("All.cpf")
#currentPoseData.linkToFixvar(fixvarfile)
hydrogenPoseData = Permutations.PeptidePermutations.readCPF(
"AllH.cpf")
waterData = Permutations.WaterPermutations.readCWF("Water.cwf")
PRINT("FILES LOADED")
PRINT(Log.timeString())
os.chdir(currentFolder)
#RunWatAnalysis(currentPoseData,hydrogenPoseData,waterData,fixvarfile,targetTree)
zzz = ZMAT.ZMAT(zmatLoc(priorSeq(plan, n, False)))
zzz.readReference(CONSTANTS)
scorePoses(currentPoseData, hydrogenPoseData, waterData, zzz,
baseWaters)
PRINT(Log.timeString())
os.chdir(currentFolder)
PRINT("")
recorder.copyLog()
os.chdir(currentFolder)
#applyEnergyToFixvar(currentPoseData)
if (plan[n]["type"] == "atomCull"):
if not fixvarfile.energyInfo:
if (os.path.isfile("ETable.tsv")):
currentPoseData.applyEnergyToFixvar()
recorder.write("********************\n")
PRINT("Culling poses by side-chain redundancy")
recorder.write("********************\n")
atomCull(fixvarfile, plan[n])
if (n < len(plan) - 1):
if not (plan[n + 1]["type"] == "atomCull"):
PRINT("Saving output")
atomCullReviseOutputs(currentPoseData)
PRINT("Done with cull")
PRINT("\tRetained poses: " + str(fixvarfile.numGood()))
if (plan[n]["type"] == "backboneCull"):
if not fixvarfile.energyInfo:
if (os.path.isfile("ETable.tsv")):
currentPoseData.applyEnergyToFixvar()
else:
raise Exception("Must have energy data to run this cull")
recorder.write("********************\n")
PRINT("Culling poses by backbone similiarity")
recorder.write("********************\n")
backboneCull(currentPoseData, plan[n])
PRINT("Done with cull")
PRINT("\tRetained poses: " + str(fixvarfile.numGood()))
if (plan[n]["type"] == "ControlCompare"):
recorder.write("********************\n")
PRINT(
"Producing ordered list of resemblance to known structure\nNot using energy data"
)
recorder.write("********************\n")
anchor = plan[n].get("anchor", None)
makeLMSTableWithoutWatgen(currentPoseData, anchor)
if (plan[n]["type"] == "KnownCompare"):
recorder.write("********************\n")
PRINT("Producing ordered list of resemblance to known structure")
recorder.write("********************\n")
anchor = plan[n].get("anchor", None)
ETable.extendETable(CONSTANTS, currentPoseData, anchor)
priorCullType = priorCullStep(plan, n)
if priorCullType is not None:
PRINT("PriorCullType " + str(priorCullType))
PRINT("Producing table of poses that still remain")
cutControlTable(priorCullType)
if (plan[n]["type"] == "waterCull"):
if not fixvarfile.energyInfo:
if (os.path.isfile("ETable.tsv")):
currentPoseData.applyEnergyToFixvar()
else:
raise Exception(
"Cannot perform water cull without WATGEN and scoring")
recorder.write("********************\n")
PRINT("Culling peptide by water energies")
recorder.write("********************\n")
if ((plan[n]["method"] == "50P_Energy")
or (plan[n]["method"] == "fracMaxEnergy")):
frac = plan[n]["threshold"]
PRINT("Threshold of max method with threshold " + str(frac))
WaterCull.thresholdOfMaxEnergy(plan[n], currentPoseData)
PRINT("\tNumber of poses retained:" +
str(currentPoseData.numGood()))
poseNumRecorder.recordStep(Log.QuantityLog.WAT_CULL,
currentPoseData.numGood(),
"Within " + str(frac * 100) + "%")
if (plan[n]["method"] == "top"):
topNum = plan[n]["liminalNumber"]
WaterCull.topWaters(plan[n], currentPoseData)
PRINT("Top %i poses in terms of water energy" % topNum)
poseNumRecorder.recordStep(Log.QuantityLog.WAT_CULL,
currentPoseData.numGood(),
"Top %i" % topNum)
if (plan[n]["method"] == "rubber"):
WaterCull.rubberTopWaters(plan[n], currentPoseData)
PRINT("Performing water cull with \"rubber\" retension")
poseNumRecorder.recordStep(
Log.QuantityLog.WAT_CULL, currentPoseData.numGood(),
"Top " + str(currentPoseData.numGood()))
if (plan[n]["method"] == "stochastic"):
WaterCull.stochasticWaterCull(plan[n], currentPoseData)
PRINT("Performing stochastic cull")
poseNumRecorder.recordStep(Log.QuantityLog.WAT_CULL,
currentPoseData.numGood(),
"Stochastic")
if (plan[n]["method"] == "delta"):
PRINT("Delta Cull")
delta = WaterCull.getDeltaFrac(top, plan, n)
PRINT("Culling poses at %3.1f%% Threshold" % (delta * 100))
fakeStep = {"threshold": delta, "relative": True}
WaterCull.thresholdOfMaxEnergy(fakeStep, currentPoseData)
PRINT("\tNumber of poses retained:" +
str(currentPoseData.numGood()))
poseNumRecorder.recordStep(Log.QuantityLog.WAT_CULL,
currentPoseData.numGood(),
"Within %3.1f%%" % (delta * 100))
if (plan[n]["type"] == "distCull"):
res = plan[n].get("residue", None)
if res is None:
lastStep = priorGly(plan, n)
atmNum = lastStep["variableTorsions"][0]["atom"]
res = ZMAT.residueNumber(zmatLoc(lastStep), atmNum)
PRINT("Last res: " + str(res))
distCull(targetTree, plan[n], currentPoseData, res)
if (plan[n]["type"] == "overlayCull"):
if not fixvarfile.energyInfo:
if (os.path.isfile("ETable.tsv")):
currentPoseData.applyEnergyToFixvar()
else:
raise Exception(
"Cannot perform water cull without WATGEN and scoring")
recorder.write("********************\n")
PRINT("Overlay Cull")
recorder.write("********************\n")
import OverlayCull
OverlayCull.findOverlays(currentPoseData)
if (plan[n]["type"] == "validityCheck"):
recorder.write("********************\n")
PRINT("Culling peptide by distance from protein")
recorder.write("********************\n")
PRINT(Log.timeString())
recorder.copyLog()
validityCheck(targetTree, plan[n], currentPoseData)
PRINT(Log.timeString())
recorder.copyLog()
if (plan[n]["type"] == "gate"):
recorder.write("********************\n")
PRINT("Applying logic gate")
if (plan[n]["method"] == "fewerPoses"):
PRINT("FEATURE NOT YET IMPLEMENTED")
recorder.write("********************\n")
if (plan[n]["type"] == "ScoreControl"):
recorder.write("********************\n")
PRINT("Scoring segment of XRay Control")
scSeq = plan[n]["sequence"]
scSeqString = "\tSequence: " + scSeq
scStartRes = plan[n].get("anchor", None)
if scStartRes is not None:
if isinstance(scStartRes, int):
scSeqString += "\t starting at residue " + str(scStartRes)
elif isinstance(scStartRes, str):
if (scStartRes.upper() == "N"):
scSeqString += "\t starting with the most N-terminal match"
if (scStartRes.upper() == "C"):
scSeqString += "\t starting with the most C-terminal match"
PRINT(scSeqString)
recorder.write("********************\n")
currentFolder = top + "/" + scSeq
try:
os.stat(currentFolder)
except:
os.mkdir(currentFolder)
os.chdir(currentFolder)
scoreControlPeptide(plan[n])
shutil.copy(getHelperScriptPath("GUI"),
CONSTANTS["HelperScripts"]["GUI"]["file"])
shutil.copy(commonFolder + "/out.pdb", currentFolder + "/out.pdb")
currentPoseData = Permutations.PeptidePermutations.readCPF(
"all.cpf")
hydrogenPoseData, waterData = RunWatGen(currentPoseData)
zzz = ZMAT.ZMAT(zmatLoc(priorSeq(plan, n, False)))
zzz.readReference(CONSTANTS)
currentPoseData.fixvar = Fixvar.Fixvar(file=None)
currentPoseData.fixvar.poses.append(Fixvar.FixvarPoses([], 1))
scorePoses(currentPoseData, hydrogenPoseData, waterData, zzz,
baseWaters)
if (plan[n]["type"] == "CollectControl"):
os.chdir(top)
headerWriten = False
xrayGrandTable = open("XrayGrandTable.tsv", 'w')
for xrayStep in plan:
if (xrayStep["type"] == "ScoreControl"):
xrayInf = open(
"%s/%s/ETable.tsv" % (top, xrayStep["sequence"]), 'r')
header = xrayInf.readline()
if not headerWriten:
xrayGrandTable.write(header)
headerWriten = True
xrayData = xrayInf.readline().split("\t")
xrayData[0] = xrayStep["sequence"]
xrayLine = "\t".join(xrayData)
xrayGrandTable.write(xrayLine)
xrayGrandTable.close()
if (plan[n]["type"] == "Consensus"):
if not fixvarfile.energyInfo:
if (os.path.isfile("ETable.tsv")):
currentPoseData.applyEnergyToFixvar()
consensusPose(currentPoseData)
PRINT("Script Complete")
sRemove(top + "/log_current.txt")
timeDifference = int(time.time() - Log.startTime)
PRINT("Time to completetion: " + Log.secondsToHMS(timeDifference))
PRINT("Time to completetion (seconds): " + str(timeDifference))
PRINT("\n\nPose Counts:\n" + poseNumRecorder.dump())
recorder.close()
poseNumRecorder.close()
self.curr_time += diffuser.dt
self.plotter.plot()
if __name__ == "__main__":
cap = 0.0089285714
tissue = 0.00892916955592076
# the m values below are tuned for 40% saturation diffusing out of the capillaries and 60% remaining inside the capillaries
# m values for 2x2, four way: m = .228
# m values for 3x3, four way: m = .105
# m values for 2x2, eight way: m = .2513
# m values for 3x3, eight way: m = .098
# the observed area, initial capillary value, initial tissue value, and fraction of capillaries "dead" (diffusing normally without replenishment) can be changed here.
initializer = Initializer.Initializer3x3(
rows=200, cols=200, cap=cap / 4, tissue=cap / 4,
fraction_dead=.25) # to view the 2x2 layout, replace 3x3 with 2x2
# the tissue death threshold, and live tissue consumption can be changed here.
diffuser = Diffuser.DiffuserEightWay(
initializer.tissue,
initializer.caps,
initializer.cap_value,
death_tissue=cap * .05,
m=.098) # to view the four way diffusion, replace Eight with Four
# Comment / uncomment out the plotters below to generate different plots
plotter = Plotter.InteractivePlotter(
cap=initializer.cap_value
) # shows the visual evolution of the system over time,
# capillaries can be turned off in real time, and time steps can be iterated through by pressing space
class BridgeCorrNet(object):
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 get_corr_loss(self, y1, y2):
y1_mean = T.mean(
y1, axis=0
) # Find mean for each dimension (columns) over all samples (rows)
y1_centered = y1 - y1_mean
y2_mean = T.mean(y2, axis=0)
y2_centered = y2 - y2_mean
corr_nr = T.sum(y1_centered * y2_centered, axis=0)
# y1_centered * y2_centered finds the dimension-wise (column-wise) product of the mean centered value VECTORS
# For a matrix, * does element wise ops
# T.sum with axis=0 sums of the dimension-wise products over all samples
corr_dr1 = T.sqrt(T.sum(y1_centered * y1_centered, axis=0) + 1e-8)
corr_dr2 = T.sqrt(T.sum(y2_centered * y2_centered, axis=0) + 1e-8)
corr_dr = corr_dr1 * corr_dr2
corr = corr_nr / corr_dr # dimension(column)-wise division
L = T.sum(
corr
) * self.lamda # adds each dimension's correlation together to get a scalar
return (L)
def train_common(self, mtype="1111"):
[z1_right, z1_left, z1_pivot] = self.reconstruct_from_sources([LEFT])
L_left_only = loss(z1_left, self.x_left, self.loss_fn) + loss(
z1_right, self.x_right, self.loss_fn) + loss(
z1_pivot, self.x_pivot, self.loss_fn)
[z2_right, z2_left, z2_pivot] = self.reconstruct_from_sources([RIGHT])
L_right_only = loss(z2_left, self.x_left, self.loss_fn) + loss(
z2_right, self.x_right, self.loss_fn) + loss(
z2_pivot, self.x_pivot, self.loss_fn)
[z_right, z_left, z_pivot] = self.reconstruct_from_sources([PIVOT])
L_pivot_only = loss(z_left, self.x_left, self.loss_fn) + loss(
z_right, self.x_right, self.loss_fn) + loss(
z_pivot, self.x_pivot, self.loss_fn)
[z3_right, z3_left,
z3_pivot] = self.reconstruct_from_sources([RIGHT, LEFT, PIVOT])
L_all_recon = loss(z3_left, self.x_left, self.loss_fn) + loss(
z3_right, self.x_right, self.loss_fn) + loss(
z3_pivot, self.x_pivot, self.loss_fn)
[z6_right, z6_left,
z6_pivot] = self.reconstruct_from_sources([RIGHT, LEFT])
L_right_left = loss(z6_left, self.x_left, self.loss_fn) + loss(
z6_right, self.x_right, self.loss_fn) + loss(
z6_pivot, self.x_pivot, self.loss_fn)
[z7_right, z7_left,
z7_pivot] = self.reconstruct_from_sources([RIGHT, PIVOT])
L_right_pivot = loss(z7_left, self.x_left, self.loss_fn) + loss(
z7_right, self.x_right, self.loss_fn) + loss(
z7_pivot, self.x_pivot, self.loss_fn)
[z8_right, z8_left,
z8_pivot] = self.reconstruct_from_sources([LEFT, PIVOT])
L_left_pivot = loss(z8_left, self.x_left, self.loss_fn) + loss(
z8_right, self.x_right, self.loss_fn) + loss(
z8_pivot, self.x_pivot, self.loss_fn)
L3 = L_pivot_only + L_all_recon + L_right_left + L_right_pivot + L_left_pivot
y1 = self.project_from_sources([LEFT])
y2 = self.project_from_sources([RIGHT])
y3 = self.project_from_sources([PIVOT])
L_corr_right_left = self.get_corr_loss(y1, y2)
L_corr_left_pivot = self.get_corr_loss(y1, y3)
L_corr_right_pivot = self.get_corr_loss(y2, y3)
L4 = L_corr_right_left + L_corr_left_pivot + L_corr_right_pivot
L5 = loss(z1_pivot, self.x_pivot, self.loss_fn) + loss(z1_right, self.x_right, self.loss_fn) + \
loss(z2_pivot, self.x_pivot, self.loss_fn) + loss(z2_left, self.x_left, self.loss_fn) + \
loss(z_left, self.x_left, self.loss_fn) + loss(z_right, self.x_right, self.loss_fn)
if mtype == "1111":
print "1111"
L = L_left_only + L_right_only + L3 - L4 # L5 not needed since it is already covered in L_left_ony, L_right_only
# and L_pivot_only
elif mtype == "1110":
print "1110"
L = L_left_only + L_right_only + L3
elif mtype == "1101":
print "1101"
L = L_left_only + L_right_only - L4
elif mtype == "0011":
print "0011"
L = L3 - L4
elif mtype == "1100":
print "1100"
L = L_left_only + L_right_only
elif mtype == "0010":
print "0010"
L = L3
elif mtype == "euc":
print "euc"
L = L5
elif mtype == "euc-cor":
print "euc-cor"
L = L5 - L4
elif mtype == "all":
L = L_left_only
cost = T.mean(L)
gradients = T.grad(cost, self.params)
updates = []
for p, g, n in zip(self.params, gradients, self.param_names):
gr, upd = self.optimizer.get_grad_update(n, g)
updates.append((p, p + gr))
updates.extend(upd)
return cost, updates
def train_left_pivot(self, mtype="1111"):
[z1_right, z1_left, z1_pivot] = self.reconstruct_from_sources([LEFT])
L_left = loss(z1_left, self.x_left, self.loss_fn) + loss(
z1_pivot, self.x_pivot, self.loss_fn)
[z_right, z_left, z_pivot] = self.reconstruct_from_sources([PIVOT])
L_pivot = loss(z_left, self.x_left, self.loss_fn) + loss(
z_pivot, self.x_pivot, self.loss_fn)
[z8_right, z8_left,
z8_pivot] = self.reconstruct_from_sources([LEFT, PIVOT])
L_left_pivot = loss(z8_left, self.x_left, self.loss_fn) + loss(
z8_pivot, self.x_pivot, self.loss_fn)
y1 = self.project_from_sources([LEFT])
y3 = self.project_from_sources([PIVOT])
L_corr_left_pivot = self.get_corr_loss(y1, y3)
L4 = L_corr_left_pivot
L5 = loss(z1_pivot, self.x_pivot, self.loss_fn) + loss(
z_left, self.x_left, self.loss_fn)
if mtype == "1111":
print "1111"
L = L_left + L_pivot + L_left_pivot - L4
elif mtype == "1110":
print "1110"
L = L_left + L_pivot + L_left_pivot
elif mtype == "1101":
print "1101"
L = L_left + L_pivot - L4
elif mtype == "0011":
print "0011"
L = L_left_pivot - L4
elif mtype == "1100":
print "1100"
L = L_left + L_pivot
elif mtype == "0010":
print "0010"
L = L_left_pivot
elif mtype == "euc":
print "euc"
L = L5
elif mtype == "euc-cor":
print "euc-cor"
L = L5 - L4
elif mtype == "all":
L = L_left
cost = T.mean(L)
if self.tied:
curr_params = [
self.W_left, self.W_pivot, self.b, self.b_prime_left,
self.b_prime_pivot
]
curr_param_names = [
"W_left", "W_pivot", "b", "b_prime_left", "b_prime_pivot"
]
else:
curr_params = [
self.W_left, self.W_pivot, self.b, self.b_prime_left,
self.b_prime_pivot, self.W_left_prime, self.W_pivot_prime
]
curr_param_names = [
"W_left", "W_pivot", "b", "b_prime_left", "b_prime_pivot"
"W_left_prime", "W_pivot_prime"
]
gradients = T.grad(cost, curr_params)
updates = []
for p, g, n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(n, g) # upd is empty list
updates.append((p, p + gr))
updates.extend(upd)
return cost, updates
def train_right_pivot(self, mtype="1111"):
[z1_right, z1_left, z1_pivot] = self.reconstruct_from_sources([RIGHT])
L_right = loss(z1_right, self.x_right, self.loss_fn) + loss(
z1_pivot, self.x_pivot, self.loss_fn)
[z_right, z_left, z_pivot] = self.reconstruct_from_sources([PIVOT])
L_pivot = loss(z_right, self.x_right, self.loss_fn) + loss(
z_pivot, self.x_pivot, self.loss_fn)
[z8_right, z8_left,
z8_pivot] = self.reconstruct_from_sources([RIGHT, PIVOT])
L_right_pivot = loss(z8_right, self.x_right, self.loss_fn) + loss(
z8_pivot, self.x_pivot, self.loss_fn)
y1 = self.project_from_sources([RIGHT])
y3 = self.project_from_sources([PIVOT])
L_corr_right_pivot = self.get_corr_loss(y1, y3)
L4 = L_corr_right_pivot
L5 = loss(z1_pivot, self.x_pivot, self.loss_fn) + loss(
z_right, self.x_right, self.loss_fn)
if mtype == "1111":
print "1111"
L = L_right + L_pivot + L_right_pivot - L4
elif mtype == "1110":
print "1110"
L = L_right + L_pivot + L_right_pivot
elif mtype == "1101":
print "1101"
L = L_right + L_pivot - L4
elif mtype == "0011":
print "0011"
L = L_right_pivot - L4
elif mtype == "1100":
print "1100"
L = L_right + L_pivot
elif mtype == "0010":
print "0010"
L = L_right_pivot
elif mtype == "euc":
print "euc"
L = L5
elif mtype == "euc-cor":
print "euc-cor"
L = L5 - L4
elif mtype == "all":
L = L_right
cost = T.mean(L)
if self.tied:
curr_params = [
self.W_right, self.W_pivot, self.b, self.b_prime_right,
self.b_prime_pivot
]
curr_param_names = [
"W_right", "W_pivot", "b", "b_prime_right", "b_prime_pivot"
]
else:
curr_params = [
self.W_right, self.W_pivot, self.b, self.b_prime_right,
self.b_prime_pivot, self.W_right_prime, self.W_pivot_prime
]
curr_param_names = [
"W_right", "W_pivot", "b", "b_prime_right", "b_prime_pivot"
"W_right_prime", "W_pivot_prime"
]
gradients = T.grad(cost, curr_params)
updates = []
for p, g, n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(
n, g
) # Just clips the gradient and multiplies the learning rate to
# the gradients. upd is empty list here
updates.append((p, p + gr))
updates.extend(upd)
return cost, updates
def train_left(self):
[z_right, z_left, z_pivot] = self.reconstruct_from_sources([LEFT])
L = loss(z_left, self.x_left, self.loss_fn)
cost = T.mean(L)
if self.tied:
curr_params = [self.W_left, self.b, self.b_prime_left]
curr_param_names = ["W_left", "b", "b_prime_left"]
else:
curr_params = [
self.W_left, self.b, self.b_prime_left, self.W_left_prime
]
curr_param_names = ["W_left", "b", "b_prime_left", "W_left_prime"]
gradients = T.grad(cost, curr_params)
updates = []
for p, g, n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(n, g)
updates.append((p, p + gr))
updates.extend(upd)
return cost, updates
def train_right(self):
[z_right, z_left, z_pivot] = self.reconstruct_from_sources([RIGHT])
L = loss(z_right, self.x_right, self.loss_fn)
cost = T.mean(L)
if self.tied:
curr_params = [self.W_right, self.b, self.b_prime_right]
curr_param_names = ["W_right", "b", "b_prime_right"]
else:
curr_params = [
self.W_right, self.b, self.b_prime_right, self.W_right_prime
]
curr_param_names = [
"W_right", "b", "b_prime_right", "W_right_prime"
]
gradients = T.grad(cost, curr_params)
updates = []
for p, g, n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(n, g)
updates.append((p, p + gr))
updates.extend(upd)
return cost, updates
def train_pivot(self):
[z_right, z_left, z_pivot] = self.reconstruct_from_sources([PIVOT])
L = loss(z_pivot, self.x_pivot, self.loss_fn)
cost = T.mean(L)
if self.tied:
curr_params = [self.W_pivot, self.b, self.b_prime_pivot]
curr_param_names = ["W_pivot", "b", "b_prime_pivot"]
else:
curr_params = [
self.W_pivot, self.b, self.b_prime_pivot, self.W_pivot_prime
]
curr_param_names = [
"W_pivot", "b", "b_prime_pivot", "W_pivot_prime"
]
gradients = T.grad(cost, curr_params)
updates = []
for p, g, n in zip(curr_params, gradients, curr_param_names):
gr, upd = self.optimizer.get_grad_update(n, g)
updates.append((p, p + gr))
updates.extend(upd)
return cost, updates
def project_from_sources(self, source_list):
y_pre = self.b
for source in source_list:
if source == LEFT:
y_pre += T.dot(self.x_left, self.W_left)
elif source == RIGHT:
y_pre += T.dot(self.x_right, self.W_right)
elif source == PIVOT:
y_pre += T.dot(self.x_pivot, self.W_pivot)
y = activation(y_pre, self.hidden_activation)
return y
def reconstruct_from_sources(self, source_list):
y = self.project_from_sources(source_list)
recon_left = activation(
T.dot(y, self.W_left_prime) + self.b_prime_left,
self.output_activation)
recon_right = activation(
T.dot(y, self.W_right_prime) + self.b_prime_right,
self.output_activation)
recon_pivot = activation(
T.dot(y, self.W_pivot_prime) + self.b_prime_pivot,
self.output_activation)
recon_list = [recon_right, recon_left, recon_pivot]
return recon_list
def get_lr_rate(self):
return self.optimizer.get_l_rate()
def set_lr_rate(self, new_lr):
self.optimizer.set_l_rate(new_lr)
def save_matrices(self):
for p, nm in zip(self.params, self.param_names):
numpy.save(self.op_folder + nm, p.get_value(borrow=True))
def save_params(self):
params = {}
params["optimization"] = self.optimization
params["l_rate"] = self.l_rate
params["n_visible_left"] = self.n_visible_left
params["n_visible_right"] = self.n_visible_right
params["n_visible_pivot"] = self.n_visible_pivot
params["n_hidden"] = self.n_hidden
params["lamda"] = self.lamda
params["hidden_activation"] = self.hidden_activation
params["output_activation"] = self.output_activation
params["loss_fn"] = self.loss_fn
params["tied"] = self.tied
params["numpy_rng"] = self.numpy_rng
params["theano_rng"] = self.theano_rng
pickle.dump(params, open(self.op_folder + "params.pck", "wb"), -1)
def load(self,
folder,
input_left=None,
input_right=None,
input_pivot=None):
plist = pickle.load(open(folder + "params.pck", "rb"))
self.init(plist["numpy_rng"],
theano_rng=plist["theano_rng"],
l_rate=plist["l_rate"],
optimization=plist["optimization"],
tied=plist["tied"],
n_visible_left=plist["n_visible_left"],
n_visible_right=plist["n_visible_right"],
n_visible_pivot=plist["n_visible_pivot"],
n_hidden=plist["n_hidden"],
lamda=plist["lamda"],
W_left=folder + "W_left",
W_right=folder + "W_right",
W_pivot=folder + "W_pivot",
b=folder + "b",
W_left_prime=folder + "W_left_prime",
W_right_prime=folder + "W_right_prime",
W_pivot_prime=folder + "W_pivot_prime",
b_prime_left=folder + "b_prime_left",
b_prime_right=folder + "b_prime_right",
b_prime_pivot=folder + "b_prime_pivot",
input_left=input_left,
input_right=input_right,
input_pivot=input_pivot,
hidden_activation=plist["hidden_activation"],
output_activation=plist["output_activation"],
loss_fn=plist["loss_fn"],
op_folder=folder)
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 test_solution(self):
random_topology = ini.make_random_topology(400, 3)
solution = sa_ds.solution(random_topology)
