def run(): input_txt = __prompt() input_cmd = __easy_parse(input_txt) #input_cmd = __parse(input_txt) model.run(input_cmd)
def test_recording(): with open(log_path, "a") as file: file.write("recording activate rate is as follows.\n") data = from_pickle() for folder in data.keys(): recording_sum = 0 activate_sum = 0 for recording in data[folder]: if len(recording) < 8000: continue recording_sum += 1 section_num = math.ceil(len(recording) / 8000) for i in range(section_num): if i == section_num - 1: result = run(recording[-8000:]) else: result = run(recording[i * 8000:(i + 1) * 8000]) if result == 0: activate_sum += 1 break with open(log_path, "a") as file: file.write(folder + ": " + str(activate_sum) + "/" + str(recording_sum) + " = " + str(activate_sum / recording_sum) + "\n")
def main(): """ main """ models = { "resnet": model.ResNet50Benchmark, "mobilenet": model.ResNet50Benchmark, "vgg": model.ResNet50Benchmark, "googlenet": model.ResNet50Benchmark, "shufflenet": model.ResNet50Benchmark, "MobileNet_SSD": model.ResNet50Benchmark, "deeplab": model.ResNet50Benchmark, "rcnn": model.RcnnBenchmark, "yolo": model.YoloBenchmark, "transformer": model.TransformerBenchmark, "bert": model.BertBenchmark } args = parse_args() model = models.get(args.model)() model.set_config(use_gpu=args.device == 'gpu', model_dir=args.model_dir, model_filename=args.model_filename, params_filename=args.params_filename, use_tensorrt=args.use_tensorrt, use_anakin=args.use_anakin, model_precision=args.model_precision) tensor = model.load_data(args.filename) warmup = args.warmup repeat = args.repeat model.run(tensor, warmup, repeat)
def main(): # read config config = ConfigParser.ConfigParser() config.read('zero-shot.cfg') dataset = config.get('data', 'dataset') method = config.get('model', 'method') # load data data = load_data.run(dataset, method, config) # train model model.run(data, method, config)
def test_frame(): with open(log_path, "a") as file: file.write("frame activate rate is as follows.\n") data = from_pickle() for folder in data.keys(): activate_sum = 0 frame_sum = 0 for recording in data[folder]: sr = 8000 th = 0.05 r = 0.1 s = max(0, (recording < th).argmin() - int(r * sr)) t = min(-1, -((recording < th)[::-1].argmin()) + int(r * sr)) recording = recording[s:t] if folder == "./recordings/5cm-pen-re/": window = 1000 bar_l = 1 bar_h = 1 section = 0 for i in range(int(len(recording) / window)): sum = np.sum(recording[i * window:(i + 1) * window]**2) if sum > bar_h: break if sum <= bar_l: section = i recording = recording[(section + 1) * window:] if len(recording) < 8000: continue section_num = math.ceil(len(recording) / 8000) for i in range(section_num): frame_sum += 1 if i == section_num - 1: result = run(recording[-8000:]) else: result = run(recording[i * 8000:(i + 1) * 8000]) if result == 0: activate_sum += 1 with open(log_path, "a") as file: file.write(folder + ": " + str(activate_sum) + "/" + str(frame_sum) + " = " + str(activate_sum / frame_sum) + "\n")
def run_game(self, u): seed = seeds[u] acts = actions[u] print 'running', u, seed, acts return model.run(seed, *acts)
def selectAudio(name,path): result = model.run(path+"/"+name) query = "SELECT phrase_id, upload_at FROM audio WHERE name = '"+name+"' LIMIT 1;" data = "" cursor = conn.run_query(query,data) phrase_id = "" upload_at = "" for (phrase, date_audio) in cursor: phrase_id = str(phrase) upload_at = date_audio #insertPhrases(users_id,'quz','esp','txt',result,result,0,upload_at) query = "SELECT user_id, text_source, text_target FROM phrase WHERE phrase_id = '"+phrase_id+"' LIMIT 1;" cursor = conn.run_query(query,data) text_source = "" text_target = "" user_id = "" for (u, q, s) in cursor: user_id = u text_source = q text_target = s #data = {'user_id': user_id ,'upload_at': upload_at, 'name':name,'text_source':text_source,'text_target':text_target} data = {'user_id': "1" ,'upload_at': "22-02-18", 'name':"hispana.wav",'text_source':result,'text_target':result} final = final = json.dumps(data,ensure_ascii=False).encode('utf8') return final
def run_for_plotting(): # run params N = 200 time = 0.02 speed = 2.0 # motion distance is equal to speed (we assume time = 1) # the controller ( P, I, D, dt ) #pid_controller = controller.PID_Controller(0.4, 0.001, 0.01, time) # why does this work so well? pid_controller = controller.PID_Controller(0.0, 0.0, 0.01, time) #pid_controller = controller.PID_Controller(0.2, 0.001, 0.01, time) pid_controller = controller.PID_Controller(0.5, 0.038, 0.0108, time) #build the track mytrack = track.get_track_1() line_seg_track = track.convert_to_line_segs(mytrack) track.write_to_file(mytrack, 'generated_files/track.csv') # create the car mycar = model.build_default_car(time, speed) mycar.write_to_file('generated_files/car_data.csv') # Main program pos_out, sense_out = model.run(N, time, pid_controller, line_seg_track, mycar, speed) f_Pos = open('generated_files/run_output.csv','w') for pos in pos_out: f_Pos.write("%s\n" % (pos)) f_Pos.close() f_Sense = open('generated_files/sense_output.csv','w') for pos in sense_out: f_Sense.write("%s\n" % (pos)) f_Sense.close()
def uploads(): if request.method == 'GET': return render_template('upload.html') else: if 'content' not in request.files: flash('No content image selected') return redirect(request.url) content = request.files['content'] if 'style' not in request.files: flash('No style image selected') return redirect(request.url) style = request.files['style'] if content.filename == '' or style.filename == '': flash('Error, please, try again') return redirect(request.url) if style and allowed_file(style.filename) and \ content and allowed_file(content.filename): style_path = os.path.join(app.config['UPLOAD_PATH'], 'style.jpeg') style.save(style_path) content_path = os.path.join(app.config['UPLOAD_PATH'], 'content.jpeg') content.save(content_path) return run()
def main(src): if not src: err("Argument list empty") quit() for path in src: with open(path, 'r') as f: txt = f.read() print(run(txt))
def main(args): batch_size = args.batch_size n_epoch = args.n_epoch n_step = args.n_step keep_prob = args.keep_prob n_hidden_units = args.n_hidden_units embedding_size = args.embedding_size initial_learning_rate=args.initial_learning_rate final_learning_rate=args.final_learning_rate assert args.embedding in ['random', 'one_hot'], 'Unrecognized embedding method' random_embedding = True if args.embedding == 'random' else False assert args.granularity in ['single', 'multi'], 'Unrecognized granularity' multi_granined = True if args.granularity == 'multi' else False assert args.granularity_out in ['single', 'multi'], 'Unrecognized granularity' multi_granined_out = True if args.granularity_out == 'multi' else False assert args.train_mode in ['step', 'epoch'], 'Unreconized traning mode (please specify step or epoch)' PrepData = IO() train_response_list, question_list = PrepData.load_model_input(fname_TrainData, sep=',') test_response_list, question_list = PrepData.load_model_input(fname_TestData, sep=',', question_list=question_list) id_encoding = PrepData.question_id_1hotencoding(question_list) category_map_dict = PrepData.load_category_map(fname_MapData, sep=',') category_encoding = PrepData.category_id_1hotencoding(category_map_dict) skill2category_map =PrepData.skill_idx_2_category_idx(category_map_dict, category_encoding) n_id = len(id_encoding) n_categories = len(category_encoding) # print {skill: category_encoding[category_map_dict[skill]] for skill in category_map_dict.keys()} # print skill2category_map train_batches = BatchGenerator(train_response_list, batch_size, id_encoding, n_id, n_id, n_categories, random_embedding=random_embedding, skill_to_category_dict=skill2category_map, multi_granined_out=multi_granined_out) test_batches = BatchGenerator(test_response_list, batch_size, id_encoding, n_id, n_id, n_categories, random_embedding=random_embedding, skill_to_category_dict=skill2category_map, multi_granined_out=multi_granined_out) sess = tf.Session() run(sess, train_batches, test_batches, \ option=args.train_mode, record_performance=True, \ model_saved_path=os.path.join(MODEL_FOLDER, MODEL_FILE), n_step=n_step, random_embedding=random_embedding, multi_granined=multi_granined, \ n_categories=n_categories, out_folder=DATA_FOLDER, out_file=fname_Result, \ keep_prob=keep_prob, n_hidden_units=n_hidden_units, embedding_size=embedding_size, \ initial_learning_rate=0.001, final_learning_rate=0.00001, multi_granined_out=multi_granined_out) # tensorboard --logdir logs writer = tf.summary.FileWriter(MODEL_LOG_FOLDER, sess.graph) # http://localhost:6006/#graphs on mac sess.close()
def do_magic(image_path): '''Do Your Image mining stuff right here & return some json data to your android app using 'result' variable. ''' # result = {'status': 'done'} # as an example result = run(image_path) # uncommant this line if you want to remove the image after dealing with it. #os.remove(image_path) return jsonify(result)
def swi_demand_json(self, model, index, **params): p = {} for k, v in params.items(): if k.startswith('key_'): p[k[4:]] = float(v) import gbm model = getattr(gbm.models, model)() r = model.run(**p) data = model.plot_nvd3(r) return json.dumps(dict(main=data, index=int(index)))
def main(): assert len(factor_defns) == len( experiments[0]) # Same order - must use appropriate design experiment_number = 0 run_number = 0 with open("results.csv", "w") as f: for experiment in experiments: factors = { k: factor_defns[k][v] for k, v in zip(sorted(factor_defns.keys()), experiment) } for environment_specification in get_environment_specification(): environments = generate_environment(environment_specification, factors['BY_LINEAGE']) write_environment(run_number, environments) for repeat in range(0, N_REPEATS): print("{0}/{1}".format( run_number + 1, N_REPEATS * N_ENVIRONMENTS * len(experiments))) results = model.run( factors=factors, population=init_population(POPULATION_SIZE), generations=GENERATIONS, population_limit=10, environment=environments) if run_number == 0: f.write( format_results_header( construct_line(run_number, experiment_number, environment_specification, results[0], factors)) + "\n") f.write("\n".join([ format_results_line( construct_line(run_number, experiment_number, environment_specification, result, factors)) for result in results ])) f.write("\n") run_number += 1 experiment_number += 1
def __init__(self, start, n, runs): # compute initial value self.path = [] self.cost = [] val = [ model.run(start[0], start[1])['total_cost'] for j in range(runs) ] best = np.mean(val) self.path = start self.cost.append(best) # complete n steps search for i in range(1, n): next = self.neighbor(start) val = [ model.run(next[0], next[1])['total_cost'] for j in range(runs) ] val = np.mean(val) # only select neighbor if solution improves if val < best: best = val self.path = np.vstack([self.path, next]) self.cost.append(val) start = next
def post(self): try: formData = request.json formData = pd.json_normalize(formData) model.addData(formData) response = jsonify({ "statusCode": 200, "status": "Prediction made", "result": model.run() }) response.headers.add('Access-Control-Allow-Origin', '*') return response except Exception as error: return jsonify({ "statusCode": 500, "status": "Could not make prediction", "error": str(error) })
def main(targets): if 'clean' in targets: shutil.rmtree('result', ignore_errors=True) if 'test-project' in targets: cfg = load_params(TEST_PROJECT_PARAMS) print("Running small set of testing data") try: [_ for _ in run(**cfg)] print("Result saved to result folder") except: print('Unknown eror expected. This should not happen') if 'test-data' in targets: cfg = load_params(TEST_DATA_PARAMS) try: [_ for _ in download_apks(**cfg)] except: print('Unknown eror expected. This should not happen') finally: print(cfg["download_amount"] * len(cfg["catagory"]), 'apps downloaded, decomplied and ingested to ', cfg['apk_path']) print('Finished Data ingestion') if 'train-data' in targets: cfg = load_params(TRAIN_DATA_PARAMS) try: [_ for _ in download_apks(**cfg)] except TypeError: print('With Type Error. But it does not affect the process') except: print('Unknown eror expected. This should not happen') finally: print(cfg["download_amount"] * len(cfg["catagory"]), 'apps downloaded ingested to ', cfg['apk_path']) print('Finished Data ingestion') if 'process' in targets: print('Converting apk to smali') subprocess.check_output(["./temp.sh", 'data']) print('Finished converting apk to smali')
def Run(self, request, context): # Run detection buff = BytesIO(request.input) img = Image.open(buff) result = model.run(img) # Send response num_detections = result['num_detections'] resp = bytes2boxes_pb2.Bytes2BoxesReply() for i in range(num_detections): detect = resp.detections.add() detected_class = result['detection_classes'][i] detect.category = model.category_index[detected_class]['name'] detect.score = result['detection_scores'][i] detected_box = result['detection_boxes'][i] detect.x = detected_box[1] detect.y = detected_box[0] detect.width = detected_box[3] - detect.x detect.height = detected_box[2] - detect.y return resp
def main(parameters_file=None): """Produce data""" param = parameters.load(parameters_file) if param.running_mode == 'unique': seed = np.random.randint(2**32) bkp = model.run((seed, param)) file_name = bkp.save() print("Data have been saved using file name: '{}'.".format(file_name)) try: analysis.separate.pos_firmA_over_pos_firmB(file_name) except _tkinter.TclError: print("Figures can not be produced if there is no graphic server.") else: print('Parameters are: ', param.dict()) pool = mlt.Pool() backups = [] seeds = np.random.randint(2**32, size=param.n_simulations) for bkp in tqdm.tqdm(pool.imap_unordered( model.run, zip(seeds, (param, ) * param.n_simulations)), total=param.n_simulations): backups.append(bkp) pool_backup = backup.PoolBackup(parameters=param, backups=backups) file_name = pool_backup.save() print("Data have been saved using file name: '{}'.".format(file_name)) try: analysis.pool.distance_over_fov(file_name=file_name) except _tkinter.TclError: print("Figures can not be produced if there is no graphic server.")
def Run(self, request, context): """Runs the detection and returns a Image2FacesReply.""" # Run detection. buff = BytesIO(request.input) img = Image.open(buff) if img.mode != 'RGB': img = img.convert('RGB') img_array = np.array(img, np.uint8) result = model.run(img_array) print('found %s faces' % len(result)) # Build Response proto. resp = image2faces_pb2.Image2FacesReply() for f in result: x1, y1, x2, y2, features = f face = resp.faces.add() face.x1 = x1 face.y1 = y1 face.x2 = x2 face.y2 = y2 face.facenet = base64.b64encode(features).decode('utf-8') # face.facenet.extend(facenet) # Send Response. return resp
def slim_run(objective, querry, *file_path, Relax=False, Limit=None, New_Pamar=None, New_Setting=None): """ Minimalistic run function, solve the model with given inputs and returns a name-value dictionnary for each item in the querry list Saves all results in a hdf5 file to the specified path. """ # Solve the model m = model.run(objective, Limit=Limit, Relax=Relax, New_Pamar=New_Pamar, New_Setting=New_Setting) # Querry variable values Querried_results = {} for q in querry: Querried_results[q] = m.getVarByName(q).x if file_path: # Save results to path var_results, var_meta = results.get_all(m, 1e-6, Days, Hours, Periods) results.save_df_to_hdf5(var_results, var_meta, file_path[0], Days, Hours, Periods) # file_name = 'run_info.txt' # with open(os.path.join(file_path[0], file_name), 'w') as f: # for v in m.getVars(): # if v.x > 2000: # print('Warning high variable value', file=f) # print('{}: {:.0f}'.format(v.VarName, v.x), file=f) return m, Querried_results
def Run(self, request, context): # Run detection buff = BytesIO(request.image) img = Image.open(buff) img_arr = np.array(img) img_arr_format = img_arr[:, :, ::-1].copy() results = model.run(img_arr_format) # Send response resp = image2pose_pb2.Image2PoseReply() image_w, image_h = img.size centers = {} for human in results: pose = resp.result.poses.add() pose.id = -1 pose.type = pose_pb2.POSE_TYPE_OPENPOSE_FULL for i in range(model.NUM_JOINTS): pt = pose.points.add() if i not in human.body_parts.keys(): continue pt.x = human.body_parts[i].x pt.y = human.body_parts[i].y return resp
action='store', type=int, dest='latent_factors', default=10, help='Define number of latent_factors') parser.add_argument('-method', action='store', type=str, dest='method', default='als', help='The method in which to solve train the model') parser.add_argument('-to', dest='to', nargs='+', default=['*****@*****.**'], help='Mail address') parser.add_argument('-path', dest='path', type=str, default='./', help='The path to the dataset directory') return parser.parse_args() if __name__ == "__main__": conf = get_config(init()) # countdown(100, conf) model.run(conf)
import model import difference_schme print 'RUN!' model.run() difference_schme.run()
def run(): model.load(args.model_path, args.checkpoint_path) rgb = misc.imread(args.input) print(rgb) result = model.run(rgb) misc.imsave('model_test_result.png', result)
from model import run, run2, run3 run('train.csv', 'test.csv', 'out4.csv')
# from hyperopt import fmin, tpe, hp # space = [hp.quniform('lr', 0.00001, 1, 0.00001), # hp.quniform('bs', 100, 10000, 100), # hp.quniform('fhl', 10, 200, 10), # hp.quniform('shl', 10, 200, 10)] numpy.set_printoptions(threshold='nan') numpy.set_printoptions(precision=2) transform.transform_data ("/home/bogdan/work/repos/ml-tloe/serps/results/*", 'expanded', 10000) data = load.read_data_sets ('expanded/*',0.3,0.1, num = 00000); model.create ( H1=1, H2=50 ) # model.train (data, learning_rate=0.001, batch_size=100000, lmbda=0, ermul=10000, restore=False) model.run(data) ################################################################################ # def cost ((lr, bs, fhl, shl)): # return model.train_once (data, lr, int(bs), 0, int(fhl), int(shl), 31, 1) #(data, 0.003, 5000, 0, 150, 50, 31, 1) # best = fmin(cost, # space, # algo=tpe.suggest, # max_evals=1000) # print best
#!/usr/bin/env python # coding: utf-8 import tensorflow as tf import os import image import model import ssl content_path = 'james.jpg' style_paths = ['Vincent_van_Gogh_69.jpg', 'Vincent_van_Gogh_604.jpg'] #image.py用的github上的原码,我过几天再更新一版 if __name__ == "__main__": best, best_loss = model.run(content_path, style_paths, iteration=200) image.saveimg(best, 'best.jpg')
def on_button_pressed_run(): print(len(image_filenames)) # Fatal user mistakes (the filter won't run without these) if not image_filenames: view.messagebox.showwarning( title="Missing Images", message= "Before running the filter, please click \"Load Images\" and select the images on which to run the filter" ) return if not heatmap_filenames: view.messagebox.showwarning( title="Missing Heatmaps", message= "Before running the filter, please click \"Load Heatmaps\" and select the heatmaps on which to run the filter" ) return if len(image_filenames) < len(heatmap_filenames): view.messagebox.showwarning( title="Input Mismatch: Too Many Heatmaps; Not Enough Images", message= f"You've selected {len(image_filenames)} image(s) and {len(heatmap_filenames)} heatmap(s). There should be exactly one heatmap per image. \nPlease check that you have selected all of the files that you need." ) return if len(image_filenames) > len(heatmap_filenames): view.messagebox.showwarning( title="Input Mismatch: Too Many Images; Not Enough Heatmaps", message= f"You've selected {len(image_filenames)} image(s) and {len(heatmap_filenames)} heatmap(s). There should be exactly one heatmap per image. \nPlease check that you have selected all of the files that you need." ) return if not save_directory: view.messagebox.showwarning( title="Missing Save Location", message= "Before running the filter, please click \"Choose Save Location\" and select a folder for the newly generated images to be saved to." ) return # Possible user mistakes (the user may have made a mistake, or may be intending this behavior) if not active_filters: is_ok = view.messagebox.askokcancel( title="No Filters Were Selected", message= "No Filters Were Selected. The generated images will be the same as the input images.\nIf this is intentional, please press \"ok\" to continue." ) if not is_ok: return # Finally, run the filter on all of the files view.change_state("disabled") for i in range(len(image_filenames)): model.run(image_filenames[i], heatmap_filenames[i], active_filters) filename_without_path = split(image_filenames[i])[1] path = save_directory + "/" + filename_without_path cv2.imwrite(filename=path, img=model.get_output_image()) # # display # imshow("filtered", model.get_output_image()) # waitKey(0) # wait for user input to show next image count = len(image_filenames) view.messagebox.showinfo( title="Filter complete!", message=str(count) + (" images have " if count != 1 else " image has ") + "been generated and saved to the folder:\n" + save_directory) view.change_state("normal")
if not args.scan_path: if cfg.scan_path: args.scan_path = cfg.scan_path else: print( 'Path of folder to scan is not set.', '\nProvide path by running "run.py -s path" or put it into reminder.cfg "scan_path".' ) exit(1) if not os.path.exists(args.scan_path): print('Can\'t find folder or file at provided path.') exit(1) if args.log_level: if args.log_level == 1: logging.basicConfig(evel=logging.INFO, format='%(message)s') elif args.log_level > 1: logging.basicConfig( level=logging.DEBUG, format= '%(asctime)s,%(msecs)03d - %(funcName)-18s - %(message)s', datefmt='%X') scheduler = r_scheduler.RScheduler() interface = cli.CliInterface() model.run(args.scan_path, cfg) scheduler.run() interface.run()
import model as model import shutil import os, time dir_to_watch = '/data/vanguard_FAQ/watch_dir/' while True: time.sleep(1) files_list = os.listdir(dir_to_watch) print("polling...") for fl in files_list: if fl.endswith('end'): data_id = fl.split('.')[0] print("training started for id "+data_id) data_file = dir_to_watch+data_id+".data" shutil.copyfile(data_file, '../data/train_data.txt') shutil.copyfile(data_file, '../data/valid_data.txt') shutil.copyfile(data_file, '../data/train2.txt') model.run() os.remove(dir_to_watch+fl) os.remove(data_file)
def run_game(self, u): # TODO: add command line argument to set this seed globally seed = uuid_package.UUID(u).int & 0x7fffffff acts = actions[u] return model.run(seed, *acts)
def run(objective, Reload=False, Relax=False, Pareto=False, Limit=None, Plot=True, Summary=True, Save_txt=False, New_Pamar=None, New_Setting=None): """ Solve the optimization model once then store the result in hdf5 format. # TODO save inputs into the resut folder """ # Option to generate a new input.h5 file if Reload: import write_inputs write_inputs.write_arrays('default', Cluster=True) start_solve = time.time() # Select objective and solve the model m = model.run(objective, Relax=Relax, Limit=Limit, New_Pamar=None, New_Setting=None) end_solve = time.time() print('model solve time: ', end_solve - start_solve, 's') start_write = time.time() # Get results into python dictionnairies Threshold = 1e-6 var_results, var_meta = results.get_all(m, Threshold, Days, Hours, Periods) # Save all results to a hdf5 file file_name = 'results.h5' cd = results.make_path(objective=objective, Limit=Limit, Pareto=Pareto) path = os.path.join(cd, file_name) results.save_df_to_hdf5(var_results, var_meta, path, Days, Hours, Periods) # Save a txt file containing variable results close to the model limit if Save_txt: results.save_txt(m, cd) end_write = time.time() print('model write time: ', end_write - start_write, 's') # Plot graphs and save xls files of results start_plot = time.time() if Plot: plot.all_fig(path, save_fig=True) plot.units_and_resources(path, fig_path=None) if Summary: results.summary(path, save=True) end_plot = time.time() # Save info about the run file_name = 'run_info.txt' info = { 0: f'Objective: {objective}', 1: f'Limit: {Limit}', 2: f'Solve Time: {end_solve - start_solve}', 3: f'Write Time: {end_write - start_write}', 4: f'Plot Time: {end_plot - start_plot}' } with open(os.path.join(cd, file_name), 'w') as f: for k in info.keys(): print(info[k], file=f) # for v in m.getVars(): # if v.x > 2000: # print('Warning high variable value', file=f) # print('{}: {:.0f}'.format(v.VarName, v.x), file=f) return path
def run(parameters, multi=True): return model.run(multi=multi, **parameters)
if args.color == 'original': raise AssertionError() if args.mode != 'artist_style': if args.artist == 'artist1': style_path = artist1_style_path elif args.artist == 'artist2': style_path = artist2_style_path elif args.artist == 'artist3': style_path = artist3_style_path best, best_loss = model.run(content_path, style_path, args.algorithm, args.mode, args.color, args.artist, iteration=1000) else: if args.artist == 'artist1': style_path_arr = artist1_style_path_arr elif args.artist == 'artist2': style_path_arr = artist2_style_path_arr elif args.artist == 'artist3': style_path_arr = artist3_style_path_arr best, best_loss = model.run(content_path, style_path_arr, args.algorithm,
if lightOption == 'ACTUAL': globalsr = df['GHI'] #extracts global solar radiation column from Excel Worksheet in W/m^2 srInp = list(globalsr.values) #srInp = np.tile(srInp, 2) else: srInp = 0 if rainOption == 'ACTUAL': rain = df['Rain'] rInp = list(rain.values) else: rInp = 0 #Run model data = model.run(species, sType, capOn, weatherOption, lightOption, rainOption, Duration, tempInp, qaInp, srInp, rInp, s0) #Save data data.to_pickle(resultsFile.get()) #Display output graphically timestepM = 30 startDay = 0 endDay = Duration dispDuration = endDay - startDay daySteps = 60 / timestepM * 24 timevec = np.linspace(0, Duration, Duration * daySteps) timevecHr = np.linspace(0, Duration * 24, Duration * daySteps) # anp = plt.figure() # plt.title("Carbon assimilation")
def run_game(self, u): seed = seeds[u] acts = actions[u] return model.run(seed, *acts)