def __init__(self, _config):
self.logger = logger
self.logger.critical('Object up: %s' % str(self))
self.__data_prvider = DataProvider(_config['database_path'])
self.__cmd_server = IPC_Server(_config['socket_file_path'])
self.__cmd_server.register_cmd('GET_DESC', self.cmd_desc)
self.__cmd_server.register_cmd('GET_MONTHLY', self.cmd_monthly_data)
self.__cmd_server.register_cmd('GET_YEARLY', self.cmd_yearly_data)
self.__cmd_server.register_cmd('GET_DAILY', self.cmd_daily_data)
self.__cmd_server.register_cmd('GET_DATATREE', self.cmd_datatree)
self.__cmd_server.register_cmd('GET_NEWEST', self.cmd_newest)
self.__cmd_server.register_cmd('SET_SAMPLE', self.cmd_store_sample)
self.__cmd_server.register_cmd('SET_DESC', self.cmd_station_register)
# Command registred, just start
self.__cmd_server.start()
self.dataCatch = []
for broker in _config['mqtt']:
catcher = MqttCatcher(_config['socket_file_path'],
broker[0],
broker[1],
_topic_prefix=broker[2],
_protocol=broker[3])
catcher.start()
self.dataCatch.append(catcher)
def handle(self):
data = DataProvider()
while True:
try:
self.request.send(data.getData())
except:
# Client closed/lost connection
break
time.sleep(1.0/15.0)
def main():
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)
GPIO.output(4, GPIO.LOW)
time.sleep(3)
GPIO.cleanup()
data_provider = DataProvider(DB_PATH)
configuration = WeightProcessorConfiguration(MAX_PAUSE_BETWEEN_MORNING_CHECKS_IN_DAYS,
MAX_WEIGHT_DIFF_BETWEEN_MORNING_CHECKS,
USERS_MAX_W_DIFF,
MORNING_HOURS)
user_provider = UserProvider(USERS)
weight_processor = WeightProcessor(data_provider,
configuration,
user_provider,
FitbitConnector(FITBIT_CLIENT_ID, FITBIT_CLIENT_SECRET, user_provider))
events_processor = EventProcessor(weight_processor)
board = Wiiboard(events_processor)
if len(sys.argv) == 1:
logging.debug("Discovering board...")
address = board.discover()
else:
address = sys.argv[1]
logging.debug("Trying to connect...")
board.connect(address) # The wii board must be in sync mode at this time
board.set_light(False)
while 1 == 1:
events_processor.reset()
board.receive()
weight = events_processor.weight + 2
weight_record = WeightRecord({'year': datetime.today().year,
'month': datetime.today().month,
'day': datetime.today().day,
'w': weight})
user = weight_processor.get_user_by_weight(weight)
display.render(str(weight), WHITE, safe_text(user))
weight_processor.process(weight_record)
display.render_graph(data_provider.all_mornings(user))
board.set_light(False)
logging.debug('Ready for next job')
def __init__(self): super().__init__() self.cl = ClientList(self) self.data = DataProvider(self) self.vcdj = Vcdj(self) self.nfs = NfsClient(self) self.keepalive_ip = "0.0.0.0" self.keepalive_port = 50000 self.beat_ip = "0.0.0.0" self.beat_port = 50001 self.status_ip = "0.0.0.0" self.status_port = 50002 self.need_own_ip = OwnIpStatus.notNeeded self.own_ip = None
def main():
model = DeepDP(training['model_cfg']['input_dim'], training['model_cfg']['hidden_size'], \
training['model_cfg']['num_factors'], training['model_cfg']['latent_dim'])
dataprovider = DataProvider(training['sample_size'],
training['model_cfg']['input_dim'])
optimizer = get_optimizer(model)
for i in range(training['epochs']):
run_epoch(model, optimizer, dataprovider, i)
meta_file_loc = os.path.join(training['result_dir'], 'metafile.pkl')
with open(meta_file_loc, 'w+') as f:
pickle.dump(training, f)
class MarketPlace:
def __init__(self, robots: ['Robot'], ticker: str):
self.data_provider = DataProvider()
self.robots = robots
self.accountant = Accountant(robots)
self.order_book = OrderBook(ticker)
def training(self, data: 'pd.DataFrame'):
for robot in self.robots:
robot.train(data)
def trading(self):
orders = []
data_from_order_book = self.order_book.get_data()
robots_orders = self.order_book.get_robots_orders()
for robot in self.robots:
data_from_accountant = self.accountant.get_data(robot.username)
robot.update(data_from_order_book, robots_orders[robot.username],
data_from_accountant)
robot.on_tick()
orders += robot.gather_new_orders()
self.order_book.register_orders(orders)
trades = self.order_book.get_last_trades()
self.accountant.register_trades(trades)
def start(self, path: str):
#training_data = self.data_provider.get_training_data()
#self.training(training_data)
self.data_provider.prepare_for_trading(path)
i = 0
total_orders = 0
for orders in self.data_provider:
i += 1
total_orders += len(orders)
#try:
self.order_book.register_orders(orders)
print(i)
print(self.order_book.total_deals)
print(total_orders)
def main(path, is_training, is_predicting, model_weights_file,
submission_file):
print('Starting train_statefarm.py')
print('* using path: {0}'.format(path))
print('* training: {0}, predicting: {1}'.format(is_training,
is_predicting))
batch_size = 64
data_provider = DataProvider(os.path.join(path, 'partition'), batch_size)
feature_provider = FeatureProvider(data_provider)
training_data_provider = TrainingDataProvider(data_provider,
feature_provider)
builder = ModelBuilder(training_data_provider,
dropout=0.6,
batch_size=batch_size)
if is_training:
print('Train last layer of dense model with batch normalization.')
builder.train_last_layer()
if is_training:
print('Train dense layers of model with batch normalization.')
builder.train_dense_layers()
model = builder.build(data_provider)
if not is_training:
print('Loading model weights from {0}'.format(model_weights_file))
model.load_weights(
data_provider.get_weight_filepath(model_weights_file))
else:
model.train()
print('Writing model weights to {0}'.format(model_weights_file))
model.save_weights(
data_provider.get_weight_filepath(model_weights_file))
if is_predicting:
print('Writing predictions to {0}'.format(submission_file))
batch_size = 2
data_provider = DataProvider(path, batch_size)
predict_states(model, data_provider, batch_size, submission_file)
class DatabaseBot(object):
''' DatabaseBot '''
def __init__(self, _config):
self.logger = logger
self.logger.critical('Object up: %s' % str(self))
self.__data_prvider = DataProvider(_config['database_path'])
self.__cmd_server = IPC_Server(_config['socket_file_path'])
self.__cmd_server.register_cmd('GET_DESC', self.cmd_desc)
self.__cmd_server.register_cmd('GET_MONTHLY', self.cmd_monthly_data)
self.__cmd_server.register_cmd('GET_YEARLY', self.cmd_yearly_data)
self.__cmd_server.register_cmd('GET_DAILY', self.cmd_daily_data)
self.__cmd_server.register_cmd('GET_DATATREE', self.cmd_datatree)
self.__cmd_server.register_cmd('GET_NEWEST', self.cmd_newest)
self.__cmd_server.register_cmd('SET_SAMPLE', self.cmd_store_sample)
self.__cmd_server.register_cmd('SET_DESC', self.cmd_station_register)
# Command registred, just start
self.__cmd_server.start()
self.dataCatch = []
for broker in _config['mqtt']:
catcher = MqttCatcher(_config['socket_file_path'],
broker[0],
broker[1],
_topic_prefix=broker[2],
_protocol=broker[3])
catcher.start()
self.dataCatch.append(catcher)
def cmd_station_register(self, _json_param):
logger.info('cmd_station_register()')
param = json.loads(_json_param)
self.logger.info('Got register data: %s' % str(param))
self.__data_prvider.stationRegister(param['uid'], param['desc'])
return json.dumps('OK')
def cmd_store_sample(self, _json_param):
logger.info('cmd_store_sample()')
param = json.loads(_json_param)
self.logger.info('Got sample data: %s' % str(param))
self.__data_prvider.stationSampleStore(param['sample'])
return json.dumps('OK')
def cmd_monthly_data(self, _json_param):
logger.info('cmd_monthly_data()')
param = json.loads(_json_param)
req_data = self.__data_prvider.getSerieMonthlyData(
param["uid"], param["serie"], param["date"])
return json.dumps(req_data)
def cmd_yearly_data(self, _json_param):
logger.info('cmd_yearly_data()')
param = json.loads(_json_param)
req_data = self.__data_prvider.getSerieYearlyData(
param["uid"], param["serie"], param["date"])
return json.dumps(req_data)
def cmd_daily_data(self, _json_param):
logger.info('cmd_daily_data()')
param = json.loads(_json_param)
req_data = self.__data_prvider.getSerieDayData(param["uid"],
param["serie"],
param["date"])
return json.dumps(req_data)
def cmd_datatree(self, _json_param):
logger.info('cmd_datatree()')
req_data = self.__data_prvider.getStationsDateTree()
return json.dumps(req_data)
def cmd_newest(self, _json_param):
logger.info('cmd_newest()')
req_data = self.__data_prvider.getStationsNewest()
return json.dumps(req_data)
def cmd_desc(self, _json_param):
logger.info('cmd_desc()')
req_data = self.__data_prvider.getStationsDesc()
return json.dumps(req_data)
def proc(self):
logger.info('proc()')
while True:
time.sleep(1)
import tensorflow as tf
from architectures.pretrained_encoder import encoder_model
from architectures.latent_space import latent_space
from architectures.decoder import decoder_model
from dataprovider import DataProvider
import os
epochs = 50
batch_size = 20
latent_units = 200
l_rate = 0.0001
# data
data_provider = DataProvider(batch_size, root_folder='../data')
train_num_batches, val_num_batches = data_provider.get_num_batches()
training_dataset_init, val_dataset_init, images, labels = data_provider.get_data(
)
# model
encoder = encoder_model(images)
latent_vector, mean, stddev = latent_space(encoder, latent_units)
predictions = decoder_model(latent_vector)
# losses
generative_loss = tf.reduce_mean(tf.reduce_sum(tf.squared_difference(
predictions, labels),
axis=1),
axis=1)
latent_loss = tf.reduce_mean(0.5 * tf.reduce_sum(
tf.square(mean) + tf.square(stddev) - tf.log(1e-8 + tf.square(stddev)) - 1,
1))
#!/usr/bin/env python
from pygame.locals import *
from dataprovider import WeightRecord, DataProvider
data = DataProvider("/home/pi/weight_db")
all_records = data.all("Alex")
print all_records
count = sum(1 for r in all_records)
print count
def __init__(self, robots: ['Robot'], ticker: str):
self.data_provider = DataProvider()
self.robots = robots
self.accountant = Accountant(robots)
self.order_book = OrderBook(ticker)
class ProDj(Thread):
def __init__(self):
super().__init__()
self.cl = ClientList(self)
self.data = DataProvider(self)
self.vcdj = Vcdj(self)
self.nfs = NfsClient(self)
self.keepalive_ip = "0.0.0.0"
self.keepalive_port = 50000
self.beat_ip = "0.0.0.0"
self.beat_port = 50001
self.status_ip = "0.0.0.0"
self.status_port = 50002
self.need_own_ip = OwnIpStatus.notNeeded
self.own_ip = None
def start(self):
self.keepalive_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.keepalive_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.keepalive_sock.bind((self.keepalive_ip, self.keepalive_port))
logging.info("Listening on {}:{} for keepalive packets".format(self.keepalive_ip, self.keepalive_port))
self.beat_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.beat_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.beat_sock.bind((self.beat_ip, self.beat_port))
logging.info("Listening on {}:{} for beat packets".format(self.beat_ip, self.beat_port))
self.status_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.status_sock.bind((self.status_ip, self.status_port))
logging.info("Listening on {}:{} for status packets".format(self.status_ip, self.status_port))
self.socks = [self.keepalive_sock, self.beat_sock, self.status_sock]
self.keep_running = True
self.data.start()
super().start()
def stop(self):
self.keep_running = False
self.nfs.stop()
self.data.stop()
self.vcdj_disable()
self.join()
self.keepalive_sock.close()
self.beat_sock.close()
def vcdj_set_player_number(self, vcdj_player_number=5):
logging.info("Player number set to {}".format(vcdj_player_number))
self.vcdj.player_number = vcdj_player_number
#self.data.dbc.own_player_number = vcdj_player_number
def vcdj_enable(self):
self.vcdj_set_iface()
self.vcdj.start()
def vcdj_disable(self):
self.vcdj.stop()
self.vcdj.join()
def vcdj_set_iface(self):
if self.own_ip is not None:
self.vcdj.set_interface_data(*self.own_ip[1:4])
def run(self):
logging.debug("ProDj: starting main loop")
while self.keep_running:
rdy = select(self.socks,[],[],1)[0]
for sock in rdy:
if sock == self.keepalive_sock:
data, addr = self.keepalive_sock.recvfrom(128)
self.handle_keepalive_packet(data, addr)
elif sock == self.beat_sock:
data, addr = self.beat_sock.recvfrom(128)
self.handle_beat_packet(data, addr)
elif sock == self.status_sock:
data, addr = self.status_sock.recvfrom(256)
self.handle_status_packet(data, addr)
self.cl.gc()
logging.debug("ProDj: main loop finished")
def handle_keepalive_packet(self, data, addr):
#logging.debug("Broadcast keepalive packet from {}".format(addr))
try:
packet = packets.KeepAlivePacket.parse(data)
except Exception as e:
logging.warning("Failed to parse keepalive packet from {}, {} bytes: {}".format(addr, len(data), e))
dump_packet_raw(data)
return
# both packet types give us enough information to store the client
if packet["type"] in ["type_ip", "type_status", "type_change"]:
self.cl.eatKeepalive(packet)
if self.own_ip is None and len(self.cl.getClientIps()) > 0:
self.own_ip = guess_own_iface(self.cl.getClientIps())
if self.own_ip is not None:
logging.info("Guessed own interface {} ip {} mask {} mac {}".format(*self.own_ip))
self.vcdj_set_iface()
dump_keepalive_packet(packet)
def handle_beat_packet(self, data, addr):
#logging.debug("Broadcast beat packet from {}".format(addr))
try:
packet = packets.BeatPacket.parse(data)
except Exception as e:
logging.warning("Failed to parse beat packet from {}, {} bytes: {}".format(addr, len(data), e))
dump_packet_raw(data)
return
if packet["type"] in ["type_beat", "type_mixer"]:
self.cl.eatBeat(packet)
dump_beat_packet(packet)
def handle_status_packet(self, data, addr):
#logging.debug("Broadcast status packet from {}".format(addr))
try:
packet = packets.StatusPacket.parse(data)
except Exception as e:
logging.warning("Failed to parse status packet from {}, {} bytes: {}".format(addr, len(data), e))
dump_packet_raw(data)
return
self.cl.eatStatus(packet)
dump_status_packet(packet)
# called whenever a keepalive packet is received
# arguments of cb: this clientlist object, player number of changed client
def set_client_keepalive_callback(self, cb=None):
self.cl.client_keepalive_callback = cb
# called whenever a status update of a known client is received
# arguments of cb: this clientlist object, player number of changed client
def set_client_change_callback(self, cb=None):
self.cl.client_change_callback = cb
# called when status update of a known master is received or the master changes
# arguments of cb: this clientlist object, player number of changed master
def set_master_change_callback(self, cb=None):
self.cl.master_change_callback = cb
# called when a player media changes
# arguments of cb: this clientlist object, player_number, changed slot
def set_media_change_callback(self, cb=None):
self.cl.media_change_callback = cb
