def run(): print("-----------------------------------------") print("local ssd") ssd = "X:/cam_front_center" process_folder(ssd) # on a local ssd. print("-----------------------------------------") print("nas") with f.timing("get camera folders", units=1): folders, jsons, labels = f.get_camera_folders(f.get_path(), root=f.get_root()) print(len(folders), " camera folders") for folder in folders: process_folder(folder) if True: break print("-----------------------------------------") [print("local ssd")] process_folder(ssd) # on a local ssd.ls .. print("-----------------------------------------") print("just read some files in a camera folder.") print("nas") with f.timing("get camera folders", units=1): folders, jsons, labels = f.get_camera_folders(f.get_path(), root=f.get_root()) print(len(folders), " camera folders") for folder in folders: process_folder(folder) if True: break
def theme_path(request): smilies = Smilie.objects.all() return {'STATIC_THEME':settings.STATIC_URL+get_path(request.user) ,'BASE_PATH':get_path(request.user)+'base.html' ,'CURRENT_SITE':get_current_site(request) ,'THEME_PATH':get_path(request.user) ,'smilies':smilies}
def move_piece(self, piece, end): start = (piece.position[0], piece.position[1]) # Check if selected move is a vertical, horizontal, or diagonal move. if val_end_pos(piece.position, end): # Check if what is being moved is actually a playable piece. if self.board[start[0]][start[1]] != None or self.board[start[0]][ start[1]] != 0: path = get_path(start, end) # Validate every square along the path the piece will move if self.validate_path(path) == True: # Swap piece on board with empty square. self.board[start[0]][start[1]], self.board[end[0]][ end[1]] = self.board[end[0]][end[1]], self.board[ start[0]][start[1]] # Increase counter of total moves performed. self.board[end[0]][end[1]].moves_performed += 1 piece.position = end self.increment_time()
def save_settings(self, env, agent, multi_agent=False, curricular=None): pathname = fc.get_path() # get settings from env and agent input_sequence_length, kind_cars, num_lines, capacity_lines, output_sequence_length, input_window_length = env.get_stats( ) buffer_size, batch_size, update_every, gamma, tau, lr = agent.get_stats( ) # check if folder exists. create it otherwise f = open( "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP_NoVal/test.settings", "a") f.write("Gamma " + str(self.gamma) + "\n") f.write("Buffer Size " + str(buffer_size) + "\n") f.write("Batch Size " + str(batch_size) + "\n") f.write("Update Every " + str(update_every) + "\n") f.write("Tau " + str(tau) + "\n") f.write("LR " + str(lr) + "\n") f.write("Kind cars " + str(self.kind_cars) + "\n") f.write("Input length " + str(input_sequence_length) + "\n") f.write("Output length " + str(output_sequence_length) + "\n") f.write("Capacity Lines " + str(capacity_lines) + "\n") f.write("Num Lines " + str(num_lines) + "\n") if multi_agent: f.write("Multi Agent\n") if curricular: f.write("Curricular - Front and Back same settings") f.close()
def check_age(result, log_name, log_path, loginfo): directory_path = get_path() for filename, saved in loginfo[log_name + "-saved"].items(): if (saved + 2592000) < time(): remove((directory_path + log_path + filename)) else: result[log_name + "-saved"][filename] = saved return result
def get_files(units=None): images, jsons, labels = bf.get_camera_folders(bf.get_path(), root=bf.get_root()) print(len(images), ' folders for images') l = [] for folder in images: l = get_pngs(folder) break # just do one now. folder = images[0] l = l if units is None else l[:units] return l
def __init__(self, checkpoint_name, kind_cars, gamma): self.kind_cars = kind_cars self.gamma = gamma self.best_score = -float("inf") pathname = fc.get_path() counter = 0 dirname = checkpoint_name + "_" + str(counter) while dirname in os.listdir(pathname + '/results'): counter += 1 dirname = checkpoint_name + "_" + str(counter) self.checkpoint_name = dirname self.run_number = counter
def read_existing_notes(): os.system('clear') path = functions.get_path() notes_list = functions.get_notes(path) for note in notes_list: print(note) choice = functions.get_choice() note = functions.get_the_note(choice, notes_list) page = functions.open_note(path, note) os.system('clear') functions.reading(page) reading_options(page) functions.save_and_close_note(page)
def load_test_sequences(name): pathname = fc.get_path() f = open(pathname + 'testsequences/' + name + ".testsequence", "r") dim = f.readline().split() rows = int(dim[0]) cols = int(dim[1]) test_sequences = np.zeros((rows * cols), int) for i, line in enumerate(f): test_sequences[i] = int(line) f.close() test_sequences = test_sequences.reshape((rows, cols)) test_sequences = torch.tensor(test_sequences).long() return test_sequences
def run(): print("--------------------------------------------") x,y,z=f.get_camera_folders(f.get_path(),root=f.get_root()) title="cars by folder:" for i,folder in enumerate(x): files=f.get_files(folder,"*.png") units=len(files) print(i,"folder: "+folder,"has:",len(files),"files.") with f.timing("folder: "+folder+" ["+str(i)+"] has: "+str(len(files))+" files.",units,title): ds=tff.make_tensor_slices_dataset_list(files) print("----------------------------------------------") for i,folder in enumerate(x): files=f.get_files(folder,"*.png") units=len(files) print(i,"folder: "+folder,"has:",len(files),"files.") with f.timing("folder: "+folder+" ["+str(i)+"] has: "+str(len(files))+" files.",units,title): ds=tff.make_tensor_slices_dataset_list(files) mapped=ds.map(tff.parse1and,tff.autotune) tff.do_enumeration(mapped,parse2=tff.write_file) print("--------------------------------------------")
def create_test_sequences(number, length, KIND_CARS): name = 'N:' + str(number) + '_L:' + str(length) + '_KC:' + str(KIND_CARS) pathname = fc.get_path() + 'testsequences/' content = os.listdir(pathname) i = 1 new_name = name while new_name + '.testsequence' in content: new_name = name + '_' + str(i) i += 1 f = open(pathname + '/' + new_name + ".testsequence", "w") f.write(str(number) + ' ' + str(length) + "\n") for _ in range(number * length): f.write(str(random.randint(0, KIND_CARS - 1)) + "\n") f.close() return new_name
print("length is correct") #missing=set(['L:/a2d2/camera_lidar_semantic/20181016_095036/camera/cam_front_center','L:/a2d2/camera_lidar_semantic/20181204_191844/camera/cam_front_center']) missing_ = [ '20181016_095036/camera/cam_front_center', '20181204_191844/camera/cam_front_center' ] missing = [join(path, part) for part in missing_] print("we expect problems with:", missing) # L:/a2d2/camera_lidar_semantic/20181016_095036/camera/cam_front_center # L:/a2d2/camera_lidar_semantic/20181204_191844/camera/cam_front_center return get_files_from_camera_folders( (camera_folders, )) # do not remove the ',' root = f.get_root() path = f.get_path() (filename, image_filename, json_filename, label_filename) = f.get_my_filenames() image_filename = filename actual = [] if os.path.exists(image_filename): print(image_filename + " exists") print("reading:", image_filename) actual = f.read_filenames_from_disk(image_filename) else: print(image_filename + " does not exist.") print("examining camera folder for files") good = get_filenames_from_camera_folders(path, root=root) print(type(good), len(good), "file names") print(good[0]) images = good
bot.sendMessage( user, json_answers["notification_cam"].format( json_answers["cams"][int(notification)])) take_snapshot(bot, user, int(notification)) jsonfile["notify"] = {} dump_json_file("allowed_users.json", jsonfile) ## SATRTUP FUNCTION (well, better call it code than function) if __name__ == "__main__": config_log = load_json_file("config.json") bot = telepot.Bot(config_log["telegram-token"]) json_file = load_json_file("lang-" + config_log["main-language"] + ".json") json_answers = json_file["answers"] json_commands = json_file["commands"] ph = PlayListHandler(get_path() + "playlists.json") ph.main_folder = config_log["music-folder"] + "/" #STARTS BOT, AND INFINITE LOOP TO KEEP IT RUNNING MessageLoop(bot, handle).run_as_thread() while True: for _ in range(10): sleep(1) ph.update() send_notifications() ph.save_playlists()
with f.timing("import tensorflow",1): import tensorflow as tf print(tf.__version__) import tffunctions as tff x,y,z=f.get_lists_of_filenames() print("got (",len(x),len(y),len(z),") files.",flush=True) first=x[0] print("first file:",first,os.path.exists(first)) path=f.path_head(first) filename=f.path_leaf(first) print(path,filename) maybe='L:/ss/sem/20180807_145028/camera/cam_front_center/20180807145028_camera_frontcenter_000000091.png' if maybe==first: print("maybe =") print("maybe file:",maybe,os.path.exists(maybe)) x,y,z=f.get_camera_folders(f.get_path(),root=f.get_root()) title="cars by folder:" #with f.timing("folder: "+folder+" ["+str(i)+"] has: "+str(len(files))+" files.",units,title): # ds=tff.make_tensor_slices_dataset_list(files) filesets=f.getFilesets(x,"*.png") print(len(filesets),"filesets.") with f.timing("make datasets from filename sets.",len(x),title): datasets=tff.makeDatasets(filesets) print(len(datasets),"datasets, type:",type(datasets)) tff.time_enumeration(datasets,units=len(datasets)) # was 1892? # this will make the 44 datasets, one for each camera folder # naybe this is enough for this file. exit() print("---------------------------------------") def concat_datasets(datasets): ds0 = tf.data.Dataset.from_tensors(datasets[0])
# https://adventofcode.com/2019/day/3 from functions import get_path, fewest_steps_intersection wires = open('input').read().splitlines() paths = [{}, {}]; # wires = [ # 'R8,U5,L5,D3', # 'U7,R6,D4,L4' # ] for wire in range(len(wires)): instructions = wires[wire].split(',') paths[wire] = get_path(instructions) fewest_steps = fewest_steps_intersection(paths[0], paths[1]) print('Fewest steps: {}'.format(fewest_steps))
import os import sqlite3 import click import termcolor as tc from functions import get_path path = get_path() db = sqlite3.connect(os.path.realpath(path)) cursor = db.cursor() @click.command() @click.argument('name', default='thing') def add(name): try: cursor.execute("INSERT INTO warp_points (name, path) VALUES (?, ?)", (name, os.getcwd())) db.commit() print(tc.colored(f"Successfully added {name} warp point", "cyan")) except: print(tc.colored(f"{name} warp point already exists", "red")) if __name__ == "__main__": add()
others=list(set(maybies)-set(files)) printffo(files,folders,others) return (files,folders,others) def printijo(imageFiles,jsonFiles,otherFiles): print("image_files:",imageFiles[:3]) print("json_files:",jsonFiles[:3]) print("others:",otherFiles[:3]) def getijo(l:list): # images, jsons, others - should only be given files. imageFiles=[e for e in l if '.png' in e] maybeFiles=list(set(l)-set(imageFiles)) jsonFiles=[e for e in maybeFiles if '.json' in e] otherFiles=list(set(maybeFiles)-set(jsonFiles)) if len(maybeFiles)!=0: print("maybies:",maybeFiles[:3]) printijo(imageFiles,jsonFiles,otherFiles) return imageFiles,jsonFiles,otherFiles path=op.join(f.get_root(),f.get_path()) # these will be sorted (folders,y,z)=f.get_camera_folders(path) print('--------------------------') f.ppl0(folders,name="folders from get camera folders",print_=True) print('--------------------------') files,folders,others=getffo(path) print('--------------------------') for folder in folders: (files2,folders2,others2)=getffo(op.join(path,folder)) for folder2 in folders2: print("process folder:",folder2) files3,folders3,others3=getffo(op.join(path,folder,folder2)) # may need camera or lifar sun directory? for folder3 in folders3: print("process folder:",folder2) files4,folders4,others4=getffo(op.join(path,folder,folder2,folder3)) # may need camera or lifar sun directory? (imageFiles,jsonFiles,otherFiles)=getijo(files4)
def train(self, env, agent, checkpoint_length, n_episodes=8000, eps_start=1.0, eps_end=0.0001, eps_decay=0.999, show_picture = False, valid_actions_only = False, load_param = False): # initialise saving spots for better reading in the code run_number = self.save_settings(env, agent) pathname = fc.get_path() best_score_weights_filename = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP/bestscore_32.pth" weights_filename = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP/weights_32.pth" scores_filename = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP/scores.txt" best_score_optim_file = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP/bestscore_optim_32.pth" # status variables and plots scores = [] # list containing scores from each episode means = [] scores_window = deque(maxlen=checkpoint_length) # last 100 scores eps = eps_start # initialize epsilon episode = 1 if load_param : checkpoint = torch.load("/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP/bestscore_32_c.pth") eps = checkpoint['eps'] episode = checkpoint['episode'] agent.qnetwork_local.load_state_dict(checkpoint['model_state_dict']) agent.optimizer.load_state_dict(checkpoint['optim_state_dict']) agent.qnetwork_local.train() for i_episode in range(1, n_episodes + 1): env.reset(i_episode) state = env.get_state() state = self.linearize(state) score = 0 option_lengths = {opt:[] for opt in range(NUM_OPTIONS)} greedy_option = agent.greedy_option(state) current_option = 0 option_termination = True curr_op_len = 0 done = False counter = 0 while not done: if option_termination: option_lengths[current_option].append(curr_op_len) current_option = np.random.choice(NUM_OPTIONS) if np.random.rand() < eps else greedy_option curr_op_len = 0 action, logp, entropy = agent.act(state, eps, current_option, eval_mode = valid_actions_only, pa = env.possible_actions()) #action, logp, entropy = agent.act(state, eps, current_option, eval_mode = valid_actions_only) reward, next_state, done = env.step(action) # send the action to the environment and observe next_state = self.linearize(next_state) agent.step(state, current_option, reward, next_state, done, logp, entropy) state = next_state score += reward option_termination, greedy_option = agent.predict_option_termination(state, current_option) if done: break scores_window.append(score) scores.append(score) eps = max(eps_end, eps_decay * eps) means.append(np.mean(scores_window)) if i_episode % checkpoint_length == 0: score = np.mean(scores_window) # if current score is better, save the network weights and update best seen score if score > self.best_score: self.best_score = score torch.save({ 'episode' : i_episode, 'eps' : eps, 'model_state_dict' : agent.qnetwork_local.state_dict(), 'optim_state_dict' : agent.optimizer.state_dict() }, best_score_weights_filename) #torch.save(agent.qnetwork_local.state_dict(), best_score_weigths_filename) #torch.save(agent.optimizer.state_dict(),best_score_optim_file) #if show_picture: # clear_output(wait=True) #plt.scatter(range(len(scores)), scores, label='Scores', color='c', alpha=0.8, s=1) # plt.plot(np.arange(len(means)), means, label='Mean', color='r') # plt.ylabel('Score') # plt.xlabel('Episode #') # plt.show() print('\rEpisode {}\tAverage Score: {:.2f}\tBest Score: {:.2f}'.format(i_episode, score, self.best_score)) f = open(scores_filename, "a") for score in scores_window: f.write(str(score) + '\n') f.close() torch.save(agent.qnetwork_local.state_dict(), weights_filename) return scores
def curricular_train(self, env, back_agent, front_agent, n_iterations, checkpoint_length, n_episodes=8000, eps_start=1.0, eps_end=0.0001, eps_decay=0.999, valid_actions_only=False): self.save_settings(env, back_agent, curricular='Back') self.save_settings(env, front_agent, curricular='Front') pathname = fc.get_path() ## Wrapping training of one learning agent against fixed wagent ## def train(learning_agent, wrapper, wrapper_first, best_score_weights_file, weights_file, scores_file, itr): agent_name = 'Back' if 'Back' in weights_file else 'Front' # if we train the back agent, a1 should be None, because back agent starts. ### maw = MAW(env, None, wrapper) # if we train the front agent, a2 should be None, for the same reason ### maw = MAW(env, wrapper, None) a1, a2 = [wrapper, None][::wrapper_first] maw = MAW(env, a1, a2) # status variables and plots scores = [] # list containing scores from each episode means = [] scores_window = deque(maxlen=checkpoint_length) # last 100 scores eps = eps_start # initialize epsilon # flush the replay buffer of previous training experiences learning_agent.reset_memory() for i_episode in range(1, n_episodes + 1): maw.reset() state = maw.get_state() state = self.linearize(state) score = 0 done = False while not done: action = learning_agent.act(state, eps, eval_mode=valid_actions_only, pa=env.possible_actions()) reward, next_state, done = maw.step( action ) # send the action to the environment and observe next_state = self.linearize(next_state) learning_agent.step(state, action, reward, next_state, done) state = next_state score += reward if done: break scores_window.append(score) scores.append(score) eps = max(eps_end, eps_decay * eps) means.append(np.mean(scores_window)) if i_episode % checkpoint_length == 0: score = np.mean(scores_window) # if current score is better, save the network weights and update best seen score if score > self.best_score: self.best_score = score torch.save(learning_agent.qnetwork_local.state_dict(), best_score_weights_file) print( '\rCC Iteration {} ({}) Episode {}\tAverage Score: {:.2f}\tBest Score: {:.2f}' .format(itr, agent_name, i_episode, score, self.best_score)) f = open(scores_file, "a") for score in scores_window: f.write(str(score) + '\n') f.close() torch.save(learning_agent.qnetwork_local.state_dict(), weights_file) ## Perform Curricular Training ## # store scores of all iteration as list of tuples [(score_back_1,score_back_2), ..., (score_back_niter, score_front_niter)] all_scores = [] # initially use a random front agent front_wrapper = fc.RandomPlayer() for iteration in range(1, n_iterations + 1): # filenames for this iteration best_score_weights_filename_front = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + "_ITR:{itr}_Front_highScore.pth".format( itr=iteration) weights_filename_front = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_ITR:{itr}_Front.pth'.format( itr=iteration) best_score_weights_filename_back = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_ITR:{itr}_Back_highScore.pth'.format( itr=iteration) weights_filename_back = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_ITR:{itr}_Back.pth'.format( itr=iteration) scores_filename_back = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_ITR:{itr}_Back.scores'.format( itr=iteration) scores_filename_front = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_ITR:{itr}_Front.scores'.format( itr=iteration) # train back with fixed front scores_back = train(back_agent, front_wrapper, 1, best_score_weights_filename_back, weights_filename_back, scores_filename_back, iteration) back_wrapper = fc.Agent_wrapper(back_agent.qnetwork_local, env.kind_cars) # train front with fixed back scores_front = train(front_agent, back_wrapper, -1, best_score_weights_filename_front, weights_filename_front, scores_filename_front, iteration) front_wrapper = fc.Agent_wrapper(front_agent.qnetwork_local, env.kind_cars) all_scores.append((scores_back, scores_front)) return all_scores
def train(self, env, agent, checkpoint_length, n_episodes=8000, eps_start=1.0, eps_end=0.0001, eps_decay=0.999, show_picture=False, valid_actions_only=False): # initialise saving spots for better reading in the code run_number = self.save_settings(env, agent) pathname = fc.get_path() #best_score_weigths_filename = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_highScore.pth' #weights_filename = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '.pth' #scores_filename = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '.scores' best_score_weights_filename = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP_NoVal/bestscore_32.pth" weights_filename = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP_NoVal/weights_32.pth" scores_filename = "/media/shadowwalker/DATA/study/RIL1/code/carmanufacturing/test/results/CP_NoVal/scores.txt" # status variables and plots scores = [] # list containing scores from each episode means = [] scores_window = deque(maxlen=checkpoint_length) # last 100 scores eps = eps_start # initialize epsilon for i_episode in range(1, n_episodes + 1): env.reset(i_episode) state = env.get_state() state = self.linearize(state) score = 0 done = False while not done: action = agent.act(state, eps, eval_mode=valid_actions_only, pa=env.possible_actions()) reward, next_state, done = env.step( action) # send the action to the environment and observe next_state = self.linearize(next_state) agent.step(state, action, reward, next_state, done) state = next_state score += reward if done: break scores_window.append(score) scores.append(score) eps = max(eps_end, eps_decay * eps) means.append(np.mean(scores_window)) if i_episode % checkpoint_length == 0: score = np.mean(scores_window) # if current score is better, save the network weights and update best seen score if score > self.best_score: self.best_score = score torch.save(agent.qnetwork_local.state_dict(), best_score_weights_filename) if show_picture: clear_output(wait=True) #plt.scatter(range(len(scores)), scores, label='Scores', color='c', alpha=0.8, s=1) plt.plot(np.arange(len(means)), means, label='Mean', color='r') plt.ylabel('Score') plt.xlabel('Episode #') plt.show() print( '\rEpisode {}\tAverage Score: {:.2f}\tBest Score: {:.2f}'. format(i_episode, score, self.best_score)) f = open(scores_filename, "a") for score in scores_window: f.write(str(score) + '\n') f.close() torch.save(agent.qnetwork_local.state_dict(), weights_filename) return scores
def multi_train(self, env, agent_front, agent_back, checkpoint_length, n_episodes=8000, eps_start=1.0, eps_end=0.0001, eps_decay=0.999, show_picture=False, valid_actions_only=False): self.save_settings(env, agent_front, multi_agent=True) pathname = fc.get_path() best_score_weigths_filename_front = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + "_Front_highScore.pth" weights_filename_front = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_Front.pth' best_score_weigths_filename_back = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_Back_highScore.pth' weights_filename_back = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '_Back.pth' scores_filename = pathname + "/results/" + self.checkpoint_name + "/" + self.checkpoint_name + '.scores' scores = [] # list containing scores from each episode means = [] scores_window = deque(maxlen=checkpoint_length) # last 100 scores eps = eps_start # initialize epsilon # init figure fig = plt.figure() # ax = fig.add_subplot(111) for i_episode in range(1, n_episodes + 1): env.reset() state = env.get_state() score = 0 done = False while not done: state = self.linearize(env.get_state()) player = env.get_player() if player == 1: action = agent_front.act(state, eps, eval_mode=valid_actions_only, pa=env.possible_actions()) else: action = agent_back.act(state, eps, eval_mode=valid_actions_only, pa=env.possible_actions()) reward, next_state, done = env.step( action) # send the action to the environment and observe next_state = self.linearize(next_state) if player == 1: agent_front.step(state, action, reward, next_state, done) else: agent_back.step(state, action, reward, next_state, done) score += reward if done: break scores_window.append(score) scores.append(score) eps = max(eps_end, eps_decay * eps) means.append(np.mean(scores_window)) if i_episode % checkpoint_length == 0: score = np.mean(scores_window) # if current score is better, save the network weights and update best seen score if score > self.best_score: self.best_score = score torch.save(agent_front.qnetwork_local.state_dict(), best_score_weigths_filename_front) torch.save(agent_back.qnetwork_local.state_dict(), best_score_weigths_filename_back) if show_picture: plt.scatter(range(len(scores)), scores, label='Scores', color='c', alpha=0.8, s=1) plt.plot(np.arange(len(means)), means, label='Mean', color='r') plt.ylabel('Score') plt.xlabel('Episode #') plt.show() print( '\rEpisode {}\tAverage Score: {:.2f}\tBest Score: {:.2f}'. format(i_episode, score, self.best_score)) f = open(scores_filename, "a") for score in scores_window: f.write(str(score) + '\n') f.close() torch.save(agent_front.qnetwork_local.state_dict(), weights_filename_front) torch.save(agent_back.qnetwork_local.state_dict(), weights_filename_back) return scores