def loss(self, data, model, tt, name):
losses = self.get_predictions_loss(data, model, tt)[1]
loss = np.sum(losses)
info('{} total loss: {:0.3f}'.format(name, loss))
avg_loss = np.mean(losses)
info('{} average loss per protein: {:0.3f}'.format(name, avg_loss))
return ['loss_' + tt, 'ave_loss_' + tt], [loss, avg_loss]
def test_constructor_arg_logfile_cfgfile_valid(self, cfgfile_valid, logfile):
# Tests the constructor against a valid argument and valid configfile
# Logging in sent to a logfile in config dir
p = logfile
args = [f'--config={cfgfile_valid}', f'--log-file={p}']
config.Configuration(args)
config.info('Test')
assert os.path.getsize(p) != 0
def fit(self, exp_spec, data, model):
""" trains model by iterating mini-batches for specified number of epochs """
# train for specified number of epochs
for epoch in range(1, exp_spec['num_epochs'] + 1):
info('epoch_' + str(epoch))
self.train_epoch(data['train'], model, exp_spec['mini_batch_size'])
# calculate train and test metrics
headers, result = self.processor.process_results(
exp_spec, data, model, 'epoch_' + str(exp_spec['num_epochs']))
# clean up
self.processor.reset()
model.close()
return headers, result
def determinerGagnant(self):
"""Détermine le gagnant de la partie à la fin du jeu."""
self.cote_gagnant = self.plateau.obtenirCoteGagnant()
if self.cote_gagnant != None:
self.gagnant = self.joueurs[self.cote_gagnant].nom
cfg.info("Le joueur " + self.gagnant + " a gagne.",
nom_fichier="othello.py")
else:
cfg.info("Match nul.", nom_fichier="othello.py")
self.gagnant = None
# Faire attention au fait que le plateau ne connait que des cotés, et à
# aucun moment il ne possède les vrais joueurs comme attributs.
# Effectivement,
# ce sont les joueurs qui utilise le plateau et non l'inverse.
return self.gagnant
def process_results(self, exp_spec, data, model, name):
""" Processes each result in the results object based on its type and returns stuff if specified in exp_spec """
info('Results for {}'.format(name))
self.test_batch_size = exp_spec['test_batch_size']
metrics = [
'loss_train', 'loss_test', 'roc_train', 'roc_test', 'auprc_train',
'auprc_test'
]
_headers = []
_results = []
for metric in metrics:
process_function = getattr(self, metric)
headers, results = process_function(data, model, name)
_headers += headers
_results += results
return _headers, _results
def auprc(self, data, model, tt, name):
scores = self.get_predictions_loss(data, model, tt)[0]
labels = [protein['label'][:, 2] for protein in data[tt]]
close_count = 0
auprcs = []
for preds, lbls in zip(scores, labels):
if np.allclose(preds[:, 0],
np.zeros_like(preds[:, 0]) + np.mean(preds[:, 0])):
close_count += 1
auprcs.append(average_precision_score(lbls, preds))
if close_count > 0:
info(
'For {} proteins, all predicted scores are close to each other, auprc may be based on improper sorting'
.format(close_count))
med_auprc = np.median(auprcs)
info('{} median auprc: {:0.3f}'.format(name, med_auprc))
return ['auprc_med_' + tt], [med_auprc]
def roc(self, data, model, tt, name):
scores = self.get_predictions_loss(data, model, tt)[0]
labels = [prot['label'][:, 2] for prot in data[tt]]
fprs = []
tprs = []
roc_aucs = []
for s, l in zip(scores, labels):
fpr, tpr, _ = roc_curve(l, s)
roc_auc = auc(fpr, tpr)
fprs.append(fpr)
tprs.append(tpr)
roc_aucs.append(roc_auc)
auc_prot_med = np.median(roc_aucs)
auc_prot_ave = np.mean(roc_aucs)
info('{} average protein auc: {:0.3f}'.format(name, auc_prot_ave))
info('{} median protein auc: {:0.3f}'.format(name, auc_prot_med))
return ['auc_prot_ave_' + tt,
'auc_prot_med_' + tt], [auc_prot_ave, auc_prot_med]
def actualiser(self):
"""Actualise le jeu."""
self.bordure.actualiser(self.rang, self.plateau.obtenirScores(),
self.fini, self.gagnant)
if self.panneau:
self.panneau.check()
self.ouvert = self.panneau.open
if not self.plateau.estFini():
if self.panneau:
self.afficher()
self.faireTour()
else:
if not self.fini:
self.fini = not (self.fini)
self.determinerGagnant()
cfg.info(
"Fin de partie : Le gagnant est {}".format(
repr(self.gagnant)),
nom_fichier="othello.py",
)
if self.panneau:
self.afficher()
else:
self.ouvert = False
def __init__(self, layers, layer_args, train_data, learning_rate, pn_ratio,
res_dir):
""" Assumes same dimensions and neighborhoods for l_ and r_
:param layers: exp_spec['spec']->spec['layers']
:param layer_args: exp_spec['spec']->spec['layer_args']
:param train_data: exp_spec['train_data_file']->data['train']
:param learning_rate: Learning Rate
:param pn_ratio: Positive-Negative Ratio
:param res_dir: output directory of results
data: 'l_'->ligand protein; 'r_'->receptor protein
"""
# parameters & args
self.layer_args = layer_args
self.params = {}
# 'tensorFlow' stuff
self.graph = tf.Graph()
self.session = None
self.predictions = None
# get details of train data
self.dcnn = ('l_edge'
not in train_data[0]) # convolution type is dcnn or not
self.vertex_dimension = train_data[0]['l_vertex'].shape[-1]
if self.dcnn:
self.hop = train_data[0]['l_power_series'].shape[1]
else:
self.edge_dimension = train_data[0]['l_edge'].shape[-1]
self.hood_size = train_data[0]['l_hood_indices'].shape[1]
# set self.graph as default Graph Object
with self.graph.as_default():
# shapes and 'tensorFlow' variables
self.vertex1 = tf.placeholder(tf.float32,
[None, self.vertex_dimension],
'vertex1')
self.vertex2 = tf.placeholder(tf.float32,
[None, self.vertex_dimension],
'vertex2')
if self.dcnn:
self.hop1 = tf.placeholder(tf.float32, [None, self.hop, None],
'hop1')
self.hop2 = tf.placeholder(tf.float32, [None, self.hop, None],
'hop2')
input1 = self.vertex1, self.hop1
input2 = self.vertex2, self.hop2
else:
self.edge1 = tf.placeholder(
tf.float32, [None, self.hood_size, self.edge_dimension],
'edge1')
self.edge2 = tf.placeholder(
tf.float32, [None, self.hood_size, self.edge_dimension],
'edge2')
self.hood_indices1 = tf.placeholder(tf.int32,
[None, self.hood_size, 1],
'hood_indices1')
self.hood_indices2 = tf.placeholder(tf.int32,
[None, self.hood_size, 1],
'hood_indices2')
input1 = self.vertex1, self.edge1, self.hood_indices1
input2 = self.vertex2, self.edge2, self.hood_indices2
self.examples = tf.placeholder(tf.int32, [None, 2], 'examples')
self.labels = tf.placeholder(tf.float32, [None], 'labels')
self.keep_prob = tf.placeholder(tf.float32, [], 'keep_prob')
# make layers
legs = True
inputs = None
i = 0
while i < len(layers):
layer = layers[i]
args = copy.deepcopy(layer_args)
args['keep_prob'] = self.keep_prob
layer_type = layer[0]
next_arg = layer[1] if len(layer) > 1 else {}
flag = layer[2] if len(layer) > 2 else None
args.update(next_arg)
# getattr(object, name[, default])-> return 'attr' of 'object'
layer_function = getattr(components,
layer_type) # return layer function
# flag == ['merge'] if flag is not None
if flag is not None and 'merge' in flag:
legs = False
# take vertex features only
inputs = input1[0], input2[0], self.examples
if legs:
# make leg layers(everything up to the merge layer)
name = 'leg1_{}_{}'.format(layer_type, i)
with tf.name_scope(name):
output, params = layer_function(input1, None, **args)
# update params
if params is not None:
info("not merge")
print(len(params.items()))
self.params.update({
'{}_{}'.format(name, key): value
for key, value in params.items()
})
if self.dcnn:
input1 = output, self.hop1
else:
input1 = output, self.edge1, self.hood_indices1
name = 'leg2_{}_{}'.format(layer_type, i)
with tf.name_scope(name):
output = layer_function(input2, params, **args)[0]
if self.dcnn:
input2 = output, self.hop2
else:
input2 = output, self.edge2, self.hood_indices2
else:
# merged layers
name = '{}_{}'.format(layer_type, i)
with tf.name_scope(name):
inputs, params = layer_function(inputs, None, **args)
# update params
if params is not None and len(params.items()) > 0:
self.params.update({
'{}_{}'.format(name, key): value
for key, value in params.items()
})
i += 1
self.predictions = inputs
# loss
with tf.name_scope('loss'):
scale_vector = (pn_ratio * (self.labels - 1) / -2) + (
(self.labels + 1) / 2)
logits = tf.concat([-self.predictions, self.predictions],
axis=1)
labels = tf.stack([(self.labels - 1) / -2,
(self.labels + 1) / 2],
axis=1)
self.loss = tf.losses.softmax_cross_entropy(
labels, logits, weights=scale_vector)
# optimizer
with tf.name_scope('optimizer'):
# generate an op which trains the model
self.train_op = tf.train.GradientDescentOptimizer(
learning_rate).minimize(self.loss)
# set up 'tensorFlow' session
self.sess = tf.Session()
self.sess.run(tf.global_variables_initializer())
Building of models --classifier.py
Training and testing of models --fitter.py
Process and output of results --processor.py
"""
# load experiment specified in system args
# exp_file = sys.argv[1]
# exp_file = "no_conv.yml"
exp_file = "single_weight_matrix.yml"
# exp_file = "node_avg.yml"
# exp_file = "node_edge_avg.yml"
# exp_file = "order_dependent.yml"
# exp_file = "deep_tensor.yml"
# exp_file = "dcnn_hop2.yml"
# exp_file = "dcnn_hop5.yml"
info("Running Experiment File: {}".format(exp_file))
f_name = exp_file.split('.')[0] if '.' in exp_file else exp_file
exp_spec = yaml.load(open(os.path.join(exp_dir, exp_file), 'r').read())
# ensure output path of results is exist
res_dir = os.path.join(out_dir, f_name)
if not os.path.exists(res_dir):
os.mkdir(res_dir)
processor = Processor()
# create results log
res_log = os.path.join(res_dir, "results.csv")
with open(res_log, 'w') as f:
f.write("")
# write experiment specifications to file
with open(os.path.join(res_dir, "exp.yml"), 'w') as f:
f.write("{}\n".format(yaml.dump(exp_spec)))
# perform each experiment
def __init__(self):
self.__info = config.info()
self.__host = self.__info[0]
self.__user = self.__info[1]
self.__passwd = self.__info[2]
self.__db = self.__info[3]
from termcolor import colored as c
from libs.console import Autocomplete, start_shell
import libs.server as server
import libs.ngrok as ngrok
import config
from getpass import getpass
from uuid import uuid4
from subprocess import Popen, PIPE
import time, _thread, os
import code, platform
arm = "arm aarch64_be aarch64 armv8b armv8l".split(" ")
x86 = "i386 i686".split(" ")
x64 = ["x86_64"]
author = config.info()
mch = platform.machine()
class var(object):
current_agent = None
var = var()
man = {
'help': 'Displays the help menu',
'banner': 'Prints the program\'s banner',
'exit': 'Exits the program',
'man': 'Find more information about a command. Usage: \'man help\'',
'listAgents': 'List active agents',
