def __init__(self, port):
self.socket = zmq.Context().socket(zmq.REP)
self.socket.bind("tcp://127.0.0.1:" + str(port))
self.algo = Algo()
self.stockHandler = self.algo.sdc
self.sip = self.algo.sip
self.should_shutdown = False
def get_production_plan():
"""
Endpoint of the REST API that accepts a POST with a payload as we can
find in the 'example_payloads' directory.
Returns a JSON following the same structure as in 'example_response.json'
with the optimal 'p' power for each powerplant to obtain the value of 'load'.
"""
# Get informations from the payload
load = request.json["load"]
PowerPlant.wind_percent = request.json["fuels"]["wind(%)"]
prices_per_MWh = {
"gasfired": request.json["fuels"]["gas(euro/MWh)"],
"turbojet": request.json["fuels"]["kerosine(euro/MWh)"],
"windturbine": 0
}
# Instanciate powerplant objects
powerplants = []
for powerplant in request.json["powerplants"]:
pp = PowerPlant.create_pp(**powerplant)
pp.compute_cost_per_MWh(prices_per_MWh)
powerplants.append(pp)
# Calculate the unit-commitment
algo = Algo(powerplants, load)
unit_commitment = algo.calc_unit_commitment()
if unit_commitment:
return jsonify(unit_commitment)
return "WARNING: There is no possible configuration for the requested load"
def play(data,thief,police,goals):
#init graph
graph = Graph(screen,data,thief,police,goals)
#init algo
algo = Algo(data[2])
#main loop
running = True
#limit for num of turns
limit=20
#gameover var
gameover = False
while running:
screen.fill(BACKGROUND)
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONDOWN:
#player select where to move for thief
if not gameover:
turn=graph.choose(event.pos)
if turn:
#police move base on algo here
graph.police_move(algo.move(graph.thief,graph.police))
limit-=1
elif event.type == pygame.QUIT:
running = False
#check who win
result = graph.checkWin()
if result ==1: #player win
misc.message_to_screen('Player wins!',(255,0,0),0,0,'large')
m= misc.button("Restart",850,320,150,150,(55,255,255),(0,255,0))
gameover = True
if m:
return
elif result ==2: #police win
misc.message_to_screen('Player Lose...',(0,255,0),0,0,'large')
m1= misc.button("Restart",850,320,150,150,(55,255,255),(0,255,0))
gameover = True
if m1:
return
elif limit==0:
misc.message_to_screen('Its a draw!',(0,0,255),0,0,'large')
m2= misc.button("Restart",850,320,150,150,(55,255,255),(0,255,0))
gameover = True
if m2:
return
else:
#draw game boundary
pygame.draw.rect(screen,(0,0,0),(50,50,700,700),1)
#display graph
graph.display()
#display turns left
misc.message_to_screen('Turns left: '+str(limit),(0,0,255),310,-200,'medium')
pygame.display.update()
def train(self,
pw,
params,
policy,
critic,
policy_loss_file,
critic_loss_file,
study_name,
beta=0) -> None:
"""
The main function for training and evaluating a policy
Repeats training and evaluation params.nb_cycles times
Stores the value and policy losses at each cycle
When the reward is greater than the best reward so far, saves the corresponding policy
:param pw: a policy wrapper, used to save the best policy into a file
:param params: the hyper-parameters of the run, specified in arguments.py or in the command line
:param policy: the trained policy
:param critic: the corresponding critic (not always used)
:param policy_loss_file: the file to record successive policy loss values
:param critic_loss_file: the file to record successive critic loss values
:param study_name: the name of the studied gradient algorithm
:param beta: a specific parameter for beta-parametrized values
:return: nothing
"""
for cycle in range(params.nb_cycles):
batch = self.make_monte_carlo_batch(params.nb_trajs, params.render,
policy)
# Update the policy
batch2 = batch.copy_batch()
algo = Algo(study_name, params.critic_estim_method, policy, critic,
params.gamma, beta, params.nstep)
algo.prepare_batch(batch)
policy_loss = batch.train_policy_td(policy)
# Update the critic
assert params.critic_update_method in [
'batch', 'dataset'
], 'unsupported critic update method'
if params.critic_update_method == "dataset":
critic_loss = algo.train_critic_from_dataset(batch2, params)
elif params.critic_update_method == "batch":
critic_loss = algo.train_critic_from_batch(batch2)
critic_loss_file.write(str(cycle) + " " + str(critic_loss) + "\n")
policy_loss_file.write(str(cycle) + " " + str(policy_loss) + "\n")
# policy evaluation part
total_reward = self.evaluate_episode(policy,
params.deterministic_eval)
# plot_trajectory(batch2, self.env, cycle+1)
# save best reward agent (no need for averaging if the policy is deterministic)
if self.best_reward < total_reward:
self.best_reward = total_reward
pw.save(self.best_reward)
def __init__(self):
pygame.init()
super().__init__()
self.win_w, self.win_h = 1600, 900
self.win = pygame.display.set_mode((self.win_w, self.win_h),
pygame.RESIZABLE)
self.algo = Algo(self.win)
self.update_window_size(0) ##
## Movement flags
self.moving = False
self.draw_outer_circle = False
def maintain(self):
algo = Algo(self)
while True:
if not self.requests.empty() and self.count < self.requests_hold:
self.count += 1
request = self.requests.get()
self.remaining_requests.append(request)
else:
break
print ('requests = ', self.remaining_requests)
robots_states, goods_states = algo.BFS(self.remaining_requests)
to_json_file(robots_states, r'../results/robots_states.json')
to_json_file(goods_states, r'../results/goods_states.json')
#These features (multithread support) will be developed in the future
'''
while True:
if not self.requests.empty():
if self.count < self.requests_hold: #Need synchronized
self.count += 1
request = self.requests.get()
#Multi-thread o day?
bfs_thread = Thread(target = algo.BFS, args = (request))
bfs_thread.start()
self.count -= done_requests
else:
#Sleep somethings
time.sleep(0.1)
else:
#Sleep somethings
break
time.sleep(0.05)
'''
Photo(i, photo_params[2:], photo_params[0]))
def write_output_file(self, slides, score):
"""
Writes the output file ./outputs/<file_prefix>_<score>_<timestamp>.out
:param slides: Slides list
:param score: The score after the simulation
"""
output_file_path = "outputs/" + self.file_prefix + "_" + str(
score) + "_" + str(time.time()) + ".out"
file = open(output_file_path, "w")
print("write_output_file : " + output_file_path)
file.write(str(len(slides)) + "\n")
for slide in slides:
file.write(str(slide.photo1.id))
if slide.photo2 is not None:
file.write(" " + str(slide.photo2.id))
file.write("\n")
file.close()
# initialize Main instance
main = Main(sys.argv[1])
# initialize Algo instance
Algo(main)
def backtest_algo2(self, number, dates, algo):
#level number corresponds to an index
wins = [0] * 11
losses = [0] * 11
#creates processes
num_processes = 16
start = int(number * (len(dates) / num_processes))
end = int((number + 1) * (len(dates) / num_processes))
print()
print(number)
print(start)
print(end)
print()
#this is actually a do-while loop
for x in range(start, end):
print("At " + str(dates[x]) + " END: " + str(dates[end - 1]))
games = self.universal.get_games(dates[x])
for y in range(0, len(games)):
#team might not exist anymore, so don't count that game
if len(games[y]['team1']) != 0 and len(games[y]['team2']) != 0:
data1 = self.universal.load_data(games[y]['team1'],
games[y]['date'])
data2 = self.universal.load_data(games[y]['team2'],
games[y]['date'])
returned1 = self.odds_calculator.analyze2(
games[y]['team1'], games[y]['team2'], data1, "away")
returned2 = self.odds_calculator.analyze2(
games[y]['team2'], games[y]['team1'], data2, "home")
algorithm = Algo(self.league)
#sets algo to backtest
algorithm.algorithm[self.league] = algo
if self.algo_version == "Algo_V1":
algo_data = algorithm.calculate(
games[y]['date'], returned1, returned2)
elif self.algo_version == "Algo_V2":
algo_data = algorithm.calculate_V2(
games[y]['date'], returned1, returned2)
total = algo_data['total']
if self.algo_version == "Algo_V1":
#categorizes odds
levels = []
levels.append([0, 3])
levels.append([3, 6])
levels.append([6, 9])
levels.append([9, 12])
levels.append([12, 15])
levels.append([15, 18])
levels.append([18, 21])
levels.append([21, 24])
levels.append([24, 27])
levels.append([27, 100])
elif self.algo_version == "Algo_V2":
#categorizes odds
levels = []
levels.append([50, 55])
levels.append([55, 60])
levels.append([60, 65])
levels.append([65, 70])
levels.append([70, 75])
levels.append([75, 80])
levels.append([80, 85])
levels.append([85, 90])
levels.append([90, 95])
levels.append([95, 100])
level = 0
for z in range(0, len(levels)):
if (total >= levels[z][0] and total < levels[z][1]
) or (total * -1 >= levels[z][0]
and total * -1 < levels[z][1]):
level = z + 1
# #0 is team1, and 1 is team2
# projected_team=0
# if self.league=="nba":
# #if team1 is projected to win
# if total>0:
# projected_team=0
# #go with home team
# elif total<=0:
# projected_team=1
# else:
# #if team1 is projected to win
# if total>0:
# projected_team=0
# #go with home team
# elif total<=0:
# projected_team=1
#0 is team1, and 1 is team2
#if team1 is projected to win
if total > 0:
projected_team = 0
#go with home team
elif total <= 0:
projected_team = 1
#0 is team1, and 1 is team2
winning_team = 0
if games[y]['game_scores'][0] > games[y]['game_scores'][1]:
winning_team = 0
else:
winning_team = 1
#if algo was right
if projected_team == winning_team:
wins[level] += 1
else:
losses[level] += 1
temp = []
for x in range(0, len(wins)):
temp.append([losses[x], wins[x]])
algo_list = str(algo).replace("[", "").replace("]",
"").replace(" ", "")
path = "./" + str(self.league) + "/analyze/backtests/" + str(
algo_list) + "_temp" + str(number) + ".csv"
self.universal.save_to_csv(path, temp)
def backtest_csv_output(self, start_date, end_date):
#breaks up date
temp = start_date.split("-")
month = int(temp[0])
day = int(temp[1])
year = int(temp[2])
cur_date = start_date
content = []
#this is actually a do-while loop
while True:
games = self.universal.get_games(cur_date)
print("date: " + cur_date)
for game in games:
print(" Game: " + str(game))
to_save = []
to_save.append([
cur_date, "Away", "Home", "Algo points", "Proj winner",
"Winner", "", "", "Score"
])
for x in range(0, len(games)):
#team might not exist anymore, so don't count that game
if len(games[x]['team1']) != 0 and len(games[x]['team2']) != 0:
data1 = self.universal.load_data(games[x]['team1'],
games[x]['date'])
data2 = self.universal.load_data(games[x]['team2'],
games[x]['date'])
# print("Teams: "+str(games[x]['team1'])+" | "+str(games[x]['team2']))
# print("date: "+str(games[x]['date']))
# print(data1)
# print(data1[0]['dates'][0])
# print(data1[0]['dates'][-1])
returned1 = self.odds_calculator.analyze2(
games[x]['team1'], games[x]['team2'], data1, "away")
returned2 = self.odds_calculator.analyze2(
games[x]['team2'], games[x]['team1'], data2, "home")
# print(returned1)
# print()
# print(returned2)
# print()
algo = Algo(self.league)
if self.algo_version == "Algo_V1":
algo_data = algo.calculate(games[x]['date'], returned1,
returned2)
elif self.algo_version == "Algo_V2":
algo_data = algo.calculate_V2(games[x]['date'],
returned1, returned2)
total = algo_data['total']
to_add = []
to_add.append("")
to_add.append(games[x]['team1'][0])
to_add.append(games[x]['team2'][0])
to_add.append(total)
if self.algo_version == "Algo_V1":
#categorizes odds (points)
levels = []
levels.append([0, 3])
levels.append([3, 6])
levels.append([6, 9])
levels.append([9, 12])
levels.append([12, 15])
levels.append([15, 18])
levels.append([18, 21])
levels.append([21, 24])
levels.append([24, 27])
levels.append([27, 100])
elif self.algo_version == "Algo_V2":
#categorizes odds (percentage)
levels = []
levels.append([50, 55])
levels.append([55, 60])
levels.append([60, 65])
levels.append([65, 70])
levels.append([70, 75])
levels.append([75, 80])
levels.append([80, 85])
levels.append([85, 90])
levels.append([90, 95])
levels.append([95, 100])
level = 0
for y in range(0, len(levels)):
if (total >= levels[y][0] and total < levels[y][1]
) or (total * -1 >= levels[y][0]
and total * -1 < levels[y][1]):
level = y + 1
#appends projected team
if total > 0:
to_add.append(games[x]['team1'][0])
elif total <= 0:
to_add.append(games[x]['team2'][0])
#appends winning team
if games[x]['game_scores'][0] > games[x]['game_scores'][1]:
to_add.append(games[x]['team1'][0])
else:
to_add.append(games[x]['team2'][0])
#appends score
score = str(games[x]['game_scores'][0]) + "-" + str(
games[x]['game_scores'][1])
to_add.append(score)
# #appends algo data
# if to_add[-2]==to_add[-3]:
# to_add.append("")
# if self.algo_version=="Algo_V1":
# to_add.append(str(level))
# elif self.algo_version=="Algo_V2":
# to_add.append(total)
# elif to_add[-3]!="":
# if self.algo_version=="Algo_V1":
# to_add.append(str(level))
# elif self.algo_version=="Algo_V2":
# to_add.append(total)
# to_add.append("")
# else:
# to_add.append("")
# to_add.append("")
#appends algo data
if to_add[-2] == to_add[-3]:
to_add.append("")
to_add.append(str(level))
elif to_add[-3] != "":
to_add.append(str(level))
to_add.append("")
else:
to_add.append("")
to_add.append("")
#appends betting odds
if self.algo_version == "Algo_V1":
odds_calculator = Odds_Calculator(self.league)
odds = odds_calculator.get_odds(total)
elif self.algo_version == "Algo_V2":
odds = abs(total)
favorable_odds = (100 / (100 - abs(odds)) - 1) * 100
underdog_odds = (100 / (100 - abs(odds)) - 1) * 100
if total > 0:
to_add.append("-" + str(favorable_odds))
to_add.append("+" + str(underdog_odds))
else:
to_add.append("+" + str(underdog_odds))
to_add.append("-" + str(favorable_odds))
to_save.append(to_add)
#space between data
to_save.append(["", "", "", "", "", "", "", "", ""])
#only saves day's games if there were actually games on that day
if len(to_save) > 2:
content.append(to_save)
#breaks loop to act like do-while
if cur_date == end_date:
break
day += 1
if day > 31:
month += 1
day = 1
#doesn't increment year since the season's year doesn't change
if month > 12:
month = 1
day = 1
#increments season at the end of the season to sometime in the middle
if self.league == "nba":
if "4-1-" in cur_date:
year += 1
month = 2
day = 1
elif self.league == "nhl":
if "4-1-" in cur_date:
year += 1
month = 2
day = 1
elif self.league == "mlb":
if "10-1-" in cur_date:
year += 1
month = 7
day = 1
cur_date = str(month) + "-" + str(day) + "-" + str(year)
#has most recent games first
content.reverse()
to_save = []
for x in range(0, len(content)):
for y in range(0, len(content[x])):
to_save.append(content[x][y])
if start_date != end_date:
self.universal.save_to_csv(
"./" + str(self.league) + "/analyze/" + str(self.league) +
"_" + str(self.algo_version) + "_" + str(start_date) + "_" +
str(end_date) + "_analysis.csv", to_save)
else:
self.universal.save_to_csv(
"./" + str(self.league) + "/analyze/" + str(self.league) +
"_" + str(self.algo_version) + "_" + str(end_date) +
"_analysis.csv", to_save)
def backtest_odds(self, start_date, end_date):
#breaks up date
temp = start_date.split("-")
month = int(temp[0])
day = int(temp[1])
year = int(temp[2])
cur_date = start_date
content = []
#this is actually a do-while loop
while True:
games = self.universal.get_games(cur_date)
print("date: " + cur_date)
for game in games:
print(" Game: " + str(game))
# - Strategy 0.0: Bet on algo's projected winner, no matter the odds.
# - Strategy 0.1: Bet on oddsmaker's projected winner, no matter the odds.
# All below strategies incorporate placing a bet if the algorithm projects a team to win more often than the oddsmaker projects
# - Strategy 1: Default strategy.
# - Strategy 2: Placing a bet if that team is also the algo's favorite.
# - Strategy 3: Placing a bet if that team is the algo's favorite, and the oddsmaker's underdog.
# - Strategy 4: Placing a bet if the difference between the algorithm's projected odds and the oddsmaker's odds is also >= 45
to_save = []
strat00 = {"total_bet": 0, "total_win": 0}
strat01 = {"total_bet": 0, "total_win": 0}
strat1 = {"total_bet": 0, "total_win": 0}
strat2 = {"total_bet": 0, "total_win": 0}
strat3 = {"total_bet": 0, "total_win": 0}
strat4 = {"total_bet": 0, "total_win": 0}
for x in range(0, len(games)):
#team might not exist anymore, so don't count that game
if len(games[x]['team1']) != 0 and len(games[x]['team2']) != 0:
data1 = self.universal.load_data(games[x]['team1'],
games[x]['date'])
data2 = self.universal.load_data(games[x]['team2'],
games[x]['date'])
returned1 = self.odds_calculator.analyze2(
games[x]['team1'], games[x]['team2'], data1, "away")
returned2 = self.odds_calculator.analyze2(
games[x]['team2'], games[x]['team1'], data2, "home")
# print(returned1)
# print()
# print(returned2)
# print()
algo = Algo(self.league)
algo_data = algo.calculate_V2(games[x]['date'], returned1,
returned2)
total = algo_data['total']
# to_return={}
# to_return['record_points']= odds['records']
# to_return['home_away_points']= odds['home_away']
# to_return['home_away_10_games_points']= odds['home_away_10_games']
# to_return['last_10_games_points']= odds['last_10_games']
# to_return['avg_points']= odds['avg_points']
# to_return['avg_points_10_games']= odds['avg_points_10_games']
# # to_return['win_streak']= win_streak
# to_return['win_streak_home_away']= odds['win_streak_home_away']
# to_return['total']= self.universal.convert_number(average)
odds = abs(total)
favorable_odds = round((100 / (100 - abs(odds)) - 1) * 100)
underdog_odds = round((100 / (100 - abs(odds)) - 1) * 100)
# print(str(year)+" | "+str(games[x]['team1'])+" | "+str(games[x]['team2'])+" | "+str(games[x]['game_scores']))
oddsportal_odds = self.universal.get_odds_game(
year, games[x]['team1'], games[x]['team2'],
games[x]['game_scores'])
if oddsportal_odds[0] != 0:
to_add = []
#date
to_add.append(cur_date)
#away
to_add.append(games[x]['team1'][1])
#home
to_add.append(games[x]['team2'][1])
#Algo Proj
to_add.append(str(total) + "%")
#Away proj
away_proj = 0
if total < 0:
away_proj = favorable_odds
else:
away_proj = underdog_odds * -1
to_add.append(away_proj)
#Home proj
home_proj = 0
if total > 0:
home_proj = favorable_odds
else:
home_proj = underdog_odds * -1
to_add.append(home_proj)
#Away odds
to_add.append(oddsportal_odds[0])
#Home odds
to_add.append(oddsportal_odds[1])
#Diff Away
away_diff = 0
if abs(away_proj - oddsportal_odds[0]) > 200:
away_diff = abs(away_proj -
oddsportal_odds[0]) - 200
else:
away_diff = abs(away_proj - oddsportal_odds[0])
to_add.append(away_diff)
#Diff Home
home_diff = 0
if abs(home_proj - oddsportal_odds[1]) > 200:
home_diff = abs(home_proj -
oddsportal_odds[1]) - 200
else:
home_diff = abs(home_proj - oddsportal_odds[1])
to_add.append(home_diff)
## Strategy 0.0 ##
if away_proj < 0:
#Bet
to_add.append("$100")
strat00['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[0] > 0):
to_win = 100 * (oddsportal_odds[0] / 100)
else:
to_win = 100 / (oddsportal_odds[0] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][0] > games[x][
'game_scores'][1]:
to_add.append("$" + str(100 + to_win))
strat00['total_win'] += (100 + to_win)
else:
to_add.append("$0")
else:
#Bet
to_add.append("$100")
strat00['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[1] > 0):
to_win = 100 * (oddsportal_odds[1] / 100)
else:
to_win = 100 / (oddsportal_odds[1] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][1] > games[x][
'game_scores'][0]:
to_add.append("$" + str(100 + to_win))
strat00['total_win'] += (100 + to_win)
else:
to_add.append("$0")
## Strategy 0.1 ##
if oddsportal_odds[0] < 0 and oddsportal_odds[
0] < oddsportal_odds[1]:
#Bet
to_add.append("$100")
strat01['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[0] > 0):
to_win = 100 * (oddsportal_odds[0] / 100)
else:
to_win = 100 / (oddsportal_odds[0] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][0] > games[x][
'game_scores'][1]:
to_add.append("$" + str(100 + to_win))
strat01['total_win'] += (100 + to_win)
else:
to_add.append("$0")
else:
#Bet
to_add.append("$100")
strat01['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[1] > 0):
to_win = 100 * (oddsportal_odds[1] / 100)
else:
to_win = 100 / (oddsportal_odds[1] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][1] > games[x][
'game_scores'][0]:
to_add.append("$" + str(100 + to_win))
strat01['total_win'] += (100 + to_win)
else:
to_add.append("$0")
## Strategy 1 ##
if oddsportal_odds[0] > away_proj:
#Bet
to_add.append("$100")
strat1['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[0] > 0):
to_win = 100 * (oddsportal_odds[0] / 100)
else:
to_win = 100 / (oddsportal_odds[0] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][0] > games[x][
'game_scores'][1]:
to_add.append("$" + str(100 + to_win))
strat1['total_win'] += (100 + to_win)
else:
to_add.append("$0")
elif oddsportal_odds[1] > home_proj:
#Bet
to_add.append("$100")
strat1['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[1] > 0):
to_win = 100 * (oddsportal_odds[1] / 100)
else:
to_win = 100 / (oddsportal_odds[1] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][1] > games[x][
'game_scores'][0]:
to_add.append("$" + str(100 + to_win))
strat1['total_win'] += (100 + to_win)
else:
to_add.append("$0")
else:
to_add.append("")
to_add.append("")
to_add.append("")
## Strategy 2 ##
if oddsportal_odds[0] > away_proj and away_proj < 0:
#Bet
to_add.append("$100")
strat2['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[0] > 0):
to_win = 100 * (oddsportal_odds[0] / 100)
else:
to_win = 100 / (oddsportal_odds[0] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][0] > games[x][
'game_scores'][1]:
to_add.append("$" + str(100 + to_win))
strat2['total_win'] += (100 + to_win)
else:
to_add.append("$0")
elif oddsportal_odds[1] > home_proj and home_proj < 0:
#Bet
to_add.append("$100")
strat2['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[1] > 0):
to_win = 100 * (oddsportal_odds[1] / 100)
else:
to_win = 100 / (oddsportal_odds[1] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][1] > games[x][
'game_scores'][0]:
to_add.append("$" + str(100 + to_win))
strat2['total_win'] += (100 + to_win)
else:
to_add.append("$0")
else:
to_add.append("")
to_add.append("")
to_add.append("")
## Strategy 3 ##
if oddsportal_odds[
0] > away_proj and away_proj < 0 and oddsportal_odds[
0] > 0:
#Bet
to_add.append("$100")
strat3['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[0] > 0):
to_win = 100 * (oddsportal_odds[0] / 100)
else:
to_win = 100 / (oddsportal_odds[0] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][0] > games[x][
'game_scores'][1]:
to_add.append("$" + str(100 + to_win))
strat3['total_win'] += (100 + to_win)
else:
to_add.append("$0")
elif oddsportal_odds[
1] > home_proj and home_proj < 0 and oddsportal_odds[
1] > 0:
#Bet
to_add.append("$100")
strat3['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[1] > 0):
to_win = 100 * (oddsportal_odds[1] / 100)
else:
to_win = 100 / (oddsportal_odds[1] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][1] > games[x][
'game_scores'][0]:
to_add.append("$" + str(100 + to_win))
strat3['total_win'] += (100 + to_win)
else:
to_add.append("$0")
else:
to_add.append("")
to_add.append("")
to_add.append("")
## Strategy 4 ##
if self.league == "mlb":
diff_amount = 45
elif self.league == "nba":
diff_amount = 100
if oddsportal_odds[
0] > away_proj and away_diff >= diff_amount:
#Bet
to_add.append("$100")
strat4['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[0] > 0):
to_win = 100 * (oddsportal_odds[0] / 100)
else:
to_win = 100 / (oddsportal_odds[0] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][0] > games[x][
'game_scores'][1]:
to_add.append("$" + str(100 + to_win))
strat4['total_win'] += (100 + to_win)
else:
to_add.append("$0")
elif oddsportal_odds[
1] > home_proj and home_diff >= diff_amount:
#Bet
to_add.append("$100")
strat4['total_bet'] += 100
#To Win
to_win = 0
if (oddsportal_odds[1] > 0):
to_win = 100 * (oddsportal_odds[1] / 100)
else:
to_win = 100 / (oddsportal_odds[1] * -1 / 100)
to_add.append("$" + str(to_win))
#Won
if games[x]['game_scores'][1] > games[x][
'game_scores'][0]:
to_add.append("$" + str(100 + to_win))
strat4['total_win'] += (100 + to_win)
else:
to_add.append("$0")
else:
to_add.append("")
to_add.append("")
to_add.append("")
else:
to_add = []
# #appends winning team
# if games[x]['game_scores'][0]>games[x]['game_scores'][1]:
# to_add.append(games[x]['team1'][0])
# else:
# to_add.append(games[x]['team2'][0])
# #appends score
# score=str(games[x]['game_scores'][0])+"-"+str(games[x]['game_scores'][1])
# to_add.append(score)
if len(to_add) != 0:
to_save.append(to_add)
# to_save.append(["Date", "Away", "Home", "Algo proj", "Away proj", "Home proj", "Away odds", "Home odds", "Diff away", "Diff home", "Bet", "To win", "Won"])
#only saves day's games if there were actually games on that day
if len(to_save) > 2:
#summary
strat00_profit = strat00['total_win'] - strat00['total_bet']
strat00_perc = strat00_profit / strat00['total_bet'] * 100
strat01_profit = strat01['total_win'] - strat01['total_bet']
strat01_perc = strat01_profit / strat01['total_bet'] * 100
strat1_profit = strat1['total_win'] - strat1['total_bet']
strat1_perc = strat1_profit / strat1['total_bet'] * 100
strat2_profit = strat2['total_win'] - strat2['total_bet']
if (strat2['total_bet'] > 0):
strat2_perc = strat2_profit / strat2['total_bet'] * 100
else:
strat2_perc = 0
strat3_profit = strat3['total_win'] - strat3['total_bet']
if (strat3['total_bet'] > 0):
strat3_perc = strat3_profit / strat3['total_bet'] * 100
else:
strat3_perc = 0
strat4_profit = strat4['total_win'] - strat4['total_bet']
if (strat4['total_bet'] > 0):
strat4_perc = strat4_profit / strat4['total_bet'] * 100
else:
strat4_perc = 0
#initializes with buffer columns
summary = ["", "", "", "", "", "", "", "", "", ""]
summary.append("$" + str(strat00['total_bet']))
summary.append("$" + str(strat00_profit))
summary.append(str(strat00_perc) + "%")
summary.append("$" + str(strat01['total_bet']))
summary.append("$" + str(strat01_profit))
summary.append(str(strat01_perc) + "%")
summary.append("$" + str(strat1['total_bet']))
summary.append("$" + str(strat1_profit))
summary.append(str(strat1_perc) + "%")
summary.append("$" + str(strat2['total_bet']))
summary.append("$" + str(strat2_profit))
summary.append(str(strat2_perc) + "%")
summary.append("$" + str(strat3['total_bet']))
summary.append("$" + str(strat3_profit))
summary.append(str(strat3_perc) + "%")
summary.append("$" + str(strat4['total_bet']))
summary.append("$" + str(strat4_profit))
summary.append(str(strat4_perc) + "%")
to_save.append(summary)
#space between data
to_save.append([
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", ""
])
content.append(to_save)
#breaks loop to act like do-while
if cur_date == end_date:
break
day += 1
if day > 31:
month += 1
day = 1
#doesn't increment year since the season's year doesn't change
if month > 12:
month = 1
day = 1
#increments season at the end of the season to sometime in the middle
if self.league == "nba":
# if "4-1-" in cur_date:
# year+=1
# month=2
# day=1
if "4-1-" in cur_date:
year += 1
month = 1
day = 15
elif self.league == "nhl":
if "4-1-" in cur_date:
year += 1
month = 2
day = 1
elif self.league == "mlb":
if "10-1-" in cur_date:
year += 1
month = 7
day = 1
cur_date = str(month) + "-" + str(day) + "-" + str(year)
# #has most recent games first
# content.reverse()
to_save = []
to_save.append([
"Date", "Away", "Home", "Algo proj", "Away proj", "Home proj",
"Away odds", "Home odds", "Diff away", "Diff home", "Bet",
"To win", "Won", "Bet", "To win", "Won", "Bet", "To win", "Won",
"Bet", "To win", "Won"
])
for x in range(0, len(content)):
for y in range(0, len(content[x])):
to_save.append(content[x][y])
if start_date != end_date:
self.universal.save_to_csv(
"./" + str(self.league) + "/analyze/" + str(self.league) +
"_Algo_V2_" + str(start_date) + "_" + str(end_date) +
"_backtest_odds.csv", to_save)
else:
self.universal.save_to_csv(
"./" + str(self.league) + "/analyze/" + str(self.league) +
"_Algo_V2_" + str(end_date) + "_backtest_odds.csv", to_save)
def team_comparison(self, algo_version, team1, team2, date, cur_year):
self.algo = Algo(self.league)
self.espn_scraper.update_data(team1, cur_year)
self.espn_scraper.update_data(team2, cur_year)
data1 = self.universal.load_data(team1, date, cur_year)
data2 = self.universal.load_data(team2, date, cur_year)
returned1 = self.analyze2(team1, team2, data1, "away")
returned2 = self.analyze2(team2, team1, data2, "home")
# print(str(team1)+" | "+str(team2))
# print(returned1)
# print(returned2)
# print()
if algo_version == "Algo_V1":
algo_data = self.algo.calculate(date, returned1, returned2)
elif algo_version == "Algo_V2":
algo_data = self.algo.calculate_V2(date, returned1, returned2)
record_points = algo_data['record_points']
home_away_points = algo_data['home_away_points']
home_away_10_games_points = algo_data['home_away_10_games_points']
last_10_games_points = algo_data['last_10_games_points']
avg_points = algo_data['avg_points']
avg_points_10_games = algo_data['avg_points_10_games']
# win_streak_10_games= algo_data['win_streak_10_games']
if self.league == "nhl":
win_streak_home_away = algo_data['win_streak_home_away']
total = algo_data['total']
to_output = []
to_output.append("")
to_output.append("Date: " + str(date))
to_output.append("Away: " + str(team1[1]) + " | Home: " +
str(team2[1]))
if algo_version == "Algo_V1":
win_streak = algo_data['win_streak']
win_streak_home_away = algo_data['win_streak_home_away']
if self.league == "nba":
to_output.append("Seasonal Record: " +
str(record_points * 10) + "/10 = " +
str(record_points))
to_output.append("Home Away: " +
str(home_away_points * 10) + "/10 = " +
str(home_away_points))
to_output.append("Home away 10: " +
str(home_away_10_games_points * 5) + "/5 = " +
str(home_away_10_games_points))
to_output.append("Last 10 games: " +
str(last_10_games_points * 5) + "/5 = " +
str(last_10_games_points))
to_output.append("Avg points: " +
str(avg_points * 8) + "/8 = " +
str(avg_points))
to_output.append("Avg points 10: " +
str(avg_points_10_games * 8) + "/8 = " +
str(avg_points_10_games))
to_output.append("Win streak: " +
str(win_streak * 3) + "/3 = " +
str(win_streak))
to_output.append("Win streak home away: " +
str(win_streak_home_away * 3) + "/3 = " +
str(win_streak_home_away))
else:
to_output.append("Seasonal Record: " +
str(record_points * 5) + "/5 = " +
str(record_points))
to_output.append("Home Away: " +
str(home_away_points * 5) + "/5 = " +
str(home_away_points))
to_output.append("Home away 10: " +
str(home_away_10_games_points * 5) + "/5 = " +
str(home_away_10_games_points))
to_output.append("Last 10 games: " +
str(last_10_games_points * 5) + "/5 = " +
str(last_10_games_points))
to_output.append("Avg points: " +
str(avg_points / 2) + "*2 = " +
str(avg_points))
to_output.append("Avg points 10: " +
str(avg_points_10_games / 2) + "*2 = " +
str(avg_points_10_games))
to_output.append("Win streak: " +
str(win_streak * 3) + "/3 = " +
str(win_streak))
to_output.append("Win streak home away: " +
str(win_streak_home_away * 3) + "/3 = " +
str(win_streak_home_away))
to_output.append("--------")
to_output.append("Total: " + str(total))
to_output.append("--------")
elif algo_version == "Algo_V2":
to_output.append("Seasonal Record: " + str(record_points) +
"%")
to_output.append("Home Away: " + str(home_away_points) +
"%")
to_output.append("Home away 10: " +
str(home_away_10_games_points) + "%")
to_output.append("Last 10 games: " +
str(last_10_games_points) + "%")
to_output.append("Avg points: " + str(avg_points) + "%")
to_output.append("Avg points 10: " +
str(avg_points_10_games) + "%")
# to_output.append("Win streak: "+str(win_streak)+"%")
if self.league == "nhl":
to_output.append("Win streak home away: " +
str(win_streak_home_away) + "%")
to_output.append("--------")
to_output.append("Total: " + str(total) + "%")
to_output.append("--------")
#chance of favorable team winning
if algo_version == "Algo_V1":
winning_odds = self.get_odds(total)
elif algo_version == "Algo_V2":
winning_odds = abs(total)
to_output.append("Perc chance to win: " + str(winning_odds) + "%")
favorable_odds = (100 / (100 - winning_odds) - 1) * 100
underdog_odds = (100 / (100 - winning_odds) - 1) * 100
to_output.append("Favorable team odds: -" + str(favorable_odds))
to_output.append("Underdog team odds: +" + str(underdog_odds))
return to_output
def predict(grammar_file: str, word: str):
word = word.strip().replace(' ', '')
grammar = Grammar.from_file(grammar_file)
algo = Algo()
algo.fit(grammar)
return algo.predict(word)
#GUI Version of TIC-TAC-TOE using kivy
import kivy
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.uix.button import Button
from kivy.uix.textinput import TextInput
from algo import Algo
my_algo = Algo()
AI_mode = False
player_name = ['X', 'O']
player_sign = ['X', 'O']
#Login Page
class Login(GridLayout):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.cols = 2
self.add_widget(Label(font_size=40, text="Tic Tac Toe"))
self.add_widget(Label(text="Subham_Games", font_size=20))
self.add_widget(Label(text="Player X:", font_size=20))
self.player_x = TextInput(multiline=False, font_size=20)
self.add_widget(self.player_x)
self.add_widget(Label(text="Player O:", font_size=20))
self.player_o = TextInput(text="Computer",
multiline=False,
font_size=20)
def train(self, pw,params, policy, critic, policy_loss_file, critic_loss_file, study_name, beta=0, is_cem=False):
all_weights=np.zeros((int(params.nb_cycles+1),policy.get_weights_dim(False)))
all_rewards=np.zeros(params.nb_cycles+1)
best_reward=-np.inf
best_weights=np.zeros(policy.get_weights_dim(False))
all_pops=np.zeros((params.nb_cycles,params.population,policy.get_weights_dim(False)))
all_pops_scores= np.zeros((params.nb_cycles,params.population))
# is_kept = np.zeros((params.nb_cycles,params.population))
list_elite_index=np.zeros((params.nb_cycles,int(params.elites_frac * params.population)))
fixed=params.fix_layers
idx_best=0
if is_cem == False:
if fixed:
print(fixed)
fc1_w, fc1_b, fc2_w, fc2_b = policy.get_weights_pg()
# print(fc1_w)
# print(policy.test())
if is_cem == True:
all_weights=np.zeros((int(params.nb_cycles+1),policy.get_weights_dim(fixed)))
best_weights=np.zeros(policy.get_weights_dim(fixed))
#random init of the neural network.
#so far, all the layers are initialized with the same gaussian.
init_weights = np.array(params.sigma*np.random.randn(policy.get_weights_dim(False)))
#print(np.shape(init_weights))
#start_weights=np.array(3*np.random.randn(policy.get_weights_dim(False)))
policy.set_weights(init_weights, False)
print(fixed)
#print(params.fix_layers)
#print(policy.get_weights_dim(params.fix_layers))
study = params.study_name
noise=np.diag(np.ones(policy.get_weights_dim(fixed))*params.sigma)
#print(np.shape(noise))
#var=np.cov(init_weights[:,-policy.get_weights_dim(fixed):],rowvar=False) + noise
#mu=init_weights[:,-policy.get_weights_dim(fixed):].mean(axis=0)
var=np.diag(np.ones(policy.get_weights_dim(fixed))*np.var(init_weights))+noise
print(np.shape(var))
mu=init_weights[-policy.get_weights_dim(fixed):]
all_weights[0]=mu
all_rewards[0]=self.evaluate_episode(policy, params.deterministic_eval)
print(np.shape(mu))
rng = np.random.default_rng()
#we can draw the last layer from a different gaussian
#mu=params.sigma_bis*np.random.randn(policy.get_weights_dim(params.fix_layers))
for cycle in range(params.nb_cycles):
if is_cem == True:
rewards = np.zeros(params.population)
weights=rng.multivariate_normal(mu, var, params.population)
for p in range(params.population):
policy.set_weights(weights[p], fixed)
batch=self.make_monte_carlo_batch(params.nb_trajs_cem, params.render, policy, True)
rewards[p] = batch.train_policy_cem(policy, params.bests_frac)
all_pops[cycle,p]=weights[p]
all_pops_scores[cycle,p]=rewards[p]
elites_nb = int(params.elites_frac * params.population)
elites_idxs = rewards.argsort()[-elites_nb:]
list_elite_index[cycle]=elites_idxs
# for i in elites_idxs:
# is_kept[cycle][i]=1
elites_weights = [weights[i] for i in elites_idxs]
#update the best weights
mu = np.array(elites_weights).mean(axis=0)
var = np.cov(elites_weights,rowvar=False)+noise
#print(best_weights)
# policy evaluation part
policy.set_weights(mu, fixed)
total_reward = self.evaluate_episode(policy, params.deterministic_eval)
if total_reward>best_reward:
best_weights=mu
best_reward=total_reward
idx_best=cycle
all_rewards[cycle+1]=total_reward
# if total_reward>np.min(top_ten_scores):
# temp_min=np.argmin(top_ten_scores)
# top_ten_scores[temp_min]=total_reward
# top_ten_policies[temp_min]=mu
# Update the file for the plot
# reward_file = policy_loss_file
# reward_file.write(str(cycle) + " " + str(total_reward) + "\n")
# if (cycle+1)%3==0:
# all_weights[int((cycle+1)/3)-1]=mu
all_weights[cycle+1]=mu
elif is_cem == False:
batch = self.make_monte_carlo_batch(params.nb_trajs_pg, params.render, policy)
# Update the policy
batch2 = batch.copy_batch()
algo = Algo(study_name, params.critic_estim_method, policy, critic, params.gamma, beta, params.nstep)
algo.prepare_batch(batch)
policy_loss = batch.train_policy_td(policy)
# if (cycle+1)%3==0:
# all_weights[int((cycle+1)/3)-1]=policy.get_weights_as_numpy()
all_weights[cycle]=policy.get_weights_as_numpy()
#print(policy_loss)
# Update the critic
assert params.critic_update_method in ['batch', 'dataset'], 'unsupported critic update method'
if params.critic_update_method == "dataset":
critic_loss = algo.train_critic_from_dataset(batch2, params)
elif params.critic_update_method == "batch":
critic_loss = algo.train_critic_from_batch(batch2)
critic_loss_file.write(str(cycle) + " " + str(critic_loss) + "\n")
policy_loss_file.write(str(cycle) + " " + str(policy_loss) + "\n")
plot_trajectory(batch2, self.env, cycle+1)
# policy evaluation part
if fixed:
policy.set_weights_pg(fc1_w, fc1_b, fc2_w, fc2_b)
total_reward = self.evaluate_episode(policy, params.deterministic_eval)
all_rewards[cycle]=total_reward
if total_reward>best_reward:
best_weights=policy.get_weights_as_numpy()
best_reward=total_reward
idx_best=cycle
print(total_reward)
# X_embedded = TSNE(n_components=2).fit_transform(all_cem_weights)
# # print(np.shape(X_embedded))
# # print(X_embedded)
# plt.scatter(*zip(*X_embedded))
# return all_weights,best_weights,all_rewards,idx_best
return all_weights,all_rewards,all_pops,all_pops_scores,list_elite_index
def main(argv):
#===== Initialization =====#
# Parse arguments
parser = argparse.ArgumentParser()
parser.add_argument('settings_file', type=str)
parser.add_argument('-s', '--sound', action='store_true', help="use sound as a feature in analysis")
parser.add_argument('-b', '--backup', action='store_true', help="start training on backup data")
parser.add_argument('-t', '--time_allign', action='store_true', help="collect data at times which are multiples of the granularity")
args = parser.parse_args(argv[1:])
# Initialize Zway server
port = 8083
host = '172.31.16.102'
zserver = zway.Server(host, port)
# Read settings from settings file
try:
settings_dict = settings.load(args.settings_file)
except Exception as error:
print "Error reading settings file.", error
print " "
exit(1)
# Initialize Algo class
granularity = int(settings_dict['granularity'])
training_window = int(settings_dict['training_window'])
training_interval = int(settings_dict['training_interval'])
ema_alpha = float(settings_dict['ema_alpha'])
severity_omega = float(settings_dict['severity_omega'])
severity_lambda = float(settings_dict['severity_lambda'])
auto_regression = int(settings_dict['auto_regression'])
num_features = len(zserver.device_IDs())
print "Num features: ", num_features
algo = Algo(granularity, training_window, training_interval, num_features)
algo.setSeverityParameters(severity_omega, severity_lambda)
algo.setEMAParameter(ema_alpha)
# Timing procedure
granularity = settings_dict['granularity'] * 60
granularity = 1
goal_time = time.time()
if args.time_allign:
goal_time = int(goal_time) + granularity - (int(time.time()) % granularity)
#===== Analysis =====#
while(True):
# Timing procedures
while goal_time > time.time():
time.sleep(0.2)
goal_time = goal_time + granularity
# Data collection
features = collect_features(zserver)
print list(features)
# Data analysis
target, pred = algo.run(features)
if (pred != None):
print target, pred, algo.checkSeverity(target, pred)
print "theta", algo.w_opt
else:
print target, pred
def train_pg(self,
pw,
params,
policy,
critic,
policy_loss_file,
critic_loss_file,
study_name,
beta=0) -> None:
"""
The main function for training and evaluating a policy
Repeats training and evaluation params.nb_cycles times
Stores the value and policy losses at each cycle
When the reward is greater than the best reward so far, saves the corresponding policy
:param pw: a policy wrapper, used to save the best policy into a file
:param params: the hyper-parameters of the run, specified in arguments.py or in the command line
:param policy: the trained policy
:param policy_loss_file: the file to record successive policy loss values
:return: nothing
"""
# Initialize variables
self.list_weights = []
self.best_weights = np.zeros(policy.get_weights_dim())
self.list_rewards = np.zeros((int(params.nb_cycles)))
self.best_reward = -1e38
self.best_weights_idx = 0
total_reward = self.best_reward
self.list_weights.append(policy.get_weights())
if params.start_from_policy:
starting_weights = get_starting_weights(pw)
policy.set_weights(starting_weights)
print("Shape of weights vector is: ", np.shape(self.best_weights))
initial_score = self.evaluate_episode(policy,
params.deterministic_eval,
params)
total_reward = initial_score
pw.save(cycle=0, score=initial_score)
self.env.write_reward(cycle=0, reward=initial_score)
with SlowBar('Performing a repetition of PG',
max=params.nb_cycles - 1) as bar:
for cycle in range(1, params.nb_cycles):
batch = self.make_monte_carlo_batch(params.nb_trajs,
params.render, policy)
if params.reinforce:
batch.sum_rewards()
policy_loss = batch.train_policy_td(policy)
# self.env.write_gradients(gradient_angles,cycle)
policy_loss_file.write(
str(cycle) + " " + str(policy_loss) + "\n")
batch = self.make_monte_carlo_batch(
params.nb_trajs, params.render, policy)
else:
# Update the policy
batch2 = batch.copy_batch()
algo = Algo(params.study_name, params.critic_estim_method,
policy, critic, params.gamma, beta,
params.nstep)
algo.prepare_batch(batch)
policy_loss = batch.train_policy_td(policy)
# Update the critic
assert params.critic_update_method in [
'batch', 'dataset'
], 'unsupported critic update method'
if params.critic_update_method == "dataset":
critic_loss = algo.train_critic_from_dataset(
batch2, params)
elif params.critic_update_method == "batch":
critic_loss = algo.train_critic_from_batch(batch2)
critic_loss_file.write(
str(cycle) + " " + str(critic_loss) + "\n")
policy_loss_file.write(
str(cycle) + " " + str(policy_loss) + "\n")
plot_trajectory(batch2, self.env, cycle + 1)
# add the new weights to the list of weights
self.list_weights.append(policy.get_weights())
distance = np.linalg.norm(self.list_weights[-1] -
self.list_weights[-2])
self.env.write_distances(cycle, distance)
self.write_angles_global(cycle)
# policy evaluation part
if (cycle % params.eval_freq) == 0:
total_reward = self.evaluate_episode(
policy, params.deterministic_eval, params)
# wrote and store reward
self.env.write_reward(cycle, total_reward)
self.list_rewards[cycle] = total_reward
# plot_trajectory(batch2, self.env, cycle+1)
# save best reward agent (no need for averaging if the policy is deterministic)
if self.best_reward < total_reward:
self.best_reward = total_reward
self.best_weights = self.list_weights[-1]
self.best_weights_idx = cycle
# Save the best policy obtained
if (cycle % params.save_freq) == 0:
pw.save(cycle=cycle, score=total_reward)
bar.next()
# pw.rename_best(method="PG",best_cycle=self.best_weights_idx,best_score=self.best_reward)
print("Best reward: ", self.best_reward)
print("Best reward iter: ", self.best_weights_idx)
"""
self._event_engine.unregister(algo)
if algo.config.launch_type == 'unactive':
self._event_manage.remove_Config(algo.config)
def deploy_algo(self):
pass
if __name__ == '__main__':
from BaseConfig import BaseConfig
from BaseAlgo import BaseAlgo
from algo import Algo
mainengin = MainEngine()
mainengin.start()
algo = Algo(BaseAlgo, BaseConfig)
mainengin.add_algo(algo)
mainengin.create_algo_instance('test_event', {
'id': 5,
'hello': 'world',
'haha': 'heihei'
})
for i in xrange(100):
mainengin.create_algo_instance('test_event', {
'id': 5,
i * 5: i,
i * 2: 'saa'
})
# mainengin.stop()
def __init__(self, grammar: Grammar):
self.grammar = grammar
self.algo = Algo()
self.algo.fit(grammar)
