def main(): parser = argparse.ArgumentParser() parser.add_argument("-fit", nargs='?', default=False) parser.add_argument("-model", nargs='?', default="simple_model") parser.add_argument("-visualize", nargs='?', default=False) parser.add_argument("-evaluate", nargs='?') parser.add_argument("-dataset") parser.add_argument("-model_path", nargs='?') parser.add_argument("-visualize_heatmap", nargs='?') args = parser.parse_args() if args.dataset: if args.dataset == 'fashion_mnist': train_loader, test_loader = fashion_mnist_dataset.get_data_loaders( ) visualize = fashion_mnist_dataset.visualize_dataset elif args.dataset == "dogs_cats": train_loader, test_loader = dogs_cats_dataset.get_data_loaders() visualize = dogs_cats_dataset.visualize_dataset if args.model: if args.model == 'simple_model': model = SimpleModel() if args.model == 'explain_model': model = ExplainModel() if args.fit: fit_classifier(model, train_loader, test_loader, args.model) elif args.visualize: visualize(train_loader) elif args.evaluate and args.model_path: model = load_model(model_path) evaluate(model, test_loader) elif args.visualize_heatmap and args.model_path: load_visualize_heatmap(args.model_path, test_loader)
def _evaluate_parameters(self, arguments_scheme, context, this, *args): arg_names = list(arguments_scheme.keys()) parameter_values = {} i = 0 for arg in args: value = helpers.evaluate(arg, context) if isinstance(value, types.TupleType) and len(value) == 2 and \ isinstance(value[0], types.StringTypes): name = value[0] value = value[1] if name not in arguments_scheme: raise TypeError() else: if i >= len(arg_names): raise TypeError() name = arg_names[i] i += 1 if callable(value): value = value() arg_spec = arguments_scheme[name] parameter_values[name] = arg_spec.validate( value, this, self._root_context, self._object_store) for name, arg_spec in arguments_scheme.iteritems(): if name not in parameter_values: if not arg_spec.has_default: raise TypeError() parameter_values[name] = arg_spec.validate( helpers.evaluate(arg_spec.default, context), this, self._root_context, self._object_store) return parameter_values
def fit( self, X_train, Y_train, X_val, Y_val, n_epoch=10, n_batch=100, logname='run', ): """Train the model""" alpha = 1.0 # learning rate, which can be adjusted later n_data = len(X_train) n_superbatch = self.n_superbatch for epoch in range(n_epoch): # In each epoch, we do a full pass over the training data: train_batches, train_err, train_acc = 0, 0, 0 start_time = time.time() # iterate over superbatches to save time on GPU memory transfer for X_sb, Y_sb in self.iterate_superbatches( X_train, Y_train, n_superbatch, datatype='train', shuffle=True, ): for idx1, idx2 in iterate_minibatch_idx(len(X_sb), n_batch): err, acc = self.train(idx1, idx2, alpha) # collect metrics train_batches += 1 train_err += err train_acc += acc if train_batches % 100 == 0: n_total = epoch * n_data + n_batch * train_batches metrics = [ n_total, train_err / train_batches, train_acc / train_batches, ] log_metrics(logname, metrics) print "Epoch {} of {} took {:.3f}s ({} minibatches)".format( epoch + 1, n_epoch, time.time() - start_time, train_batches) # make a full pass over the training data and record metrics: train_err, train_acc = evaluate( self.loss, X_train, Y_train, batchsize=100, ) val_err, val_acc = evaluate( self.loss, X_val, Y_val, batchsize=100, ) print " training:\t\t{:.6f}\t{:.6f}".format( train_err, train_acc ) print " validation:\t\t{:.6f}\t{:.6f}".format( val_err, val_acc ) metrics = [epoch, train_err, train_acc, val_err, val_acc] log_metrics(logname + '.val', metrics)
def home_modal(): if request.method == 'POST': data = request.form['url'] title, score = helpers.evaluate(data, weights) print(title, score) return render_template("home_modal.html", title = title, url = data, score = score) return render_template("home_modal.html", title = "", url = "", score = 0)
def __inner_evaluate_model(self, predictions_dict): if self.truth_dictionary is None: print("[ERROR] No ground truth dictionary defined") sys.exit() rmse_list = [] for i in predictions_dict.keys(): pred = predictions_dict[i] truth = self.truth_dictionary[i] rmse = evaluate(pred, truth) rmse_list.append(rmse) return np.mean(rmse_list)
def jinni_findSuggestionsWithFilters(query): logging.info(u'Doing a suggestion search for "{0}"...'.format(query)) url = "http://www.jinni.com/dwr/call/plaincall/AjaxController.findSuggestionsWithFilters.dwr" values = { # Both the httpSessionId and scriptSessionId need to be submitted # or the server will respond with a "HTTP Error 501: Not Implemented". # However, they are not validated. # FIXME: when logged in for some reason you do need to send along a valid httpSessionId "httpSessionId": [cookie.value for cookie in cj if cookie.name == "JSESSIONID"][0], "scriptSessionId": "", # i.e. 3C675DDBB02222BE8CB51E2415259E99878 "callCount": "1", "page": "/discovery.html", "c0-scriptName": "AjaxController", "c0-methodName": "findSuggestionsWithFilters", "c0-id": "0", "c0-param0": "string:{0}".format(query.encode("utf-8")), "c0-e1": "null:null", "c0-e2": "boolean:false", "c0-e3": "boolean:false", "c0-e4": "boolean:false", "c0-e5": "Array:[]", "c0-param1": "Object_Object:{contentTypeFilter:reference:c0-e1, onlineContentFilter:reference:c0-e2, dvdContentFilter:reference:c0-e3, theaterContentFilter:reference:c0-e4, contentAffiliates:reference:c0-e5}", "batchId": "2" } data = urllib.urlencode(values) request = urllib2.Request(url, data) response = open_url(request) content = response.read() js_tree = parse_js(content) tree = convert(js_tree) evaluate(js_tree, tree) results = tree["s1"] return results
def start(self) -> None: ties = 0 p1 = 0 p2 = 0 for i in range(self.iterations): player1_move = self.player1.move() player2_move = self.player2.move() result = evaluate(player1_move, player2_move) if result == 0: ties += 1 elif result == 1: p1 += 1 else: p2 += 1 self.player1.train(player2_move, player1_move, result) self.player2.train(player1_move, player2_move, result) # print('Player1: %s, Player2: %s, %s' % (player1_move, player2_move, r_str)) print('Player1: %d, Player2: %d, Ties: %d' % (p1, p2, ties))
def __set_property(self, key, value, caller_class=None): if key in self.__type.properties: spec = self.__type.get_property(key) if caller_class is not None and ( spec.type not in typespec.PropertyTypes.Writable or not caller_class.is_compatible(self)): raise exceptions.NoWriteAccess(key) default = self.__defaults.get(key, spec.default) child_context = Context(parent_context=self.__context) child_context.set_data(self) default = helpers.evaluate(default, child_context, 1) self.__properties[key] = spec.validate( value, self, self.__context, self.__object_store, default) else: for parent in self.__parents.values(): try: parent.__set_property(key, value, caller_class) return except AttributeError: continue raise AttributeError(key)
total += nn print('Number of parameters:', total) # print example predictions and ground truths print('Printing 8 random frame truths, predictions and output vectors...') test_dl = DataLoader(testset, batch_size=8, shuffle=True) dataiter = iter(test_dl) image, label = dataiter.next() #output = model(image) #_, prediction = torch.max(output, 1) #_, label = torch.max(label, 1) #for t, p, o in zip(label, prediction, output): # print('Truth: ' + truth_table[t] + '; prediction: ' + truth_table[p]) # print('Output: ', o) print('\nValidating over the entire set...', flush=True) acc, confusion_matrix = helpers.evaluate(testset, model, truth_table, device=device, verbose=True) print('Frame accuracy: ' + str(acc) + '\n') # If specified, add the suffix to the savepath if suffix is not None: savepath = savepath[:-4] + '_' + suffix + '.png' helpers.print_confusion_matrix(confusion_matrix, truth_table, savepath) print('All done. Time:', helpers.time_since(start)) print('\n\n\n')
def fit( self, X_train, Y_train, X_val, Y_val, n_epoch=10, n_batch=100, logname='run', ): """Train the model""" alpha = 1.0 # learning rate, which can be adjusted later n_data = len(X_train) n_superbatch = self.n_superbatch # print '...', self.rbm.logZ_exact() # print '...', self.rbm.logZ_exact(marg='h') for epoch in range(n_epoch): # In each epoch, we do a full pass over the training data: train_batches, train_err, train_acc = 0, 0, 0 start_time = time.time() # iterate over superbatches to save time on GPU memory transfer for X_sb, Y_sb in self.iterate_superbatches( X_train, Y_train, n_superbatch, datatype='train', shuffle=True, ): for idx1, idx2 in iterate_minibatch_idx(len(X_sb), n_batch): # train model self.rbm.reset_averages() err, acc, z = self.train(idx1, idx2, alpha) # train rbm z_rbm = z.reshape((128,1,8,8)) # self.rbm.train_batch(z.reshape((128,1,8,8)), np.zeros((n_batch,), dtype='int32'), alpha) # q steps for i in range(2): self.rbm.train_q0(z_rbm) # p steps self.rbm.train_p_batch(z_rbm, alpha) # collect metrics # print err, acc train_batches += 1 train_err += err train_acc += acc if train_batches % 100 == 0: n_total = epoch * n_data + n_batch * train_batches metrics = [ n_total, train_err / train_batches, train_acc / train_batches, ] log_metrics(logname, metrics) print "Epoch {} of {} took {:.3f}s ({} minibatches)".format( epoch + 1, n_epoch, time.time() - start_time, train_batches) # make a full pass over the training data and record metrics: train_err, train_acc = evaluate( self.loss, X_train, Y_train, batchsize=128, ) val_err, val_acc = evaluate( self.loss, X_val, Y_val, batchsize=128, ) print " training:\t\t{:.6f}\t{:.6f}".format( train_err, train_acc ) print " validation:\t\t{:.6f}\t{:.6f}".format( val_err, val_acc ) metrics = [epoch, train_err, train_acc, val_err, val_acc] log_metrics(logname + '.val', metrics) # reserve N of training data points to kick start hallucinations self.rbm.hallu_set = np.asarray( z[:100,:].reshape((100,1,8,8)), dtype=theano.config.floatX )
def execute(self, context, object_store, murano_class): raise exceptions.ReturnException( helpers.evaluate(self._value, context))
def heatmap(): clicked_strike = request.form.get("strike") bundles = request.form.get("bundles") targetmargin = request.form.get("targetmargin") minpayout = request.form.get("minpayout") maxpayout = request.form.get("maxpayout") kgperperson = int(request.form.get("kgperperson")) interest = float(request.form.get("interest")) deposit = float(request.form.get("deposit")) # region = request.form.get("region") res = db.execute( f"""SELECT strike, payouts, premiums FROM policies WHERE strike={clicked_strike} AND minpayout={minpayout} AND maxpayout={maxpayout} AND bundles={bundles} AND targetmargin={targetmargin} ORDER BY strike""" ).fetchone() payouts = pd.DataFrame(res.payouts).transpose() payouts.index = [int(x) for x in payouts.index] payouts = payouts.sort_index() premiums = pd.DataFrame(res.premiums).transpose() premiums.index = [int(x) for x in premiums.index] premiums = premiums.sort_index() # Calculate critical critloss DF and total_thresh crit_thresh_df = helpers.calc_crit(data, indexyields, loandeposit=deposit, loaninterest=interest, kg_per_mouth=kgperperson) cl_noins, cl_ins, clsr, clcr, clfr, rmsr, premsaspc, realisedmargin = helpers.evaluate( realyields, crit_thresh_df, payouts, premiums, data['farmarea'], startyear=startyear) # min_cl = cl_noins.min().min() payouts = payouts.loc[:, startyear:].sort_index(ascending=False) premiums = premiums.loc[:, startyear:].sort_index(ascending=False) crit_thresh_df = crit_thresh_df.loc[:, startyear:].sort_index(ascending=False) cl_ins = cl_ins.sort_index(ascending=False) cl_noins = cl_noins.sort_index(ascending=False) indexyieldstosend = indexyields.loc[:, startyear:].sort_index(ascending=False) realyieldstosend = realyields.loc[:, startyear:].sort_index(ascending=False) # if region != "All": # cl_noins = cl_noins[:][data['group'] == region] # cl_ins = cl_ins[:][data['group'] == region] # indexyieldstosend = indexyieldstosend[:][data['group'] == region] # regions = [region] * cl_ins.shape[0] # else: regions = data['group'].sort_index(ascending=False).tolist() improvement = (cl_ins - cl_noins) sitenames = [f"Farm {x}" for x in indexyieldstosend.index] heatmapdata = { "payouts": payouts.values.tolist(), "premiums": premiums.values.tolist(), "crit_thresh_df": crit_thresh_df.values.tolist(), "cl_noins": cl_noins.values.tolist(), "cl_ins": cl_ins.values.tolist(), "improvement": improvement.values.tolist(), "columns": cl_ins.columns.tolist(), "sitenames": sitenames, "regions": regions, # "min_cl": min_cl, "indexyields": indexyieldstosend.values.tolist(), "realyields": realyieldstosend.values.tolist() } return jsonify(heatmapdata)
import helpers with open('config.json') as config_file: config = json.load(config_file) firebase = pyrebase.initialize_app(config) db = firebase.database() weights = db.child("sources").get().val() test_news = [ "https://www.nydailynews.com/news/politics/ny-trump-first-pitch-washington-nationals-world-series-20191026-o5rnjkq3trhfnpenpvah4fadtm-story.html?fbclid=IwAR1Bz7xj629rTFw8p5AaKLYSrG6SvLaAZwBNC4vTdMJ0vCyVDzawh7rCnG0", "https://www.mercurynews.com/2019/10/26/pge-shutoffs-grow-nearly-1-million-customers-to-lose-power/", "https://www.aljazeera.com/news/2019/10/russia-decries-decision-secure-oil-fields-eastern-syria-191026183322358.html", "https://www.cnn.com/2019/10/26/politics/company-government-contract-donald-trump-brother-robert-trump/index.html", "https://abcnews.go.com/Politics/state-department-official-expected-part-impeachment-probe/story?id=66532626&cid=clicksource_4380645_null_hero_hed", #"https://www.usnews.com/news/elections/articles/2019-10-25/the-state-of-the-presidential-race-100-days-until-the-iowa-caucus", #"https://www.npr.org/2019/10/26/773706177/pentagon-awards-10-billion-contract-to-microsoft-over-front-runner-amazon", #"https://www.nytimes.com/2019/10/26/us/tennessee-treehouse-fire.html", #"https://www.huffpost.com/entry/al-franken-comeback-politicon_n_5db2300be4b0a89374020d55?guccounter=1&guce_referrer=aHR0cHM6Ly93d3cuaHVmZnBvc3QuY29tL25ld3Mv&guce_referrer_sig=AQAAAK1EbjNMIbjvCJBNwOo5wC5hxouNhFg7KktUGaVrm_Qbkmi3iri2a7zDnQNG0ra9g_nGJ9jLrKljUlj5FqDZ-FL11ENuKe14fDZvkekFXJbeBU7TvwYfeWxNivPrt7wApwGqSTwlOjRmq7s1SQ16mj05pPdVdW7ZJTRQSOKGZ5Gs", "https://fox2now.com/2019/10/26/belleville-apartment-fire-caused-by-unattended-candle/" ] for s in test_news: title, score = helpers.evaluate(s, weights) if title: print("Title: ", title) else: print("Title: Unknown") print(score)
training_operation = optimizer.minimize(loss_operation) # model evaluation correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1)) accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) saver = tf.train.Saver() # training max_accuracy = 0 with tf.Session() as sess: saver.restore(sess, './best_model_save_file') validation_accuracy = helpers.evaluate(X_test, y_test, accuracy_operation, n_test, x, y, keep_prob) print("validation accuracy = {:.3f}".format(validation_accuracy)) # sess.run(tf.global_variables_initializer()) # num_examples = X_train.shape[0] # print("Training with batch size ", BATCH_SIZE) # print() # for i in range(EPOCHS): # X_train, y_train = skl.utils.shuffle(X_train, y_train) # # process each batch # for offset in range(0, num_examples, BATCH_SIZE): # end = offset + BATCH_SIZE # batch_x, batch_y = X_train[offset:end], y_train[offset:end] # _, loss = sess.run([training_operation, loss_operation], feed_dict={
def train(x_train, y_train, x_val, y_val, params): ''' TODO: documentation ''' # Parameters String used for saving the files parameters_str = str('_d' + str(params['do']).replace('.', '') + '_a' + str(params['a']).replace('.', '') + '_k' + str(params['k']).replace('.', '') + '_c' + str(params['cl']).replace('.', '') + '_s' + str(params['s']).replace('.', '') + '_pf' + str(params['pf']).replace('.', '') + '_pt' + params['pt'] + '_fp' + str(params['fp']).replace('.', '') + '_opt' + params['opt'] + '_obj' + params['obj']) # Printing the parameters of the model print('[Dropout Param] \t->\t' + str(params['do'])) print('[Alpha Param] \t\t->\t' + str(params['a'])) print('[Multiplier] \t\t->\t' + str(params['k'])) print('[Patience] \t\t->\t' + str(params['patience'])) print('[Tolerance] \t\t->\t' + str(params['tolerance'])) print('[Input Scale Factor] \t->\t' + str(params['s'])) print('[Pooling Type] \t\t->\t' + params['pt']) print('[Pooling Factor] \t->\t' + str(str(params['pf'] * 100) + '%')) print('[Feature Maps Policy] \t->\t' + params['fp']) print('[Optimizer] \t\t->\t' + params['opt']) print('[Objective] \t\t->\t' + get_Obj(params['obj'])) print('[Results filename] \t->\t' + str(params['res_alias'] + parameters_str + '.txt')) # Rescale Input Images if params['s'] != 1: print('\033[93m' + 'Rescaling Patches...' + '\033[0m') x_train = np.asarray( np.expand_dims([ cv2.resize(x_train[i, 0, :, :], (0, 0), fx=params['s'], fy=params['s']) for i in xrange(x_train.shape[0]) ], 1)) x_val = np.asarray( np.expand_dims([ cv2.resize( x_val[i, 0, :, :], (0, 0), fx=params['s'], fy=params['s']) for i in xrange(x_val.shape[0]) ], 1)) print('\033[92m' + 'Done, Rescaling Patches' + '\033[0m') print('[New Data Shape]\t->\tX: ' + str(x_train.shape)) model = get_model(x_train.shape, y_train.shape, params) # Counters-buffers maxf = 0 maxacc = 0 maxit = 0 maxtrainloss = 0 maxvaloss = np.inf p = 0 it = 0 best_model = model # Open file to write the results open(params['res_alias'] + parameters_str + '.csv', 'a').write('Epoch, Val_fscore, Val_acc, Train_loss, Val_loss\n') open(params['res_alias'] + parameters_str + '-Best.csv', 'a').write('Epoch, Val_fscore, Val_acc, Train_loss, Val_loss\n') while p < params['patience']: p += 1 # Fit the model for one epoch print('Epoch: ' + str(it)) history = model.fit(x_train, y_train, batch_size=128, nb_epoch=1, validation_data=(x_val, y_val), shuffle=True) # Evaluate models y_score = model.predict(x_val, batch_size=1050) fscore, acc, cm = H.evaluate(np.argmax(y_val, axis=1), np.argmax(y_score, axis=1)) print('Val F-score: ' + str(fscore) + '\tVal acc: ' + str(acc)) # Write results in file open(params['res_alias'] + parameters_str + '.csv', 'a').write( str( str(it) + ', ' + str(fscore) + ', ' + str(acc) + ', ' + str(np.max(history.history['loss'])) + ', ' + str(np.max(history.history['val_loss'])) + '\n')) # check if current state of the model is the best and write evaluation metrics to file if fscore > maxf * params[ 'tolerance']: # if fscore > maxf*params['tolerance']: p = 0 # restore patience counter best_model = model # store current model state maxf = fscore maxacc = acc maxit = it maxtrainloss = np.max(history.history['loss']) maxvaloss = np.max(history.history['val_loss']) print(np.round(100 * cm / np.sum(cm, axis=1).astype(float))) open(params['res_alias'] + parameters_str + '-Best.csv', 'a').write( str( str(maxit) + ', ' + str(maxf) + ', ' + str(maxacc) + ', ' + str(maxtrainloss) + ', ' + str(maxvaloss) + '\n')) it += 1 print('Max: fscore:', maxf, 'acc:', maxacc, 'epoch: ', maxit, 'train loss: ', maxtrainloss, 'validation loss: ', maxvaloss) return best_model
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(one_hot_y, 1)) accuracy_operation = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) saver = tf.train.Saver() # training max_accuracy = 0 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) num_examples = X_train.shape[0] print("Training with batch size ", BATCH_SIZE) print() for i in range(EPOCHS): X_train, y_train = skl.utils.shuffle(X_train, y_train) # process each batch for offset in range(0, num_examples, BATCH_SIZE): end = offset + BATCH_SIZE batch_x, batch_y = X_train[offset:end], y_train[offset:end] _, loss = sess.run([training_operation, loss_operation], feed_dict={x: batch_x, y: batch_y, keep_prob: dropout}) # execute session validation_accuracy = helpers.evaluate(X_valid, y_valid, accuracy_operation, BATCH_SIZE, x, y, keep_prob) print("EPOCH {} ...".format(i + 1), " validation accuracy = {:.3f}".format(validation_accuracy)) if validation_accuracy > max_accuracy: # save only highest accuracy we've achieved so far max_accuracy = validation_accuracy saver.save(sess, './best_model_save_file') print("Highest accuracy seen so far. Model saved.") else: print("Not highest accuracy seen so far. Model not saved.") print()
def execute(self, context, murano_class): result = helpers.evaluate(self.expression, context) if self.destination: self.destination(result, context, murano_class) return result
def train(x_train, y_train, x_val, y_val, params): ''' TODO: documentation ''' # Parameters String used for saving the files parameters_str = str('_d' + str(params['do']).replace('.', '') + '_a' + str(params['a']).replace('.', '') + '_k' + str(params['k']).replace('.', '') + '_c' + str(params['cl']).replace('.', '') + '_s' + str(params['s']).replace('.', '') + '_pf' + str(params['pf']).replace('.', '') + '_pt' + params['pt'] + '_fp' + str(params['fp']).replace('.', '') + '_opt' + params['opt'] + '_obj' + params['obj']) # Printing the parameters of the model print('[Dropout Param] \t->\t'+str(params['do'])) print('[Alpha Param] \t\t->\t'+str(params['a'])) print('[Multiplier] \t\t->\t'+str(params['k'])) print('[Patience] \t\t->\t'+str(params['patience'])) print('[Tolerance] \t\t->\t'+str(params['tolerance'])) print('[Input Scale Factor] \t->\t'+str(params['s'])) print('[Pooling Type] \t\t->\t'+ params['pt']) print('[Pooling Factor] \t->\t'+str(str(params['pf']*100)+'%')) print('[Feature Maps Policy] \t->\t'+ params['fp']) print('[Optimizer] \t\t->\t'+ params['opt']) print('[Objective] \t\t->\t'+ get_Obj(params['obj'])) print('[Results filename] \t->\t'+str(params['res_alias']+parameters_str+'.txt')) # Rescale Input Images if params['s'] != 1: print('\033[93m'+'Rescaling Patches...'+'\033[0m') x_train = np.asarray(np.expand_dims([cv2.resize(x_train[i, 0, :, :], (0,0), fx=params['s'], fy=params['s']) for i in xrange(x_train.shape[0])], 1)) x_val = np.asarray(np.expand_dims([cv2.resize(x_val[i, 0, :, :], (0,0), fx=params['s'], fy=params['s']) for i in xrange(x_val.shape[0])], 1)) print('\033[92m'+'Done, Rescaling Patches'+'\033[0m') print('[New Data Shape]\t->\tX: '+str(x_train.shape)) model = get_model(x_train.shape, y_train.shape, params) # Counters-buffers maxf = 0 maxacc = 0 maxit = 0 maxtrainloss = 0 maxvaloss = np.inf p = 0 it = 0 best_model = model # Open file to write the results open(params['res_alias']+parameters_str+'.csv', 'a').write('Epoch, Val_fscore, Val_acc, Train_loss, Val_loss\n') open(params['res_alias']+parameters_str+'-Best.csv', 'a').write('Epoch, Val_fscore, Val_acc, Train_loss, Val_loss\n') while p < params['patience']: p += 1 # Fit the model for one epoch print('Epoch: ' + str(it)) history = model.fit(x_train, y_train, batch_size=128, nb_epoch=1, validation_data=(x_val,y_val), shuffle=True) # Evaluate models y_score = model.predict(x_val, batch_size=1050) fscore, acc, cm = H.evaluate(np.argmax(y_val, axis=1), np.argmax(y_score, axis=1)) print('Val F-score: '+str(fscore)+'\tVal acc: '+str(acc)) # Write results in file open(params['res_alias']+parameters_str+'.csv', 'a').write(str(str(it)+', '+str(fscore)+', '+str(acc)+', '+str(np.max(history.history['loss']))+', '+str(np.max(history.history['val_loss']))+'\n')) # check if current state of the model is the best and write evaluation metrics to file if fscore > maxf*params['tolerance']: # if fscore > maxf*params['tolerance']: p = 0 # restore patience counter best_model = model # store current model state maxf = fscore maxacc = acc maxit = it maxtrainloss = np.max(history.history['loss']) maxvaloss = np.max(history.history['val_loss']) print(np.round(100*cm/np.sum(cm,axis=1).astype(float))) open(params['res_alias']+parameters_str+'-Best.csv', 'a').write(str(str(maxit)+', '+str(maxf)+', '+str(maxacc)+', '+str(maxtrainloss)+', '+str(maxvaloss)+'\n')) it += 1 print('Max: fscore:', maxf, 'acc:', maxacc, 'epoch: ', maxit, 'train loss: ', maxtrainloss, 'validation loss: ', maxvaloss) return best_model
def run_algorithm(self, seed): # Set up custom hall of fame to keep track of the top chromosomes and their generations hall_of_fame = hof.HallOfFame(self.HOF_SIZE) # set up standard hall of fame that comes with DEAP hall_of_fame_with_dupes = tools.HallOfFame(self.HOF_SIZE) # Get date and time date_time = datetime.datetime.now().strftime("%m-%d_%I%M%p") # print out to file file_name = date_time + '.txt' sys.stdout = open(file_name, 'w') print 'Seed:', seed i = 0 while i < self.GENERATIONS and not self.isConverged: i += 1 print('--------------------------------' + 'Generation: ' + str(i) + '-----------------------------------') # evaluate each chromosome in the population and assign its fitness score for index, x in enumerate(self.population): # update the chromosome, write out to JSON tactical file chromosome_parameters.update_chromosome( x[0].value, x[1].value, x[2].value, x[3].value, x[4].value) # use Ace0 to evaluate the chromosome x.fitness.values = helper.evaluate(self.repetitions) # Select the best chromosome from this generation and display it best_chromosome = tools.selBest(self.population, 1)[0] print "Best chromosome is: ", helper.list_to_string( best_chromosome), best_chromosome.fitness.values # Select worst chromosome and display worst_chromosome = tools.selWorst(self.population, 1)[0] print "Worst chromosome is: ", helper.list_to_string( worst_chromosome), worst_chromosome.fitness.values # Get the over all fitness values sum_fits = sum(ind.fitness.values[0] for ind in self.population) average_fitness = sum_fits / self.POP print 'Generation average fitness: ', average_fitness # save best and average fitness to plot lists self.plot_best_fitness.append(best_chromosome.fitness.values) self.plot_average_fitness.append(average_fitness) self.plot_worst_fitness.append(worst_chromosome.fitness.values) # Update the hall of fame to track the best chromosomes from each generation hall_of_fame.update(self.population, i) hall_of_fame_with_dupes.update(self.population) # hall_of_fame.print_hof() # this is where we evolve the population # Select the next generation individuals offspring = self.toolbox.select(self.population, len(self.population)) # Clone the selected individuals so we can apply crossover offspring = list(map(self.toolbox.clone, offspring)) # Apply crossover on the offspring for child1, child2 in zip(offspring[::2], offspring[::-2]): if random.random() < self.CROSSOVER_PROBABILITY: # mate the two children self.toolbox.mate(child1, child2) # Apply mutation on the offspring for mutant in offspring: if random.random() < self.MUTATION_PROBABILITY: # print 'Mutated Chromosome before: ', helper.list_to_string(mutant) for index, x in enumerate(mutant): mutant[index].value = helper.convert_range( mutant[index].value, mutant[index].min, mutant[index].max) self.toolbox.mutate(mutant) for index, x in enumerate(mutant): mutant[index].value = helper.change_back( mutant[index].value, mutant[index].min, mutant[index].max) helper.bounds_check(mutant[index]) # print 'Mutated Chromosome after: ', helper.list_to_string(mutant) # The population is entirely replaced by the offspring self.population[:] = offspring if float(best_chromosome.fitness.values[0] ) - average_fitness < 0.0001: self.converge_tracker += 1 if self.converge_tracker >= self.converge_tracker_max: print 'CONVERGED' self.isConverged = True else: self.converge_tracker = 0 # # Elitism self.population[0] = hall_of_fame_with_dupes[0] print( '-------------------------------------Hall Of Fame Regular----------------------------------------' ) for chromosomes in hall_of_fame_with_dupes: print 'Chromosome: ', helper.list_to_string( chromosomes), 'Fitness: ', chromosomes.fitness print( '-------------------------------------Hall Of Fame with Gen----------------------------------------' ) hall_of_fame.print_hof() print( '-------------------------------------Stats----------------------------------------' ) print("Pop size: " + str(self.POP)) print("Generations: " + str(self.GENERATIONS)) print("Crossover Prob: " + str(self.CROSSOVER_PROBABILITY)) print("Mutation Prob: " + str(self.MUTATION_PROBABILITY)) # Select the best chromosome from this generation and display it best_chromosome = tools.selBest(self.population, 1)[0] print "Best chromosome is: ", helper.list_to_string( best_chromosome), best_chromosome.fitness.values # Select worst chromosome and display worst_chromosome = tools.selWorst(self.population, 1)[0] print "Worst chromosome is: ", helper.list_to_string( worst_chromosome), worst_chromosome.fitness.values # Get the over all fitness values sum_fits = sum(ind.fitness.values[0] for ind in self.population) average_fitness = sum_fits / self.POP print 'Generation average fitness: ', average_fitness title = 'Seed: ' + str(seed) visualization.draw_plot(title, self.plot_average_fitness, self.plot_best_fitness, self.plot_worst_fitness, 'average per generation', 'best fitness', 'worst fitness', 'generation', 'fitness', 1, 250, 150, date_time) del creator.fitness del creator.Tactic
def updategraphs(): # Query for form data bundles = request.form.get("bundles") targetmargin = request.form.get("targetmargin") minpayout = request.form.get("minpayout") maxpayout = request.form.get("maxpayout") kgperperson = int(request.form.get("kgperperson")) interest = float(request.form.get("interest")) deposit = float(request.form.get("deposit")) strikes = np.linspace(0, 6000, 13) policyid_list = [] payouts_list = [] premiums_list = [] crit_thresh_list = [] clsr_list = [] premsaspc_list = [] realisedmargin_list = [] for strike in strikes: strike = int(strike) # Access pre-calculated payout and premium data from the database # (calculation of these values is too computationally intensive to run in the app) res = db.execute( f"""SELECT policyid, strike, payouts, premiums FROM policies WHERE strike={strike} AND minpayout={minpayout} AND maxpayout={maxpayout} AND bundles={bundles} AND targetmargin={targetmargin} ORDER BY strike""" ).fetchone() policyid_list.append(res.policyid) payouts = pd.DataFrame(res.payouts).transpose() payouts.index = [int(x) for x in payouts.index] payouts = payouts.sort_index() premiums = pd.DataFrame(res.premiums).transpose() premiums.index = [int(x) for x in premiums.index] premiums = premiums.sort_index() # Calculate critical critloss DF and total_thresh crit_thresh_df = helpers.calc_crit(data, indexyields, loandeposit=deposit, loaninterest=interest, kg_per_mouth=kgperperson) cl_noins, cl_ins, clsr, clcr, clfr, rmsr, premsaspc, realisedmargin = helpers.evaluate( realyields, crit_thresh_df, payouts, premiums, data['farmarea'], startyear=startyear) clsr_list.append(clsr) premsaspc_list.append(premsaspc) realisedmargin_list.append(realisedmargin) datadict = { "strikes": strikes.tolist(), "clsr_list": clsr_list, "premsaspc_list": premsaspc_list, "policyid_list": policyid_list, "realised_margin": realisedmargin_list } return jsonify(datadict)
def main(): # Import data from csv data = pd.read_csv('data/data123.csv', header=0, index_col='siteid') # Pull out index yields and real yields into their own dataframes indcols = [] realcols = [] for col in data.columns: if col[:5] == "index": indcols.append(col) elif col[:4] == 'real': realcols.append(col) indexyields = data[indcols] realyields = data[realcols] # Create array of years and relabel the columns of indexyields and realyields years = [x[-4:] for x in indexyields.columns] indexyields.columns = years realyields.columns = years # -------------------------- # Analyse combinations of insurance parameters at default crit loss # parameters and write results to the POLICIES table of the database # strike = 4000 # bundle = 2 maxpayout = 999999 # targetmargin = 0.25 strikes = np.linspace(0, 6000, 13) bundles = [0, 1, 2, 3] minpayouts = [0, 500, 1000, 2000] targetmargins = [0, 0.1, 0.2, 0.3, 0.4, 0.5] loandeposits = [0, 0.5] # [0, 0.2, 0.5, 1.0] loaninterests = [0.1, 0.2] # [0.1, 0.2, 0.3] kg_per_mouths = [90, 180] # [90, 180, 360] combinations = (len(strikes) * len(bundles) * len(minpayouts) * len(targetmargins)) counter = 1 for strike in strikes: for bundle in bundles: for minpayout in minpayouts: for targetmargin in targetmargins: payouts, premiums = helpers.calc_payouts_premiums( indexyields, strikelevel=strike, bundles=bundle, minpayout=minpayout, maxpayout=maxpayout, targetmargin=targetmargin) crit_thresh_df = helpers.calc_crit(data, indexyields, loandeposit=0.20, loaninterest=0.19, kg_per_mouth=180) cl_noins, cl_ins, clsr, clcr, clfr, premsaspc, realisedmargin = helpers.evaluate( realyields, crit_thresh_df, payouts, premiums, data['farmarea'], startyear='1990') payouts_json = payouts.to_json(orient='index') premiums_json = premiums.to_json(orient='index') db.execute( """INSERT INTO policies(strike, bundles, minpayout, maxpayout, targetmargin, realisedmargin, clsr, clcr, clfr, premsaspc, payouts, premiums) VALUES (:strike, :bundle, :minpayout, :maxpayout, :targetmargin, :realisedmargin, :clsr, :clcr, :clfr, :premsaspc, :payouts, :premiums);""", { "strike": strike, "bundle": bundle, "minpayout": minpayout, "maxpayout": maxpayout, "targetmargin": targetmargin, "realisedmargin": realisedmargin, "clsr": clsr, "clcr": clcr, "clfr": clfr, "premsaspc": premsaspc, "payouts": payouts_json, "premiums": premiums_json }) print(f"Added {counter} of {combinations}") counter += 1 # Isolate dat for FARMS table for ind, row in data.iterrows(): siteid = ind farmarea = row['farmarea'] hhsize = row['householdsize'] region = row['group'] indexyield = indexyields.iloc[ind, :].to_json() realyield = indexyields.iloc[ind, :].to_json() # Write data to FARMS table db.execute( """INSERT INTO farms (siteid, farmarea, hhsize, region, indexyields, realyields) VALUES (:siteid, :farmarea, :hhsize, :region, :indexyield, :realyield);""", { 'siteid': siteid, 'farmarea': farmarea, 'hhsize': hhsize, 'region': region, 'indexyield': indexyield, 'realyield': realyield }) db.commit()