class RemoteClient(object):
def __init__(self, ip, transmit):
if not os.path.isdir(DATA_DIR):
os.makedirs(DATA_DIR)
# Logging
self.log = Logger(CLIENT_LOG_FILE, D_VERB)
self.log.info('[MAIN THREAD] Instantiated client')
# Central data
self.receiving = False
self.training = False
self.paused = False
self.define_headers()
self.targets = {}
# Workers
self.data_client = DataClient(transmit, ip)
# Connection
self.connect(ip)
def connect(self, ip):
self.soc_ctrl = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.soc_ctrl.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
my_ip = socket.gethostbyname('')
self.log.debug('[MAIN THREAD] connecting...')
self.soc_ctrl.connect((ip,SOC_PORT_CTRL))
self.log.info('[MAIN THREAD] Client connected to server')
def define_headers(self):
head = {}
self.headers = head
def add_target(self, target, name):
if target in self.targets:
self.targets[target].append(name)
else:
self.targets[target]=[name]
def remove_target(self, target, name):
if target in self.targets:
if name in self.targets[target]:
self.targets[target].remove(name)
self.log.info('[MAIN THREAD] Removed {} named {}'.format(target, name))
else:
self.log.error('[MAIN THREAD] Asked to remove {} named {} while not recorded'.format(target, name))
else:
self.log.error('[MAIN THREAD] Asked to remove {} named {} while not recorded'.format(target, name))
def start_record(self, target, name):
self.log.debug('[MAIN THREAD] Asking server to start recording')
msg = MSG_SEP.join([START_RECORD, target, name])
answer = send_data(self.soc_ctrl,msg)
self.log.info('[MAIN THREAD] Server asked to start recording')
if answer == SYNC:
self.add_target(target, name)
self.log.info('[MAIN THREAD] Added {} named {}'.format(target, name))
else:
self.log.warn('[MAIN THREAD] Could not add {} named {} because of server answer'.format(target, name))
def stop_record(self, target, name):
self.log.debug('[MAIN THREAD] Asking server to stop recording')
msg = MSG_SEP.join([STOP_RECORD, target, name])
answer = send_data(self.soc_ctrl,msg)
self.log.info('[MAIN THREAD] Server asked to stop recording')
if answer == SYNC:
self.remove_target(target, name)
else:
self.log.warn('[MAIN THREAD] Could not remove {} named {} because of server answer'.format(target, name))
def start_receive(self):
if not self.receiving:
self.receiving = True
self.log.debug('[MAIN THREAD] Asking server to start sending')
status = send_data(self.soc_ctrl,START_SEND)
self.log.info('[MAIN THREAD] Server asked to start sending')
if status == FAIL:
self.log.error('[MAIN THREAD] Client tried to receive but server denied it')
else:
self.data_client.start()
self.log.info('[MAIN THREAD] Client is receiving')
self.log.debug("[MAIN THREAD] DATA THREAD started")
else:
self.log.warn("[MAIN THREAD] Asked to start receiving while already receiving")
def start_training(self):
if not self.training:
self.training = True
self.log.debug('[MAIN THREAD] Asking server to start training')
status = send_data(self.soc_ctrl,START_TRAIN)
self.log.info('[MAIN THREAD] Server asked to start training')
if status == FAIL:
self.log.error('[MAIN THREAD] Server refused to start training')
else:
self.log.info('[MAIN THREAD] Server is training')
else:
self.log.warn("[MAIN THREAD] Asked to start training while already training")
def stop_training(self):
if self.training:
self.training = False
self.log.debug('[MAIN THREAD] Asking server to stop training')
status = send_data(self.soc_ctrl,STOP_TRAIN)
self.log.info('[MAIN THREAD] Server asked to stop training')
if status == FAIL:
self.log.error('[MAIN THREAD] Server refused to stop training')
else:
self.log.info('[MAIN THREAD] Server has stopped training')
else:
self.log.warn("[MAIN THREAD] Asked to stop training while not training")
def pause_training(self):
if not self.paused:
self.paused = True
self.log.debug('[MAIN THREAD] Asking server to pause training')
status = send_data(self.soc_ctrl,PAUSE_TRAIN)
self.log.info('[MAIN THREAD] Server asked to pause training')
if status == FAIL:
self.log.error('[MAIN THREAD] Server refused to pause training')
else:
self.log.info('[MAIN THREAD] Server is paused')
else:
self.log.warn("[MAIN THREAD] Asked to paused training while already paused")
def resume_training(self):
if self.paused:
self.paused = False
self.log.debug('[MAIN THREAD] Asking server to resume training')
status = send_data(self.soc_ctrl,RESUME_TRAIN)
self.log.info('[MAIN THREAD] Server asked to resume training')
if status == FAIL:
self.log.error('[MAIN THREAD] Server refused to resume training')
else:
self.log.info('[MAIN THREAD] Server has resumed training')
else:
self.log.warn("[MAIN THREAD] Asked to resume training while not paused")
def stop_receive(self):
if self.receiving:
self.log.debug('[MAIN THREAD] Closing data channel. Exiting data client thread')
self.data_client.stop()
self.log.info("[MAIN THREAD] Asked server to stop receiving")
self.receiving = False
else:
self.log.warn("[MAIN THREAD] Asked to stop receiving while already receiving")
#def start_store(self, dirname = 'easy_client'):
# return self.data_processor.start_store(dirname)
#def stop_store(self):
# self.data_processor.stop_store()
#def start_print(self):
# self.data_processor.start_print()
#def stop_print(self):
# self.printing = self.data_processor.stop_print()
def stop_process(self):
self.stop_print()
self.stop_store()
#self.data_processor.stop()
self.stop_receive()
self.soc_ctrl.close()
def stop_all(self):
self.stop_process()
send_data(self.soc_ctrl, STOP_ALL)
class BaseModel(object):
def __init__(self):
'''
DOC
'''
self.log = Logger(MODEL_LOG_FILE)
self.input = T.matrix('x')
def add_target(self, target = None):
'''
DOC
'''
if target in self.struct:
self.struct[target][0] = True
self.log.info('added target {}'.format(target))
return True
else:
self.log.warn('asked to add target {} which does not exist'.format(target))
return False
def remove_target(self, target):
'''
DOC
'''
if target in self.struct:
self.struct[target][0] = False
self.log.info('added target {}'.format(target))
return True
else:
self.log.warn('asked to add target {} which does not exist'.format(target))
return False
def drop_weights(self):
'''
DOC
'''
dico = {}
for layer in self.struct:
if self.struct[layer][0] == True:
self.get_layer_weight(layer, dico)
return dico
def get_layer_weight(self, layer, dico):
'''
DOC
'''
weights = self.struct[layer][1].get_weights()
dico[layer]=weights
def get_struct(self):
'''
DOC
'''
return self.struct
def load_weights(self, file = None):
'''
DOC
'''
if file is None:
return self.standard_weight_init()
else:
#TODO Weight loading. How shall we serialize? cPickle a dict?
return False
def standard_weight_init(self):
'''
DOC
'''
return all(self.struct[layer][1].standard_init() for layer in self.struct)
