def train_one_epoch(model, param_dict, input_names, output_name, X_shuffled, Y_shuffled): batch_size = int(param_dict['batch_size']) l = len(X_shuffled) train_loss = 0 train_acc = 0 for i in range(0, l, batch_size): batch_end = min(i + batch_size, l) Xs = X_shuffled[i:batch_end] Ys = Y_shuffled[i:batch_end] batchsize = len(Xs) batch = gd.get_batch(Xs, param_dict) batch = da.augment_data(batch, param_dict, "train") #If single stream model, we have 1 input_name, otherwise 2 fit_input = make_model_input_dict(input_names, batch) # Train on single batch history = model.fit(fit_input, {output_name: Ys}, batch_size=batchsize) train_loss += float(history.history['loss'][0]) * (batchsize / l) train_acc += float(history.history['acc'][0]) * (batchsize / l) return model, train_loss, train_acc
def train(model,loss_func,optim,poem_vec_lst7, num_epochs, model_path): global BATCH_SIZE,get_batch,idx2Wd,vocab_size,sentence_len for epoch in range(start_epoch,start_epoch+num_epochs): print('Starting epoch %d / %d' % (epoch+1,start_epoch+num_epochs)) model.train() #设置网络模型为train模式 #每个epoch取epoch_size//batch_size次,分别使idx取0,1,2,...,epoch_size//batch_size-1 for idx in range(len(poem_vec_lst7)//BATCH_SIZE): print(idx*BATCH_SIZE,"/",len(poem_vec_lst7)) batch_x,batch_y=get_batch(poem_vec_lst7,BATCH_SIZE,idx, 7)#得到batch_x,batch_y batch_x=np.array(batch_x) batch_y=np.array(batch_y) output=model(batch_x,True)#output为模型预测的向量 #将output变成BATCH_SIZE*3(句)*每句sentence_len个字,每个字有vocab_size种选择的向量 output=torch.reshape(output,(BATCH_SIZE*3*sentence_len,vocab_size)) #将output变成BATCH_SIZE*3(句)*每句sentence_len个字,每个位置是ground_truth对应字的index batch_y=np.reshape(batch_y,BATCH_SIZE*3*sentence_len) batch_y=torch.LongTensor(batch_y) #output中选出概率最大的字,这个字的index放到wordidx里 wordidx=torch.argmax(output,dim=1) loss=loss_func(output,batch_y)#output是每个位置预测每个字的概率分布矩阵,batch_y是一维数组,分别是ground_truth中每个位置字的index print('loss is %lf'%(loss.item())) loss.backward() optim.step() optim.zero_grad() #print('epoch '%) #保存模型 print("save model in epoch %d "%(epoch)) torch.save(model.state_dict(), model_path + "\\rnn7_epoch_%d.pth"%(epoch))
def validate_one_epoch(model, param_dict, input_names, output_name, X_val, Y_val): X_val_data = gd.get_batch(X_val, param_dict) X_val_augmented = da.augment_data(X_val_data, param_dict, "val") # Evaluate on validation data print("Evaluating On Validation Data...") fit_input = make_model_input_dict(input_names, X_val_augmented) val_loss, val_acc = model.evaluate(fit_input, {output_name: Y_val}) return val_loss, val_acc
def main(): # 선형회귀와 같은 파라미터 # 특징 벡터의 차원 설정 dimension = 10 # 비선형 플래그 nonlinear = False # 전체 데이터의 수 num_of_samples = 1000 # 노이즈의 진폭 noise_amplitude = 0.01 # 하이퍼 파라미터의 설정 batch_size = 10 max_epoch = 10000 learning_rate = 1e-3 momentum = 0.9 # 이 값을 하면 모멘트법이 됩니다 regularize_coeff = 0.0 # 이 값을 하면 L2 노름에 의한 법칙이 걸립니다 # 전체 데이터 구하기 # NOTE: 여기에서는 미니배치 동작만을 보기 위해서 # 일단 전체 데이터를 취득하고 나서 배치 단위로 잘라서 반환합니다 # 그러나, 미니배치법이 필요하게 되는 상황에서는 # 전체 데이터를 한번에 읽어 들이지 않는 경우가 보통이므로 # 수 배치분을 읽어 들여 버퍼하고 나서 1배치만 반환해야 합니다 # 이러한 경우, python의 기능을 살려 # 순서를 따라 읽어 들이는 제너레이터를 작성하는 것이 유효합니다 data_train, (X_test, Y_test) = get_all(dimension, nonlinear, num_of_samples, noise_amplitude, return_coefficient_matrix=False) A_test = coeff(X_test) # 손실의 이력 train_losses = [] test_losses = [] # 파라미터의 초기값 D_hat = np.zeros(dimension + 1) # 에포크에 대해서의 루프 for epoch in range(max_epoch): print("epoch: {0} / {1}".format(epoch, max_epoch)) # 배치 단위로 분할 data_train_batch = get_batch(data_train, batch_size) # 1에포크 분 학습 loss, D_hat = train_epoch(data_train_batch, D_hat, learning_rate, momentum, regularize_coeff) # 손실을 이력에 저장 train_losses.append(loss) # 전형적인 코드에서는 어떤 에포크에 한 번 테스트를 실시하고 # 도중 경과가 어느 정도의 범화성능을 나타내는지 확인하지만 # 여기에서는 매회 테스트를 실시하고 있습니다 Y_hat = A_test.dot(D_hat) E = Y_hat - Y_test test_loss = E.T.dot(E) test_losses.append(test_loss) # 실험기록용 parameters = { "linearity": "nonlinear" if nonlinear else "linear", "dimension": dimension, "num_of_samples": num_of_samples, "batch_size": batch_size, "max_epoch": max_epoch, "learning_rate": learning_rate, "momentum": momentum, "regularize_coeff": regularize_coeff, } # 결과 표시 visualize_result("linear_regression_iterative_solution", A_test[:, 0:2], Y_test, Y_hat, parameters, losses=(train_losses, test_losses))
# model=FastText2(maxlen,embedding_dim,word_dict,num_class) print('fit...') # train_data=np.array(train_tensor) # train_label=to_categorical(np.array(train_label),num_classes=num_class) #model.fit(train_data,train_label,validation_split=0.1,epochs=10,batch_size=64,callbacks=callback_list,verbose=0) max_acc = 0.0 for iter in range(iter_num): i = 0 sum_loss = 0. sum_acc = 0. data_length = len(train_tensor) batch_nums = (data_length // batch_size) - 1 while i < batch_nums: batch_data, batch_label = get_batch(batch_size, i, train_tensor, train_label) batch_data = np.array(batch_data) batch_label = np.array(batch_label) batch_label = to_categorical(batch_label, num_classes=num_class) batch_train, batch_test, batch_train_label, batch_test_label = train_test_split( batch_data, batch_label, test_size=0.1, random_state=22) batch_train = np.array(batch_train) batch_test = np.array(batch_test) model.train_on_batch(batch_train, batch_train_label) i += 1 print('iter : %d, i :%d' % (iter, i)) loss, acc = model.evaluate(batch_test, batch_test_label, batch_size=batch_size) print('Train loss: %f, Train accuracy: %f ' % (loss, acc))
model = tu.make_network_model(param_dict,stream,None) weights_pre = model.get_weights() model = tu.load_weights(model, param_dict, stream, False, "test") weights_after = model.get_weights() weight_names = [weight.name for layer in model.layers for weight in layer.weights] tu.check_weights(weights_pre, weights_after, weight_names) # If the frame at second 1 is used (time of shot in B3SD dataset), then # we only get that particular frame for each video. if sec1_frame: print("1sec_frame set, so choosing that frame for each video") result_file.write("1sec_frame set, so choosing that frame for each video\n") X = gd.get_batch(X, param_dict) augmented_X = da.augment_data(X, param_dict, "test") fit_input = tu.make_model_input_dict(input_names, augmented_X) predictions_categorical = model.predict(fit_input, verbose=1) print(predictions_categorical.shape) predictions = np.asarray([np.argmax(pred) for pred in predictions_categorical]) print(predictions.shape) acc, correct_predictions = tpu.calculate_accuracy(predictions, Y, len(predictions)) # If sec1_frame is false, then we select x frames from each video for a # more averaged guess for each video. else:
def main(): # 선형회귀와 같은 파라미터 # 특징 벡터의 차원의 설정 dimension = 10 # 비선형 플래그 nonlinear = True # 전체 데이터 수 num_of_samples = 1000 # 노이즈 진폭 noise_amplitude = 0.01 # 선형회귀와 공통의 하이퍼 파라미터 batch_size = 10 max_epoch = 10000 learning_rate = 1e-3 momentum = 0.0 regularize_coeff = 0.0 # 뉴럴 네트워크 특유의 하이퍼 파라미터 # 중간층의 유닛수(채널 수) # NOTE: 여기에서는 1층만으로 하지만 # 리스트에 값을 붙여 나감으로써 층을 추가할 수 있습니다 # 단지, 메모리 사용량에는 주의하세요! num_units = [ 50, 100, ] # 전체 데이터 구하기 data_train, (X_test, Y_test) = get_all(dimension, nonlinear, num_of_samples, noise_amplitude, return_coefficient_matrix=False) # 손실의 이력 train_losses = [] test_losses = [] # 파라미터의 초기값 W_hat = init_weights(num_units, dimension) for epoch in range(max_epoch): print("epoch: {0}/{1}".format(epoch, max_epoch)) # 배치 단위로 분할 data_train_batch = get_batch(data_train, batch_size) # 1에포크 분 학습 train_loss, W_hat = train_epoch(data_train_batch, W_hat, learning_rate, momentum, regularize_coeff) # 결과를 이력에 저장 train_losses.append(train_loss) # 테스트 데이터로의 피팅 Y_hat = forward(X_test, W_hat)[-1][:, 0] E = Y_hat - Y_test test_loss = E.T.dot(E) test_losses.append(test_loss) # 실험 기록용 parameters = { "linearity": "nonlinear" if nonlinear else "linear", "dimension": dimension, "num_of_samples": num_of_samples, "batch_size": batch_size, "max_epoch": max_epoch, "learning_rate": learning_rate, "momentum": momentum, "regularize_coeff": regularize_coeff, "num_units": num_units, } # 결과 표시 visualize_result("neural_network", X_test[:, 0:2], Y_test, Y_hat, parameters, losses=(train_losses, test_losses))
model_part1 = tu.make_network_model(param_dict_part1,stream_part1,None) weights_pre = model_part1.get_weights() model_part1 = tu.load_weights(model_part1, param_dict_part1, stream_part1, True, "test") weights_after = model_part1.get_weights() weight_names = [weight.name for layer in model_part1.layers for weight in layer.weights] tu.check_weights(weights_pre, weights_after, weight_names) # If the frame at second 1 is used (time of shot in B3SD dataset), then # we only get that particular frame for each video. print("1sec_frame set, so choosing that frame for each video") result_file.write("1sec_frame set, so choosing that frame for each video\n") X2_data = gd.get_batch(X2, param_dict_part1) augmented_X2 = da.augment_data(X2_data, param_dict_part1, "test") fit_input2 = tu.make_model_input_dict(input_part1, augmented_X2) predictions_categorical2 = model_part1.predict(fit_input2, verbose=1) print(predictions_categorical2.shape) predictions2 = np.asarray([np.argmax(pred) for pred in predictions_categorical2]) print(predictions2.shape) acc2, correct_predictions2 = tpu.calculate_accuracy(predictions2, Y2, len(predictions2)) correct=0 ones = 0 actual_shots=0
CAPACITY = 1000 #每批次最大容量 MAX_STEP = 100000 # 训练总批次 VAL_SPACE = 100 #训练几批,测试一次 learning_rate = 0.0001 # 学习率 # 用这个程序,请改路径 train_dir = '/home/emin/Temp/Tensorflow/data/cifar-10/train/' test_dir = '/home/emin/Temp/Tensorflow/data/cifar-10/test/' logs_train_dir = '/home/emin/Temp/Tensorflow/Me/cifar_me/train/' logs_val_dir = '/home/emin/Temp/Tensorflow/Me/cifar_me/val/' arra = [0] * (int(MAX_STEP / VAL_SPACE)) #储存训练准确度 brra = [0] * (int(MAX_STEP / VAL_SPACE)) #储存测试准确度 train, train_label = get_data.get_files(train_dir) #读训练集 val, val_label = get_data.get_files(test_dir) #读测试集 train_batch, train_label_batch = get_data.get_batch(train, train_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) val_batch, val_label_batch = get_data.get_batch(val, val_label, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) #生成批次 x = tf.placeholder(tf.float32, shape=[BATCH_SIZE, IMG_W, IMG_H, 3]) y_ = tf.placeholder(tf.int32, shape=[BATCH_SIZE]) keep_prob = tf.placeholder(tf.float32) #损失率 logits = model.inference(x, BATCH_SIZE, N_CLASSES, keep_prob) loss = model.losses(logits, y_) #计算误差 acc = model.evaluation(logits, y_) #计算准确度 train_op = model.trainning(loss, learning_rate) #训练开始程序 with tf.Session() as sess: saver = tf.train.Saver() #运行队列准备等