def main():
# Measure run time
timer = StopWatch()
timer.start()
# Setup models
db = getDBInstance(config)
summaries = Summaries(db.tick_summary_db)
stepSeconds = {
'minutely': 60,
'hourly': 60 * 60,
'daily': 24 * 60 * 60,
'weekly': 7 * 24 * 60 * 60
}
maxCompletions = {
'minutely': None,
'hourly': MAX_COMPLETION_HOURLY,
'daily': MAX_COMPLETION_DAILY,
'weekly': None
}
noiseCycles = {
'minutely': None,
'hourly': COMPLETION_CYCLE_HOURLY,
'daily': None,
'weekly': None
}
now = datetime.datetime.now().timestamp()
after = now - EXPORT_WITHIN_SECONDS
for exchanger in EXCHANGERS:
for unit in UNITS:
sums = list(summaries.all(exchanger, unit, after=after))
logger.debug('Copying {e}\'s {u} ticks to np.array, #items={n}...'
.format(e=exchanger, u=unit, n=len(sums)))
step = stepSeconds[unit]
maxCompletion = maxCompletions[unit]
dates = seriesDate(sums, step)
logger.debug('Completing {e}\'s {u} ticks to np.array, maxN={maxN}...'
.format(e=exchanger, u=unit, maxN=maxCompletion))
opts = {
'maxN': maxCompletion
}
if noiseCycles[unit] is not None:
opts['noise'] = lambda n:completionNoise(n, cycle=noiseCycles[unit],
scale=COMPLETION_NOISE_SCALE)
completes = {
'askMax': completion(lambda s:s.askMax, sums, step, **opts),
'askMin': completion(lambda s:s.askMin, sums, step, **opts),
'askAverage': completion(lambda s:s.askAverage, sums, step, **opts),
'askOpen': completion(lambda s:s.askOpen, sums, step, **opts),
'askClose': completion(lambda s:s.askClose, sums, step, **opts)
}
for ty in completes:
completed = completes[ty]
if len(dates) != len(completed):
raise Exception('Length unmatch, #date={date}, #completed={completed}.'
.format(date=len(dates), completed=len(completed)))
savenpy(config, completed, exchanger, unit, ty)
savenpy(config, dates, exchanger, unit, 'date')
# Finished
seconds = timer.stop()
logger.debug('End export, elapsed={s:.2f}s'.format(s=seconds))
def main():
# Measure run time
timer = StopWatch()
timer.start()
# Execution
types = ['askAverage', 'askOpen', 'askClose']
runForAll(EXCHANGERS, UNITS, types)
# Finished
seconds = timer.stop()
logger.debug('End supervising, elapsed={s:.2f}s'.format(s=seconds))
def main():
# Measure run time
timer = StopWatch()
timer.start()
# Setup models
db = getDBInstance(config)
ticksModel = Ticks(db.tick_db)
dashb = Dashboard(uri=AIMAI_DB_URI, logger=logger)
dashb.requestLogin(USERNAME, PASSWORD)
sync(dashb, ticksModel)
# Finished
seconds = timer.stop()
logger.debug('End synchronization, elapsed={s:.2f}s'.format(s=seconds))
def main():
# Measure run time
timer = StopWatch()
timer.start()
# Setup models
db = getDBInstance(config)
ticks = Ticks(db.tick_db)
summaries = Summaries(db.tick_summary_db)
for exchanger in EXCHANGERS:
for unit in UNITS:
logger.debug('Summarizing, exchanger={exchanger}, unit={unit}.'
.format(exchanger=exchanger, unit=unit))
latest = summaries.one(exchanger, unit)
if latest is not None:
start = latest.date
else:
start = None
sums = ticksBy(ticks, exchanger, unit, dateStart=start)
logger.info('Saving summary...')
summaries.saveAll(exchanger, unit, sums)
# Finished
seconds = timer.stop()
logger.debug('End summarization, elapsed={s:.2f}s'.format(s=seconds))
from utils import readConfig, getLogger, loadnpy, StopWatch
logger = getLogger()
config = readConfig('predict.ini')
logger.info('Training started.')
OFFSET_SAMPLES = config['train'].getint('samples.offset')
INPUT_SIZE = config['train'].getint('fitting.inputsize')
BATCH_SIZE = config['train'].getint('fitting.batchsize')
EPOCHS = config['train'].getint('fitting.epochs')
SAMPLES_PREDICT = config['train'].getint('samples.predict')
ACCURACY_MIN = config['train'].getfloat('accuracy.min')
# Measure run time
timer = StopWatch()
timer.start()
def load(exchanger, unit, ty):
return loadnpy(config, exchanger, unit, ty, nan=0.)
def fit(X, y, model, rateTrain=0.9, epochs=1000, batchSize=64):
Xu, yu = balance(X, y, thres=0.5)
trainCount = int(Xu.shape[0] * rateTrain)
indexRandom = np.random.permutation(Xu.shape[0])
indexTrain = indexRandom[:trainCount]
XTrain = Xu[indexTrain]
yTrain = yu[indexTrain]
hist = model.fit(XTrain, yTrain, batch_size=batchSize, epochs=epochs,
verbose=1, validation_split=0.1, shuffle=True)
return hist
def main():
iprint("hello")
def foo():
iprint("inside foo")
bar()
def bar():
iprint("inside bar")
foo()
bar()
a = [1, 2, 3, 4, 5, 6]
iprint(a)
b = [i for i in range(1000)]
iprint(b)
watch = StopWatch()
log1 = NameLog()
log2 = NameLog()
log1.track("test1", "test2")
log2.track("accuracy")
test1 = 4
def baz(log1, log2):
test2 = 42
log1.record()
for accuracy in range(10):
log2.record()
baz(log1, log2)
print(log1.tracked)
print(log2.tracked)
@CodeMemo
def longjob(t, ret):
print("Sleeping...")
sleep(t)
print("Done.")
return ret
def worker():
return longjob(5, ret=4)
watch.start()
res = worker()
watch.stop()
iprint(f"Got {res}")
iprint(f"Elapsed {watch.elapsed()}")
exit()
tagger = Tagger()
print("Basic")
print(f"# possible tags: {tagger.size():,}")
for i in range(5):
print(tagger.make())
print()
tagger = Tagger()
seen = set()
tag = tagger.make()
while tag not in seen:
seen.add(tag)
tag = tagger.make()
assert len(seen) == tagger.size()
print("Space size matches.")
print()
tagger = Tagger(10)
print("Numeric 10")
print(f"# possible tags: {tagger.size():,}")
for i in range(5):
print(tagger.make())
print()
tagger = Tagger("aaa")
print("Letters 3")
print(f"# possible tags: {tagger.size():,}")
for i in range(5):
print(tagger.make())
print()