import tkinter
import tkinter.filedialog
from view import View
from controller import Controller
from model import Model
app = tkinter.Tk()
# アプリのウィンドウのサイズ設定
app.geometry("1000x430")
app.title("ocr_app[JunjiSakurai]")
model = Model()
view = View(app, model)
controller = Controller(app, model, view)
app.mainloop()
def model_with_two_articles():
return Controller(
ModelInMemory([
Article(title="title 1", text="text 1"),
Article(title="title 2", text="text 2")
]))
def main():
import sys
if path.exists('data/coordinates_1.yml'):
os.remove('data/coordinates_1.yml')
points = None
carPark = None
try:
fn = sys.argv[1]
except:
fn = 1
cap = video.create_capture(fn)
def fetchShortIntervalVideos(ctrl, motion_detector, coordinates_data,
times, statuses, lock):
with lock:
videoFilePath, hasIncomingVideoCaptureChanged = ctrl.getVideoFilePath(
)
return videoFilePath, hasIncomingVideoCaptureChanged, motion_detector, coordinates_data, times, statuses
threadn = cv.getNumberOfCPUs()
pending = deque()
lock = Lock()
pool = ThreadPool(processes=threadn,
initializer=init_child,
initargs=(lock, ))
threaded_mode = True
ctrl = None
motionDetector = None
lastsave = 0
coordinates_data = None
times = None
statuses = None
pointsCaptured = False
while True:
with lock:
while len(pending) > 1 and pending[0].ready() and pending[1].ready(
):
payload = pending.popleft().get()
if len(payload) == 6:
videoFilePath, hasIncomingVideoCaptureChanged, motion_detector, coordinates_data, times, statuses = payload
if videoFilePath == None and hasIncomingVideoCaptureChanged == None:
break
else:
if hasIncomingVideoCaptureChanged == True:
capture = cv.VideoCapture(videoFilePath)
while capture.isOpened():
result, frame = capture.read()
if not result:
capture.release()
continue
else:
res, evaluated_carPark = motion_detector.process_algo_per_frame(
frame, capture, coordinates_data,
times, statuses)
draw_str(
res, (5, 20),
CarParkData.TOTAL_NUMBER_OF_SLOTS +
str(evaluated_carPark.
get_total_car_park_slots()))
draw_str(
res, (5, 40), CarParkData.
NUMBER_OF_CARPARK_SLOTS_AVAILABLE +
str(evaluated_carPark.
get_available_carpark_slots()))
if carPark.is_carpark_full():
draw_str_red(
res, (5, 60),
CarParkData.CARPARK_FULL_MESSAGE)
else:
draw_str_green(
res, (5, 60), CarParkData.
CARPARK_AVAILABLE_MESSAGE)
#latest_modified_date_time = datetime.now()
#draw_str(res, (440,20), latest_modified_date_time.strftime('%d-%m-%Y %H:%M:%S '))
json = '['
for carpark_slot in evaluated_carPark.get_carpark_slots(
):
json = json + carpark_slot.toJSON(
) + ','
json = json[:-1]
json = json + ']'
json = json.replace('\n', '')
json = json.replace('\t', '')
json = json.replace('\r', '')
json = json.replace("\'", '')
json = json.replace(' ', '')
#retval, buffer = cv.imencode('.jpg', res)
#jpg_as_text = base64.b64encode(buffer)
if time.time() - lastsave > 1:
lastsave = time.time()
persistSmartParkRealTime(
None, None,
evaluated_carPark.
get_total_car_park_slots(),
evaluated_carPark.
get_available_carpark_slots(),
json, None, None)
cv.namedWindow('smart-parking',
cv.WINDOW_NORMAL)
cv.setWindowProperty('smart-parking', 0, 1)
cv.imshow('smart-parking', res)
if len(pending) < threadn:
if not pointsCaptured:
_ret, frame = cap.read()
points = getPoints(frame, points)
carPark = CarParkData('SmartCarPark', len(points))
ctrl = Controller(points, None, None)
motionDetector = MotionDetector(points, 1, carPark)
coordinates_data, times, statuses = motionDetector.detect_motion_activity(
)
pointsCaptured = True
if threaded_mode:
task_put_videos = pool.apply_async(captureShortIntervalVideos,
(cap, lock))
task_get_videos = pool.apply_async(
fetchShortIntervalVideos,
(ctrl, motionDetector, coordinates_data, times, statuses,
lock))
pending.append(task_put_videos)
pending.append(task_get_videos)
ch = cv.waitKey(1)
if ch == ord(' '):
threaded_mode = not threaded_mode
if ch == 27:
break
print('Done')
cap.release()
def setUp(self):
self.controller = Controller()
def assert_create_controller_with_model(model, expected_str):
controller = Controller(model)
assert str(controller) == expected_str
import numpy as np
import cv2
from drawer import draw_table, draw_ball, draw_feeder
from tracker import Tracker
from controller import Controller
#FRAME_SIZE = (1080, 1920)
cam = cv2.VideoCapture(1) #cv2.VideoCapture('feed_vid.mp4')
table = cv2.imread("table.png")
c = Controller()
t = Tracker()
img_array = []
tr = 0
size = None
while (True):
tr += 1
if (tr % 10 == 0): print(tr)
"""
frame = np.zeros(FRAME_SIZE).astype(np.int)
frame = draw_table(frame)
"""
frame = np.copy(table)
def main():
root = tk.Tk()
app = Controller(root)
app.render_app()
def __init__(self):
self.control = Controller()
def loop():
"""this is where the game is set up and run"""
pygame.init()
controller = Controller()
"""screen size"""
size = width, height = TOTAL_SIZE
black = 0, 0, 0
background = 30, 30, 30
screen = pygame.display.set_mode(size)
# ball = pygame.draw.circle(screen, (255, 0, 0), (10, 10), 10, 0)
center = [width / 2, height / 2]
render_speed = 33
animation_speed = 250
animation_mult = animation_speed // render_speed
animation_cnt = 0
step_speed = 600
step_mult = step_speed // render_speed
step_cnt = 0
top_shake = (20, 5)
num_shake_frames = 35
shake_list = [((i % 2) - random.random() * top_shake[0],
(i % 2) - random.random() * top_shake[1])
for i in range(num_shake_frames)]
shake_list += [(0, 0)]
shake = 0
controller.audio_controller.start_music()
start_screen(screen, controller)
"""this is the main loop for the game"""
while 1:
"""detection of escape key to close program"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
pygame.display.quit()
pygame.quit()
sys.exit()
elif event.key == pygame.K_RETURN or event.key == pygame.K_SPACE:
controller.enter()
elif event.key == pygame.K_r:
controller = Controller()
elif event.key == pygame.K_s:
shake += controller.start_round()
elif event.key == pygame.K_i:
controller.toggle_inv()
elif event.type == pygame.MOUSEBUTTONUP: # handle MOUSEBUTTONUP
pos = pygame.mouse.get_pos()
controller.click(pos)
elif event.type == pygame.MOUSEMOTION:
controller.handle_mouse(pygame.mouse.get_pos())
keys = pygame.key.get_pressed() # checking pressed keys
step_cnt = input_to_board(controller, keys, step_cnt)
screen.fill(background)
if not animation_cnt:
controller.step_animate()
if not step_cnt:
shake += controller.step()
if shake:
controller.pygame_handler.shakex = shake_list[shake][0]
controller.pygame_handler.shakey = shake_list[shake][1]
shake += 1
if shake == len(shake_list):
shake = 0
animation_cnt = (animation_cnt + 1) % animation_mult
step_cnt = (step_cnt + 1) % step_mult
controller.render(screen)
pygame.display.flip()
pygame.time.wait(render_speed)
pygame.display.quit()
pygame.quit()
sys.exit()
def controller(mock_repository):
return Controller(mock_repository)
def main():
initialize_logger(SERVICE_NAME)
logging.getLogger(KUBERNETES_PKG).setLevel(logging.ERROR)
controller = Controller()
controller.start()
def main():
drone = init_drone()
controller = Controller(drone)
controller.start()
import time
from controller import Controller
control = Controller('configs/config5.json')
control.startReplicas()
control.startClients()
time.sleep(15)
control.terminateAll()
def run(self):
# print(self.flags.getPredictFlag())
print('controller running')
controller = Controller(self.flags)
controller.run()
config_file_name = 'config.json'
try:
if os.path.isfile(config_file_name):
with open(config_file_name) as config_file:
config = json.load(config_file)
if config.__contains__(name):
return config[name]
else:
print('CRITICAL: cannot get token in config file ' + name)
logging.critical('Cannot get token in config file ' + name)
else:
if os.environ.__contains__(name):
return os.environ[name]
else:
print('CRITICAL: cannot get token in OS environment ' + name)
logging.critical('Cannot get token in OS environment ' + name)
except Exception as error:
print('CRITICAL: cannot get token, reason: ' + error.__str__())
logging.critical('Cannot get token, reason: ' + error.__str__())
logging.basicConfig(
filename='logs.log',
level=logging.INFO,
format='%(asctime)s %(name)-30s %(levelname)-8s %(message)s')
if __name__ == '__main__':
controller = Controller(get_token('CLARIFAI_TOKEN'),
get_token('TELEGRAM_BOT_TOKEN'))
controller.start()
def main():
c = Controller()
c.run_dl_agent_graphics()
import logging
import sys
from controller import Controller
if __name__ == '__main__':
# Configure the logger
logging.basicConfig(
stream=sys.stdout,
level=logging.DEBUG,
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
controller = Controller()
controller.train_controller()
def __init__(self, master):
self.master = master
self.model = Model()
self.controller = Controller(self.model)
master.title("Calculator")
self.master.rowconfigure((0, 1, 2, 3, 4, 5), weight=1)
self.master.columnconfigure((0, 1, 2, 3), weight=1)
self.display = StringVar()
self.display_label = Label(master,
anchor=E,
textvariable=self.display,
font=(None, 48))
self.display_label.grid(columnspan=4, sticky=E + W)
# Row 1
self.clear_entry_button = Button(
master, text="CE", command=lambda: self.click_handler("CE"))
self.clear_entry_button.grid(row=1, sticky=N + S + E + W)
self.clear_button = Button(master,
text="C",
command=lambda: self.click_handler("C"))
self.clear_button.grid(row=1, column=1, sticky=N + S + E + W)
self.delete_button = Button(master,
text="⌫",
command=lambda: self.click_handler("Del"))
self.delete_button.grid(row=1, column=2, sticky=N + S + E + W)
self.division_button = Button(master,
text="÷",
command=lambda: self.click_handler("/"))
self.division_button.grid(row=1, column=3, sticky=N + S + E + W)
# Row 2
self.digit7_button = Button(master,
text="7",
command=lambda: self.click_handler("7"))
self.digit7_button.grid(row=2, sticky=N + S + E + W)
self.digit8_button = Button(master,
text="8",
command=lambda: self.click_handler("8"))
self.digit8_button.grid(row=2, column=1, sticky=N + S + E + W)
self.digit9_button = Button(master,
text="9",
command=lambda: self.click_handler("9"))
self.digit9_button.grid(row=2, column=2, sticky=N + S + E + W)
self.multiplication_button = Button(
master, text="×", command=lambda: self.click_handler("*"))
self.multiplication_button.grid(row=2, column=3, sticky=N + S + E + W)
# Row 3
self.digit4_button = Button(master,
text="4",
command=lambda: self.click_handler("4"))
self.digit4_button.grid(row=3, sticky=N + S + E + W)
self.digit5_button = Button(master,
text="5",
command=lambda: self.click_handler("5"))
self.digit5_button.grid(row=3, column=1, sticky=N + S + E + W)
self.digit6_button = Button(master,
text="6",
command=lambda: self.click_handler("6"))
self.digit6_button.grid(row=3, column=2, sticky=N + S + E + W)
self.subtraction_button = Button(
master, text="−", command=lambda: self.click_handler("-"))
self.subtraction_button.grid(row=3, column=3, sticky=N + S + E + W)
# Row 4
self.digit1_button = Button(master,
text="1",
command=lambda: self.click_handler("1"))
self.digit1_button.grid(row=4, sticky=N + S + E + W)
self.digit2_button = Button(master,
text="2",
command=lambda: self.click_handler("2"))
self.digit2_button.grid(row=4, column=1, sticky=N + S + E + W)
self.digit3_button = Button(master,
text="3",
command=lambda: self.click_handler("3"))
self.digit3_button.grid(row=4, column=2, sticky=N + S + E + W)
self.addition_button = Button(master,
text="+",
command=lambda: self.click_handler("+"))
self.addition_button.grid(row=4, column=3, sticky=N + S + E + W)
# Row 5
self.plus_minus_button = Button(
master, text="±", command=lambda: self.click_handler("+/-"))
self.plus_minus_button.grid(row=5, sticky=N + S + E + W)
self.digit0_button = Button(master,
text="0",
command=lambda: self.click_handler("0"))
self.digit0_button.grid(row=5, column=1, sticky=N + S + E + W)
self.decimal_point_button = Button(
master, text=".", command=lambda: self.click_handler("."))
self.decimal_point_button.grid(row=5, column=2, sticky=N + S + E + W)
self.equals_button = Button(master,
text="=",
command=lambda: self.click_handler("="))
self.equals_button.grid(row=5, column=3, sticky=N + S + E + W)
self.display.set(self.model.display)
def main():
parser = ArgumentParser()
parser.add_argument("-mo",
"--mode",
dest="mode",
help="Select machine,database or application",
metavar="mode")
#application
parser.add_argument("-san",
"--SourceAppName",
dest="source_appname",
help="Select AppDynamics app name",
metavar="source_appname")
parser.add_argument("-sai",
"--SourceAppId",
dest="source_appid",
help="Select AppDynamics app id",
metavar="source_appid")
parser.add_argument("-tan",
"--TargetAppName",
dest="target_appname",
help="Select AppDynamics app name",
metavar="target_appname")
parser.add_argument("-tai",
"--TargetAppId",
dest="target_appid",
help="Select AppDynamics app id",
metavar="target_appid")
#server
parser.add_argument("-ssg",
"--SourceSubGroup",
dest="source_subgroup",
help="Select Source Subggroup",
metavar="source_subgroup")
parser.add_argument("-dsg",
"--DestSubGroup",
dest="dest_subgroup",
help="Select Dest Subggroup",
metavar="dest_subgroup")
#database
parser.add_argument("-l",
"--Line",
dest="line",
help="Select a line like PS|BAP|HDEV6-SL0",
metavar="line")
args = parser.parse_args()
Config = configparser.ConfigParser()
Config.read("config.txt")
controllerURL = Config.get("CONTROLLER", "controllerURL")
account = Config.get("CONTROLLER", "account")
client_name = Config.get("CONTROLLER", "api_client_name")
client_secret = Config.get("CONTROLLER", "api_client_secret")
log_file_name = Config.get("LOGGING", "file_name")
log_level = Config.get("LOGGING", "log_level")
user = Config.get("CONTROLLER", "user")
password = Config.get("CONTROLLER", "password")
ceritficateFilePath = Config.get("CONTROLLER", "ceritficateFilePath")
server_application_id = Config.get("CONTROLLER", "server_application_id")
database_application_id = Config.get("CONTROLLER",
"database_application_id")
logger = logging.getLogger("SYNCHER")
if log_level == "DEBUG": logger.setLevel(logging.DEBUG)
elif log_level == "INFO": logger.setLevel(logging.INFO)
else:
print("Logging level not defined - will log to INFO")
logger.setLevel(logging.INFO)
fh = logging.FileHandler(log_file_name)
formatter = logging.Formatter(
'HR_MIGRATION - %(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
ctrl = Controller(account,
client_name,
client_secret,
logger,
user=user,
password=password,
controllerURL=controllerURL,
ceritficateFilePath=ceritficateFilePath,
server_application_id=server_application_id,
database_application_id=database_application_id)
account, client_name, client_secret = "", "", ""
app_name = ""
app_id = -1
source_appname, source_appid, target_appname, target_appid, source_subgroup, dest_subgroup = "", "", "", "", "", ""
for arg in vars(args):
value = getattr(args, arg)
print("'" + str(arg) + "' = '" + str(value) + "'")
if arg == "mode": mode = value
#if arg == "source_subgroup": source_subgroup = value
if arg == "dest_subgroup": dest_subgroup = value
if arg == "source_appname": source_appname = value
if arg == "source_appid": source_appid = value
if arg == "target_appname": target_appname = value
if arg == "target_appid": target_appid = value
if arg == "line": line = value
if mode == "database":
line = line.split("|")
opstool = ITMOpsTool("user", "pwd")
db = opstool.getDatabaseByLine(line)
print("db = " + str(db))
oltp_db = db["oltp_db"]
olap_db = db["olap_db"]
print("oltp_db = " + str(oltp_db))
print("olap_db = " + str(olap_db))
hrs = ctrl.get_health_rules_by_reference_database(
database_application_id)
if mode == "machine":
ctrl.ui_login()
#if not ctrl.doesSubGroupExist(source_subgroup):
# print("source_subgroup '" + str(source_subgroup) + "' does not exist! Exit")
# sys.exit(-1)
if not ctrl.doesSubGroupExist(dest_subgroup):
print("dest_subgroup '" + str(dest_subgroup) +
"' does not exist! Exit")
sys.exit(-1)
#hrs = ctrl.get_health_rules_by_server_subgroup(source_subgroup)
#SubGroup = "Root|Machine|Path|Here"
hrs = ctrl.get_health_rules_with_details(server_application_id)
for hr in hrs:
hr_name = hr["name"]
if hr_name.lower().endswith("template"):
print("hr before change = " + str(hr))
if "serverSelectionCriteria" in hr["affects"]:
hr["affects"]["serverSelectionCriteria"][
"affectedServers"]["subGroups"] = [
"Root|" + dest_subgroup
]
dest_subgroups_segments = dest_subgroup.split("|")
suffix = dest_subgroups_segments[
-2] + "-" + dest_subgroups_segments[-1]
prefix = ""
for i in range(len(dest_subgroups_segments) - 2):
prefix = prefix + dest_subgroups_segments[i] + "-"
prefix = prefix[:-1]
hr["name"] = replace_ignorecase(hr["name"], "template",
suffix)
hr["name"] = prefix + hr["name"]
print("hr after change = " + str(hr))
ctrl.create_health_rules(server_application_id, hrs)
if mode == "application":
if not (source_appname == None) and not (source_appid == None):
print("Do not provide source_appname and source_appid! Abort")
sys.exit(-1)
if not (target_appname == None) and not (target_appid == None):
print("Do not provide target_appname and target_appid! Abort")
sys.exit(-1)
if not (source_appname == ""):
source_app_id = ctrl.get_id_by_app_name(source_appname)
if not (target_appname == ""):
target_appid = ctrl.get_id_by_app_name(target_appname)
health_rules = ctrl.get_health_rules(source_app_id)
health_rules_details = []
for hr in health_rules:
hr_id = hr["id"]
tmp = ctrl.get_health_rule_details(source_app_id, hr_id)
health_rules_details.append(tmp)
ctrl.create_health_rules(target_appid, health_rules_details)
def __init__(self):
print("Starting...")
self.controller = Controller()
self.image = Image()
self.stopwatch = Stopwatch()
'''
InfraGOTApp is a prototype program in Python that supports IFC workflow for infrastructure projects
with the use of Object-Relational Mapper (Pony ORM), database (PostgreSQL) and IfcOpenShell
@author Sara Guerra de Oliveira, Andrej Tibaut
@modified 2019, 2020
@version 1.0
'''
# ## LIBRARIES in use
from controller import Controller
# start of the main module
if __name__ == '__main__':
c = Controller() # initialize a controller
c.run() # run the controller
def index():
ctrl = Controller()
user_id = ctrl.get_current_user_id()
return render_template('index.html', value=user_id)
if __name__ == "__main__":
# Create QT application
app = QtWidgets.QApplication(sys.argv)
# LIN Adapter
linAdapter = LINAdapter()
# Create Modell
model = Model(linAdapter)
# Create controller / main window
controller = Controller(model)
# Register Controller in model
model.registerController(controller)
# Set program version
controller.setWindowTitle(WINDOW_TITLE)
# Disable window resizing
#mainWindow.setFixedSize(mainWindow.size())
# Show main window
controller.show()
# Start QT application
sys.exit(app.exec_())
def get_image_url():
movie_id = request.args.get('movie_id', '')
ctrl = Controller()
return jsonify({"image_url": ctrl.get_image_url(movie_id)})
def model_with_one_article():
return Controller(ModelInMemory([Article(title="title 1", text="text 1")]))
def setup_db():
ctrl = Controller()
ctrl.setup_db()
def test_should_list_one_article(model_with_one_article):
controller = Controller(model_with_one_article)
articles = controller.get_all_articles()
assert len(articles) == 1
assert articles[0].get_title() == "title 1"
assert articles[0].get_text() == "text 1"
def train(self,
plot_every=10,
save_every=100,
resample=False,
true_controller=False,
steps_to_solve=10):
tru = Controller(vj=0.75, dt=0.05, u_max=2., radius=1.,
A=0.1) # DEBUG only
reached = 0
solved = 0
solved_max = 0
if not self.built:
self.build()
self.sess.run(self.sync)
min_buf_fill = False
for i in range(self.epoch):
dP = np.array([0.001, 0.001])
s = self.env.reset()
total_reward = 0
terminal = False
step_gamma = 1
a_p = 0
resample_counter = 0
if solved > steps_to_solve:
print('SOLVED')
break
for step in range(self.max_path_length):
do_resample = 0
if terminal:
break
a, var_a = self.get_action(s)
# normalization variance to probability
clipped_var = np.clip(var_a, -1, 0)
prob_action = (np.exp(clipped_var) - 0.367) / 0.633
var_p = np.zeros(
(self.predictor.obs_length + self.predictor.pred_length,
2))
for index, var in enumerate(prob_action):
if (np.random.random() < var) and (
step > self.predictor.obs_length) and resample:
do_resample = 1
self.env.reset_magic()
if do_resample:
resample_counter += 1
step_gamma = 0 # mixing iterative learning reset condition
if true_controller: # DEBUG only
err, a_p, dP = tru.point(np.asarray(s[0:2]),
dP,
self.env.target,
magic=75.)
else: # NORMAL operation
self.env.magic = 4.
path = self.env.get_path(self.predictor.obs_length)
self.path_predicted, mu_p, var_p = self.predictor.predict(
path, full=True)
a_p = self.path_predicted[self.predictor.obs_length +
self.predictor.pred_length -
1]
# mixing iterative learning
gamma_decayed = self.gamma**step_gamma
a = a * (1. - gamma_decayed) + a_p * gamma_decayed
step_gamma += 1
next_s, r, terminal, env_info = self.env.step(a)
total_reward += r
self.replay_buffer.add_sample(s, a, r * self.scale_reward,
terminal)
if self.replay_buffer.size >= self.min_buffer_size:
if not min_buf_fill:
print('minimum buffer filled')
min_buf_fill = True
batch = self.replay_buffer.random_batch(self.batch_size)
self.optimize_q(batch)
self.optimize_pi(batch)
self.sess.run(self.soft_updater)
# plotting
if (not i % plot_every):
self.env.render()
if step > self.predictor.obs_length:
self.env.render_predicted(self.path_predicted)
# whether the run is solved (conditions)
if total_reward and not resample_counter:
solved += 1
else:
solved = 0
if solved > solved_max:
solved_max = solved
if total_reward:
reached += 1
print('episode:',
i,
' reward:',
total_reward,
' resampled:',
resample_counter,
'of',
step,
' solved: %.0f%%' % (100 * solved / steps_to_solve),
'(max: %.0f%%)' % (100 * solved_max / steps_to_solve),
flush=True)
# save weights
if (not i % save_every) and (i > 0):
print('save_old weights at', i)
self.net.model.save('save_svg/model_' + str(i) + '.h5')
self.net.q_model.save('save_svg/q_model_' + str(i) + '.h5')
self.net.pi_model.save('save_svg/pi_model_' + str(i) + '.h5')
self.net.mu_model.save('save_svg/mu_model_' + str(i) + '.h5')
self.net.var_a_model.save('save_svg/var_a_model_' + str(i) +
'.h5')
self.net.target_model.save('save_svg/target_model_' + str(i) +
'.h5')
self.net.q_model.save('save_svg/target_q_model_' + str(i) +
'.h5')
self.net.target_pi_model.save('save_svg/target_pi_model_' +
str(i) + '.h5')
self.net.target_mu_model.save('save_svg/target_mu_model_' +
str(i) + '.h5')
self.net.target_var_a_model.save(
'save_svg/target_var_a_model_' + str(i) + '.h5')
print('Reached', reached, '/', self.epoch)
def bets():
""" bets route """
if request.method == "POST":
Controller().add_funds()
return render_template("bets.html", controller=Controller())
from values.mlp import MLPValue
from utils.check_env import environment_check
name = 'Pendulum-v0'
state_dim, action_dim, action_min, action_max = environment_check(name)
hidden_dim = 20
value_model = MLPValue([state_dim, 128, 64, 32, 1],
learning_rate=1e-4,
activation=F.tanh,
epsilon=0.1,
eta=10)
policy_model = MLPNormalPolicy([state_dim, 128, 64, 32, 2],
sigma=2,
learning_rate=1e-4,
act_bound=1,
activation=F.tanh)
prefix = "try"
policy_model = torch.load(
'../results/results/Pendulum-v0_Final1_policy_best.pth')
model = Controller(name,
policy_model,
value_model,
reset_prob=0.002,
history_depth=1,
verbose=True,
cuda=True)
print(model.evaluate(20, True))
