def predictor(): # Get predictions from model model() # Empty rankings dictionary to pass to html file the_rankings = [] with open('predictions.csv') as predictions: rankings = csv.reader(predictions) for row in rankings: the_rankings.append(row) # Get length of "the_rankings" to pass to html file for loop length = len(the_rankings) # Possible words to choose from to make website a little more interactive intro = [ "Currently", "At this point", "At present", "Right now", "For now", "As of now", "Well" ] intro_next = [ "it seems like", "it seems as though", "it looks like", "chances are that" ] intro_for_predictor = random.choice(intro) intro_next_for_predictor = random.choice(intro_next) team1 = the_rankings[1][1] team2 = the_rankings[2][1] team3 = the_rankings[3][1] team4 = the_rankings[4][1] team5 = the_rankings[5][1] team6 = the_rankings[6][1] team3rdlast = the_rankings[-3][1] team2ndlast = the_rankings[-2][1] teamlast = the_rankings[-1][1] return render_template("predictor.html", the_rankings=the_rankings, length=length, intro_for_predictor=intro_for_predictor, intro_next_for_predictor=intro_next_for_predictor, team1=team1, team2=team2, team3=team3, team4=team4, team5=team5, team6=team6, team3rdlast=team3rdlast, team2ndlast=team2ndlast, teamlast=teamlast)
def __init__(self,data,variance_threshold = 1e3,alpha = 1e-2,max_source = 10,epochs = 500,\ center_movement_allow = 0.1,scale = 20,center_num = 1,method = 'Okumura_Hata',sample_num = None): ''' alpha: 更新的缩放系数,类似于学习率 max_source:发射源的最大数量,分裂出的中心数量不能超过该数值 epochs:查找发射源时的迭代次数 center_movement_allow(km):中心点移动距离的最小许用值,小于此值认为找到发射源,结束迭代 scale: 可视化散点图中点的缩小倍数 methods:使用的模型,可选'free' 或 'Okumura_Hata' 或 'Egli' sample_num:监测点数量,默认根据data自动计算 ''' self.__alpha = alpha #更新的缩放系数,类似于学习率 self.__max_source = max_source #发射源的最大数量 self.__epochs = epochs #迭代次数 self.__center_movement_allow = center_movement_allow#中心点移动距离小于此值认为找到发射源,结束迭代 self.__scale = scale #可视化散点图中点的缩小倍数 self.__method = method #使用的模型,可选'free' 或 'Okumura_Hata' 或 'Egli' self.__variance_threshold = variance_threshold #增加中心点的方差阈值 self.__centers_num = center_num#中心点初始数量 if not sample_num == None: self.point_num = sample_num #样本(监测点)数量 简记为n self.data = self.__init_data(data,sample_nums=sample_num) self.centers = self.__init_center(self.data) #(1,2)-->(m,2) self.__model = model(launch_frequency = self.data[0,2]) #假设所有点频率相同 self.center_power = [] self.__point_power_predict = [] self.loss = []
def train(train_dir, test_dir): data_generator = ImageDataGenerator(rescale=1.0 / 255.0, zoom_range=0.2) batch_size = 32 training_data = data_generator.flow_from_directory(directory=train_dir, target_size=(64, 64), batch_size=batch_size, class_mode='binary') testing_data = data_generator.flow_from_directory(directory=test_dir, target_size=(64, 64), batch_size=batch_size, class_mode='binary') mode = model(training_data) fitted_model = mode.fit_generator(training_data, steps_per_epoch=1000, epochs=20, validation_data=testing_data, validation_steps=1000) mode.save('final_model.h5')
def create_model(sess, CONFIGS): text_model = model(CONFIGS) checkpt = tf.train.get_checkpoint_state(CONFIGS.ckpt_dir) if checkpt: print("Restoring old model parameters from %s" % checkpt.model_checkpoint_path) text_model.saver.restore(sess, checkpt.model_checkpoint_path) return text_model
def kFLR(kFolds, learningRate): # Splitting the Dataset X_split = np.split(X, kFolds) Y_split = np.split(target_df, kFolds) X_test = [] X_train = [] # Instantiating LinearRegression() Model for i in range(len(X_split)): X_intermediateTrain = [] for j in range(len(X_split)): if i == j: X_test.append(X_split[j]) else: X_intermediateTrain.append(X_split[j]) # Training/Testing the Model X_train.append(X_intermediateTrain) X_trainSet = [] for i in X_train: X_trainSet.append(np.matrix(pd.concat(i))) Y_test = [] Y_train = [] for i in range(len(Y_split)): Y_intermediateTrain = [] for j in range(len(Y_split)): if i == j: Y_test.append(Y_split[j]) else: Y_intermediateTrain.append(Y_split[j]) Y_train.append(Y_intermediateTrain) Y_trainSet = [] for i in Y_train: Y_trainSet.append(np.matrix(pd.concat(i))) MeanAbsoluteError = [] for i in range(kFolds): X_trainSet[i] = np.array(X_trainSet[i]).T Y_trainSet[i] = np.array(Y_trainSet[i]).T X_test[i] = np.array(X_test[i]).T Y_test[i] = np.array(Y_test[i]).T MeanAbsoluteError.append( model(X_trainSet[i], Y_trainSet[i], X_test[i], Y_test[i], learningRate, 150)) totalSum = 0 for i in MeanAbsoluteError: totalSum = totalSum + i MeanAbsoluteError = totalSum / kFolds acc = round((100 - MeanAbsoluteError), 2) return acc
def test(model,iterator,criterion): model.eval() epoch_loss = 0 epoch_bleu = 0 for _, (src, trg) in enumerate(iterator): src, trg = src.to(device), trg.to(device) output = model(src, trg, 0) #turn off teacher forcing output = output[1:].view(-1, output.shape[-1]) trg = trg[1:].view(-1) loss = criterion(output, trg) bleu=bleu(output,trg) epoch_loss += loss.item() epoch_bleu+=bleu return epoch_loss / len(iterator),epoch_bleu / len(iterator)
def train(): # Import data img_batch, label_batch = distorted_inputs('C:\\Users\Akira.DESKTOP-HM7OVCC\Desktop\data\\', 20) # Create the model x = tf.placeholder(tf.float32, [None, 64, 64, 3], name='input') # Define loss and optimizer y = tf.placeholder(tf.float32, [None, 4], name='label') # Build the graph for the deep net logits = model(x) with tf.name_scope("xent"): loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits( logits=logits, labels=y), name="loss") tf.summary.scalar("loss", loss) with tf.name_scope("train"): train_step = tf.train.AdamOptimizer(1e-4).minimize(loss) with tf.name_scope("accuracy"): correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar("accuracy", accuracy) # tf.reset_default_graph() sess = tf.InteractiveSession() saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) merged = tf.summary.merge_all() writer = tf.summary.FileWriter('C:\\Users\Akira.DESKTOP-HM7OVCC\Desktop\data\\', sess.graph) tf.train.start_queue_runners(sess=sess) for i in range(500): img, label = sess.run([img_batch, label_batch]) if i % 10 == 0: train_accuracy = accuracy.eval(feed_dict={x: img, y: label}) print('step %d, training accuracy %g' % (i, train_accuracy)) result = sess.run(merged, feed_dict={x: img, y: label}) writer.add_summary(result, i) sess.run(train_step, feed_dict={x: img, y: label}) saver.save(sess, SAVE_PATH) print('Model stored...')
def main(): #loading the dataset from .h5 files #test_catvnoncat.h5 #train_catvnoncat.h5 train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset( ) print(" no of training samples : {0}".format(train_set_y.shape[1])) print(" no of testing samples : {0}".format(test_set_y.shape[1])) print(" Height and width of an image in the sample : {0} {1} {2}".format( train_set_x_orig.shape[1], train_set_x_orig.shape[2], train_set_x_orig.shape[3])) ### reshaping the training and test data set in ### train_set_x_flatten that contains image samples stored as columns and each row is a features train_set_x_flatten = train_set_x_orig.reshape( train_set_x_orig.shape[0], train_set_x_orig.shape[1] * train_set_x_orig.shape[2] * train_set_x_orig.shape[3]).T test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T # print(train_set_x_flatten.shape, test_set_x_flatten.shape) # print("*****sanity checking *****") # print(str(train_set_x_flatten[:140,0])) # print(train_set_x_orig) #standarding the dataset by taking the mean and subtracting the data by mean and dividing it with the standard deviation. #but where the range of the data is same, so here we just divide the data by 255 train_set_x = train_set_x_flatten / 255 test_set_x = test_set_x_flatten / 255 d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations=100000, learning_rate=0.4, print_cost=True) print(d["num_iterations"]) print(d["learning_rate"]) costs = np.squeeze(d['costs']) plt.plot(costs) plt.ylabel('Cost') plt.xlabel('Iterations (per hundreds)') plt.title("Learning rate =" + str(d["learning_rate"])) plt.show()
def train(model, dataloader, dataset, device, optimizer, criterion): model.train() running_loss = 0.0 counter = 0 for i, data in tqdm(enumerate(dataloader), total=int(len(dataset) / dataloader.batch_size)): counter += 1 data = data[0] data = data.to(device) optimizer.zero_grad() reconstruction, mu, logvar = model(data) bce_loss = criterion(reconstruction, data) loss = final_loss(bce_loss, mu, logvar) loss.backward() running_loss += loss.item() optimizer.step() train_loss = running_loss / counter return train_loss
def train(): loss_fn = torch.nn.NLLLoss() optimizer = torch.optim.Adam(lr=config.learning_rate, params=model.parameters()) # torch.autograd.set_detect_anomaly(True) for i in range(config.EPOCH): for j in range(config.iter_per_epoch): hidden = model.init_hidden() optimizer.zero_grad() loss = 0 category_tensor, name_tensor, target_tensor = loader.get_training_data() target_tensor.unsqueeze_(-1) for k in range(name_tensor.size(0)): output, hidden = model(category_tensor, name_tensor[k], hidden) # print(output.shape, target_tensor[k].shape) loss += loss_fn(output, target_tensor[k]) loss.backward(retain_graph=True) optimizer.step() if j % 1000 == 0: print(loss)
def validate(model, dataloader, dataset, device, criterion): model.eval() running_loss = 0.0 counter = 0 with torch.no_grad(): for i, data in tqdm(enumerate(dataloader), total=int(len(dataset) / dataloader.batch_size)): counter += 1 data = data[0] data = data.to(device) reconstruction, mu, logvar = model(data) bce_loss = criterion(reconstruction, data) loss = final_loss(bce_loss, mu, logvar) running_loss += loss.item() # save the last batch input and output of every epoch if i == int(len(dataset) / dataloader.batch_size) - 1: recon_images = reconstruction val_loss = running_loss / counter return val_loss, recon_images
def init(self, r, c, b): self.model = model(r, c, b) self.view = view(self) self.view.numBombsRemaining.setText(str( self.model.getBombsRemaining())) self.view.restartButton.clicked.connect(self.restart) self.view.timer.timeout.connect(self.every_second) #print the actual value self.view.beginnerLeaderboard.setText( self.model.getManager().printDatas( self.model.getManager().beginner, "Easy")) self.view.intermediateLeaderboard.setText( self.model.getManager().printDatas( self.model.getManager().intermediate, "Intermediate")) self.view.expertLeaderboard.setText(self.model.getManager().printDatas( self.model.getManager().expert, "Expert")) #connecting the signals for the game rules for i in range(self.model.getNumRows() * self.model.getNumCols()): self.model.getIBox(i).bomb.connect(self.model.bombClicked) self.model.getIBox(i).bomb.connect(self.endgame) self.model.getIBox(i).flaggeds.connect(self.model.flagF) self.model.getIBox(i).flaggeds.connect(self.updateBombsLabel) self.model.getIBox(i).unflaggeds.connect(self.model.unflagF) self.model.getIBox(i).unflaggeds.connect(self.updateBombsLabel) self.model.getIBox(i).flaggeds.connect(self.updateBombsLabel) self.model.getIBox(i).revealeds.connect(self.model.revealF) self.model.getIBox(i).emptybox.connect(self.model.emptyNeighbors) #connecting the signals for the menu actions self.view.easyMode.triggered.connect(self.easy) self.view.intermediateMode.triggered.connect(self.intermediate) self.view.expertMode.triggered.connect(self.expert) self.view.customMode.triggered.connect(self.showDialog) self.model.customsignal.connect(self.custom) #connecting the win game signal self.model.winsignal.connect(self.win)
def test(category, begin): def _get_letter_tensor(letter): letter_tensor = torch.zeros(1, loader.n_letters) letter_tensor[0][loader.all_letters.find(letter)] = 1 return letter_tensor.to(config.device) def _get_category_tensor(category): category_tensor = torch.zeros(1, loader.n_categories) category_tensor[0][loader.all_categories.index(category)] = 1 return category_tensor.to(config.device) result = begin hidden = model.init_hidden() input_tensor = _get_letter_tensor(begin) category_tensor = _get_category_tensor(category) for i in range(config.max_length): output, hidden = model(category_tensor, input_tensor, hidden) topv, topi = output.topk(1) topi = topi[0][0] # print(topi) if topi == loader.n_letters - 1: break result += loader.all_letters[topi] input_tensor = _get_letter_tensor(result[-1]) return result
def evaluate(model: nn.Module, iterator: torch.utils.data.DataLoader, criterion: nn.Module): model.eval() epoch_loss = 0 with torch.no_grad(): for _, (src, trg) in enumerate(iterator): src, trg = src.to(device), trg.to(device) output = model(src, trg, 0) #turn off teacher forcing output = output[1:].view(-1, output.shape[-1]) trg = trg[1:].view(-1) loss = criterion(output, trg) epoch_loss += loss.item() return epoch_loss / len(iterator)
def create_model(sess, CONFIGS): text_model = model(CONFIGS) print("Created new model.") sess.run(tf.global_variables_initializer()) return text_model
print("db = " + str(grads["db"])) print("cost = " + str(costs)) # pridict from Predict import predict print("prediction = " + str(predict(w, b, X))) print() # model from Model import model d = model(X_train=train_set_x, Y_train=train_set_y, X_test=test_set_x, Y_test=test_set_y, num_iteration=2000, learn_rate=0.005, print_cost=True) print() # Example of a picture that was wrongly classified. index = 5 plt.imshow(test_set_x[:, index].reshape((num_px, num_px, 3))) # plt.show() print("y = " + str(test_set_y[:, index]) + ", you pridict that it is a \"" + classes[int(d["Y_prediction_test"][0, index])].decode("utf-8") + "\" picture") # plot the cost function and the gradient # Plot learning curve (with costs)
target_model.model.set_weights(main_model.model.get_weights()) main_model.target_update_counter = 0 if __name__ == '__main__': episode = 0 epsilon = 1.0 MIN = 0.0 frame_idx = 0 env = Environment(window_size=int(sys.argv[1]), step_size=int(sys.argv[2]), world_size=int(sys.argv[3])) show = int(sys.argv[4]) state = env.reset() main_model = model( state.shape, INPUT_N, HIDDEN_N, ACTION_SPACE ) # Forward propagation. Uses current weights and performs our linear algebra target_model = model( state.shape, INPUT_N, HIDDEN_N, ACTION_SPACE ) # For training (Calculates gradients with backpropagation) target_model.model.set_weights(main_model.model.get_weights()) while True: frame_idx += 1 if show: env.render() reward, is_done = env.play_step(target_model, epsilon, view_live_progress=False) calc_loss(main_model, target_model, env, is_done)
#import broadcast_model as bm from Model import model import numpy as np from matplotlib import pyplot as plt np.set_printoptions(suppress=True) def get_random_num(k, b, dim0=30, dim1=2): return k * np.random.rand(dim0, dim1) + b generater_model = model() def rad(degree): return degree * np.pi / 180.0 def GetDistance(site0, site1): ''' 由经纬度坐标得到实际距离\n site0:中心点坐标,(m,2)\n site1:监测点坐标,(N,2)或(N,4) ''' centers_num = site0.shape[0] dist = [] for i in range(centers_num): center = site0[i, :] radlat1 = rad(center[0]) radlat2 = rad(site1[:, 0]) a = radlat1 - radlat2 #(N,)
def test(): return 'Hello world!' @app.route('/predict', methods=['POST']) def predict(): json_ = request.json #Check for presence of required fields reqDiffAct = set(required_fields) - set(json_.keys()) if len(reqDiffAct) > 0: raise UnprocessableEntity('Missing fields: %s' % reqDiffAct, status_code=422) #Check types #Infill dummies df = pd.DataFrame({k:[v] for k,v in json_.items()})[required_fields] prediction = event_predictor.score(json_) return jsonify({'prediction':prediction}) if __name__ == '__main__': scorObj = joblib.load('Data/scoring_objects.pkl') required_fields = scorObj['required_fields'] event_predictor = model(scorObj['rfr_search'], scorObj['memberships_per_group'], scorObj['maxRsvpLimit'], scorObj['w2vModel'], scorObj['vecSize']) app.run(host='0.0.0.0', port=80)
# if there is an error saving any jpegs try: PIL_img = Image.open(imagePath).convert( 'L') # convert it to grayscale except: continue img_numpy = np.array(PIL_img, 'uint8') id = int(os.path.split(imagePath)[-1].split(".")[1]) faceSamples.append(img_numpy) ids.append(id) return faceSamples, ids _, ids = getImagesAndLabels() model = model((32, 32, 1), len(set(ids))) model.load_weights('trained_model.h5') model.summary() cascPath = "haarcascade_frontalface_default.xml" faceCascade = cv2.CascadeClassifier(cascPath) font = cv2.FONT_HERSHEY_SIMPLEX def start(): cap = cv2.VideoCapture(0) print('here') ret = True clip = [] while ret:
file_glob = './data/testdata-*.tfrecord' # test_iterator = get_rt_dataset(hparams, file_glob) def nll_loss(iterator, model_fn): _origin, _incident, _normal, _Li, _image_rgb, _image_depth, _image_position = iterator.get_next() _x = tf.concat([_origin, _incident, _normal], axis=1) _images = tf.concat([_image_rgb, _image_depth, _image_position], axis=-1) _distribution = model_fn(_x, images) neg_log_loss = -tf.reduce_mean(_distribution.log_prob(_Li)) return neg_log_loss D = 3 d = ceil(D // 2) _model_fn = model(D, d, hparams) LOG_FREQUENCY = 1e0 steps_in_epoch = floor(TRAIN_TOTAL_SIZE / hparams.batch_size) # t_steps_in_epoch = floor(TEST_TOTAL_SIZE / hparams.batch_size) decay_steps = int(5e4) global_step = tf.train.get_or_create_global_step() learning_rate = tf.train.exponential_decay( hparams.learning_rate, global_step, decay_steps, 0.95) lr_summary = tf.summary.scalar('learning_rate', learning_rate) optimizer = tf.train.AdamOptimizer(learning_rate) _origin, _incident, _normal, _Li, _image_rgb, _image_depth, _image_position = train_iterator.get_next() x = tf.concat([_origin, _incident, _normal], axis=1)
for i in range(len(ty)): if (ty[i] == [0, 1, 0, 0, 0, 0, 0]).all(): ty[i] = [0, 1, 0, 0, 0, 0, 0] else: ty[i] = [1, 0, 0, 0, 0, 0, 0] weight = [] for i in range(len(graph)): iweight = [] for j in graph[i]: iweight.append(1.0) weight.append(iweight) print("Initial the model") m = model(args) m.add_data(x, y, graph, weight, 2, True) m.build() m.init_train(init_iter_graph=150) print("Start training") max_iters = 50000 max_accu, max_recall = 0, 0 y_score = None for iter_cnt in range(max_iters): m.step_train(max_iter=1, iter_graph=0, iter_inst=1, iter_label=0) tpy = m.predict(tx) accu = comp_accu(tpy, ty) print(iter_cnt, accu, max_accu) if accu > max_accu: m.store_params()
from Model import model m=model("test.txt") m.Uppercase(); m.Lowercase();
def classify(treeDic, x_test , x_train,TDdroprate,BUdroprate,lr, weight_decay,patience,n_epochs,batchsize,dataname,iter, fold_count): unsup_model = Net(64, 3).to(device) for unsup_epoch in range(25): optimizer = th.optim.Adam(unsup_model.parameters(), lr=lr, weight_decay=weight_decay) unsup_model.train() traindata_list, _ = loadBiData(dataname, treeDic, x_train+x_test, x_test, 0.2, 0.2) train_loader = DataLoader(traindata_list, batch_size=batchsize, shuffle=True, num_workers=4) batch_idx = 0 loss_all = 0 tqdm_train_loader = tqdm(train_loader) for Batch_data in tqdm_train_loader: optimizer.zero_grad() Batch_data = Batch_data.to(device) loss = unsup_model(Batch_data) loss_all += loss.item() * (max(Batch_data.batch) + 1) loss.backward() optimizer.step() batch_idx = batch_idx + 1 loss = loss_all / len(train_loader) name = "best_pre_"+dataname +"_4unsup" + ".pkl" th.save(unsup_model.state_dict(), name) print('Finished the unsuperivised training.', ' Loss:', loss) print("Start classify!!!") # unsup_model.eval() log_train = 'logs/' + datasetname + '/' + 'train' + 'iter_' + str(iter) writer_train = SummaryWriter(log_train) log_test = 'logs/' + datasetname + '/' + 'test' + 'iter_' + str(iter) writer_test = SummaryWriter(log_test) model = Classfier(64*3,64,4).to(device) opt = th.optim.Adam(model.parameters(), lr=0.0005, weight_decay=weight_decay) train_losses = [] val_losses = [] train_accs = [] val_accs = [] early_stopping = EarlyStopping(patience=10, verbose=True) for epoch in range(n_epochs): traindata_list, testdata_list = loadBiData(dataname, treeDic, x_train, x_test, TDdroprate,BUdroprate) train_loader = DataLoader(traindata_list, batch_size=batchsize, shuffle=True, num_workers=4) test_loader = DataLoader(testdata_list, batch_size=batchsize, shuffle=True, num_workers=4) avg_loss = [] avg_acc = [] batch_idx = 0 tqdm_train_loader = tqdm(train_loader) model.train() unsup_model.train() for Batch_data in tqdm_train_loader: Batch_data.to(device) _, Batch_embed = unsup_model.encoder(Batch_data.x, Batch_data.edge_index, Batch_data.batch) out_labels= model(Batch_embed, Batch_data) finalloss=F.nll_loss(out_labels,Batch_data.y) loss=finalloss opt.zero_grad() loss.backward() avg_loss.append(loss.item()) opt.step() _, pred = out_labels.max(dim=-1) correct = pred.eq(Batch_data.y).sum().item() train_acc = correct / len(Batch_data.y) avg_acc.append(train_acc) print("Iter {:03d} | Epoch {:05d} | Batch{:02d} | Train_Loss {:.4f}| Train_Accuracy {:.4f}".format(iter,epoch, batch_idx, loss.item(), train_acc)) batch_idx = batch_idx + 1 writer_train.add_scalar('train_loss', np.mean(avg_loss), global_step=epoch+1) writer_train.add_scalar('train_acc', np.mean(avg_acc), global_step=epoch+1) train_losses.append(np.mean(avg_loss)) train_accs.append(np.mean(avg_acc)) temp_val_losses = [] temp_val_accs = [] temp_val_Acc_all, temp_val_Acc1, temp_val_Prec1, temp_val_Recll1, temp_val_F1, \ temp_val_Acc2, temp_val_Prec2, temp_val_Recll2, temp_val_F2, \ temp_val_Acc3, temp_val_Prec3, temp_val_Recll3, temp_val_F3, \ temp_val_Acc4, temp_val_Prec4, temp_val_Recll4, temp_val_F4 = [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [] model.eval() unsup_model.eval() tqdm_test_loader = tqdm(test_loader) for Batch_data in tqdm_test_loader: Batch_data.to(device) Batch_embed = unsup_model.encoder.get_embeddings(Batch_data) val_out = model(Batch_embed, Batch_data) val_loss = F.nll_loss(val_out, Batch_data.y) temp_val_losses.append(val_loss.item()) _, val_pred = val_out.max(dim=1) correct = val_pred.eq(Batch_data.y).sum().item() val_acc = correct / len(Batch_data.y) Acc_all, Acc1, Prec1, Recll1, F1, Acc2, Prec2, Recll2, F2, Acc3, Prec3, Recll3, F3, Acc4, Prec4, Recll4, F4 = evaluation4class( val_pred, Batch_data.y) temp_val_Acc_all.append(Acc_all), temp_val_Acc1.append(Acc1), temp_val_Prec1.append( Prec1), temp_val_Recll1.append(Recll1), temp_val_F1.append(F1), \ temp_val_Acc2.append(Acc2), temp_val_Prec2.append(Prec2), temp_val_Recll2.append( Recll2), temp_val_F2.append(F2), \ temp_val_Acc3.append(Acc3), temp_val_Prec3.append(Prec3), temp_val_Recll3.append( Recll3), temp_val_F3.append(F3), \ temp_val_Acc4.append(Acc4), temp_val_Prec4.append(Prec4), temp_val_Recll4.append( Recll4), temp_val_F4.append(F4) temp_val_accs.append(val_acc) writer_test.add_scalar('val_loss', np.mean(temp_val_losses), global_step=epoch+1) writer_test.add_scalar('val_accs', np.mean(temp_val_accs), global_step=epoch+1) val_losses.append(np.mean(temp_val_losses)) val_accs.append(np.mean(temp_val_accs)) print("Epoch {:05d} | Val_Loss {:.4f}| Val_Accuracy {:.4f}".format(epoch, np.mean(temp_val_losses), np.mean(temp_val_accs))) res = ['acc:{:.4f}'.format(np.mean(temp_val_Acc_all)), 'C1:{:.4f},{:.4f},{:.4f},{:.4f}'.format(np.mean(temp_val_Acc1), np.mean(temp_val_Prec1), np.mean(temp_val_Recll1), np.mean(temp_val_F1)), 'C2:{:.4f},{:.4f},{:.4f},{:.4f}'.format(np.mean(temp_val_Acc2), np.mean(temp_val_Prec2), np.mean(temp_val_Recll2), np.mean(temp_val_F2)), 'C3:{:.4f},{:.4f},{:.4f},{:.4f}'.format(np.mean(temp_val_Acc3), np.mean(temp_val_Prec3), np.mean(temp_val_Recll3), np.mean(temp_val_F3)), 'C4:{:.4f},{:.4f},{:.4f},{:.4f}'.format(np.mean(temp_val_Acc4), np.mean(temp_val_Prec4), np.mean(temp_val_Recll4), np.mean(temp_val_F4))] print('unsup_epoch:', (unsup_epoch+1) ,' results:', res) early_stopping(np.mean(temp_val_losses), np.mean(temp_val_accs), np.mean(temp_val_F1), np.mean(temp_val_F2), np.mean(temp_val_F3), np.mean(temp_val_F4), model, 'RDEA_'+str(fold_count)+'_', dataname) accs =np.mean(temp_val_accs) F1 = np.mean(temp_val_F1) F2 = np.mean(temp_val_F2) F3 = np.mean(temp_val_F3) F4 = np.mean(temp_val_F4) if epoch>=199: accs = early_stopping.accs F1 = early_stopping.F1 F2 = early_stopping.F2 F3 = early_stopping.F3 F4 = early_stopping.F4 if early_stopping.early_stop: print("Early stopping") accs=early_stopping.accs F1=early_stopping.F1 F2 = early_stopping.F2 F3 = early_stopping.F3 F4 = early_stopping.F4 break return train_losses , val_losses ,train_accs, val_accs,accs,F1,F2,F3,F4
from DataIn import Data_in from Data import GenData from Datasex import SexData from Model import model, graph from RFCmodel import RFC data = Data_in() RFC(data) #GenData(data) #SexData(data) model(data)
sourceMax = -100 for i in range(len(article_list)): if len(article_list[i]) > sourceMax: sourceMax = len(article_list[i]) emb_matrix = np.zeros( (len(words_to_index) + 1, word_to_vec_map['go'].shape[0]), dtype=np.float32) for i in range(1, len(words_to_index)): emb_matrix[i] = word_to_vec_map[str(index_to_words[i])].astype(np.float32) max_target_sentence_length = max([len(sentence) for sentence in title_list]) train_graph = tf.Graph() with train_graph.as_default(): myModel = model() inputs, targets, target_sequence_length, max_target_len, source_sequence_length = myModel.enc_dec_model_inputs( ) lr, keep_prob = myModel.hyperparam_inputs() train_logits, infer_logits = myModel.seq2seq( inputs, targets, KEEP_PROB, BATCH_SIZE, target_sequence_length, max_target_len, len(words_to_index), len(words_to_index), EMBEDDING_SIZE, EMBEDDING_SIZE, RNN_SIZE, NUM_LAYERS, words_to_index, source_sequence_length, emb_matrix) training_logits = tf.identity(train_logits.rnn_output, name='logits') inference_logits = tf.identity(infer_logits.sample_id, name='predictions') # https://www.tensorflow.org/api_docs/python/tf/sequence_mask # - Returns a mask tensor representing the first N positions of each cell.
if args.Mode == 'Init_Dir': create_dir(dict_dir) if args.Mode == 'Mask': create_mask('Train', args.Num, dict_dir) create_mask('Val', args.Num, dict_dir) if args.Mode == 'Run': # create validation set: X_val, y_val = create_dataset('Val', 2000, dict_dir) # compile model = model() print(model.summary()) model.compile(optimizer='Adamax', loss='binary_crossentropy', metrics=['accuracy']) Model_Checkpoints = dict_dir[ 'Saved_Models'] + 'Checkpoint_' + now.strftime( "%d_%m_%H%M") + '.h5' callbacks = [ EarlyStopping(monitor='val_loss', patience=5, verbose=1, mode='auto',
PIL_img = Image.open(imagePath).convert('L') except: continue img_numpy = np.array(PIL_img,'uint8') id = int(os.path.split(imagePath)[-1].split(".")[1]) faceSamples.append(img_numpy) ids.append(id) return faceSamples,ids print ("\n [INFO] Training faces now.") faces,ids = getImagesAndLabels(path) K.clear_session() n_faces = len(set(ids)) model = model((32,32,1),n_faces) faces = np.asarray(faces) faces = np.array([downsample_image(ab) for ab in faces]) ids = np.asarray(ids) faces = faces[:,:,:,np.newaxis] print("Shape of Data: " + str(faces.shape)) print("Number of unique faces : " + str(n_faces)) ids = to_categorical(ids) faces = faces.astype('float32') faces /= 255. x_train, x_test, y_train, y_test = train_test_split(faces,ids, test_size = 0.20, random_state = 0)
# pca visualization to get number of components pca(X_train) # dimensionality reduction X_train_reduced, X_test_reduced = dimension_reduction('PCA', 20, X_train, X_test) # dealing with imbalanced class X_train_smote, y_train_smote = class_imbalance(X_train_reduced, y_train) # machine learning model metrics = ['accuracy', 'f1', 'precision', 'recall', 'roc_auc'] # 1. Logistic Regression # KFold cross validation model_res = model('LR', 'KFold', metrics, X_train_smote, X_test_reduced, y_train_smote) # StratifiedKFold cross validation model_res = model('LR', 'StratifiedKFold', metrics, X_train_smote, X_test_reduced, y_train_smote) # make prediction prediction(model_res, 'Linear Regression', X_train_smote, y_train_smote, X_test_reduced, y_test) # 2. XGBoost # KFold cross validation model_res = model('XGB', 'KFold', metrics, X_train_smote, X_test_reduced, y_train_smote) # StratifiedKFold cross validation model_res = model('XGB', 'StratifiedKFold', metrics, X_train_smote, X_test_reduced, y_train_smote) # make prediction
for i in all_data: data = np.vstack((data, np.load(i))) print(str(x) + "/" + str(len(all_data)) + " items loaded!") x += 1 print("Data loaded!") random.shuffle(data) # Shuffle data (important when doing machine learning!) train_data = data[HM_TEST:] test_data = data[:HM_TEST] train_x = [i[0] for i in train_data] train_y = [i[1] for i in train_data] test_x = [i[0] for i in test_data] test_y = [i[1] for i in test_data] model = model(WIDTH, HEIGHT, LR) model.fit({'input_pic': train_x}, {'targets': train_y}, n_epoch=EPOCHS, validation_set=({ 'input_pic': test_x }, { 'targets': test_y }), snapshot_step=100, show_metric=True, batch_size=200, validation_batch_size=100) model.save(MODEL_NAME)
def project_tsne(params, dataset, pairs_x, pairs_y, dist, P_joint, device): print("---------------------------------") print("Begin finding the embedded space") net = model(params.col, params.output_dim) Project_DNN = init_model(net, device, restore=None) optimizer = optim.RMSprop(Project_DNN.parameters(), lr=params.lr) c_mse = nn.MSELoss() Project_DNN.train() dataset_num = len(dataset) for i in range(dataset_num): P_joint[i] = torch.from_numpy(P_joint[i]).float().to(device) dataset[i] = torch.from_numpy(dataset[i]).float().to(device) for epoch in range(params.epoch_DNN): len_dataloader = np.int(np.max(params.row) / params.batch_size) if len_dataloader == 0: len_dataloader = 1 params.batch_size = np.max(params.row) for step in range(len_dataloader): KL_loss = [] for i in range(dataset_num): random_batch = np.random.randint(0, params.row[i], params.batch_size) data = dataset[i][random_batch] P_tmp = torch.zeros([params.batch_size, params.batch_size]).to(device) for j in range(params.batch_size): P_tmp[j] = P_joint[i][random_batch[j], random_batch] P_tmp = P_tmp / torch.sum(P_tmp) low_dim_data = Project_DNN(data, i) Q_joint = Q_tsne(low_dim_data) KL_loss.append(torch.sum(P_tmp * torch.log(P_tmp / Q_joint))) feature_loss = np.array(0) feature_loss = torch.from_numpy(feature_loss).to(device).float() for i in range(dataset_num - 1): low_dim = Project_DNN(dataset[i][pairs_x[i]], i) low_dim_biggest_dataset = Project_DNN( dataset[dataset_num - 1][pairs_y[i]], len(dataset) - 1) feature_loss += c_mse(low_dim, low_dim_biggest_dataset) # min_norm = torch.min(torch.norm(low_dim), torch.norm(low_dim_biggest_dataset)) # feature_loss += torch.abs(torch.norm(low_dim) - torch.norm(low_dim_biggest_dataset))/min_norm loss = params.beta * feature_loss for i in range(dataset_num): loss += KL_loss[i] optimizer.zero_grad() loss.backward() optimizer.step() if (epoch + 1) % params.log_DNN == 0: print("epoch:[{:d}/{}]: loss:{:4f}, align_loss:{:4f}".format(epoch+1, \ params.epoch_DNN, loss.data.item(), feature_loss.data.item())) integrated_data = [] for i in range(dataset_num): integrated_data.append(Project_DNN(dataset[i], i)) integrated_data[i] = integrated_data[i].detach().cpu().numpy() print("Done") return integrated_data