def create_models(samples, dictionary): neumf = NeuMF(len(samples), len(dictionary), 0.5, 8, [64, 32, 16, 8]) attr_nets = dict() for key, labels in dictionary.items(): if labels is None: # regression; attr_nets[key] = Regression(16) else: # classification # NOTE: class num doesnt include blank labels attr_nets[key] = Classification(16, len(labels) - 1) return neumf, attr_nets
config = args.parse_args() if config.mode == 'train': dropout_prob = config.dropout is_training = True else: dropout_prob = 0.0 is_training = False if not HAS_DATASET and not IS_ON_NSML: # It is not running on nsml if config.dataset_path: DATASET_PATH = config.dataset_path else: DATASET_PATH = '../sample_data/movie_review/' model = Regression(config.embedding, config.strmaxlen, dropout_prob, config.rnn_layers, use_gpu=USE_GPU, model_type=config.model_type) if USE_GPU: #if USE_GPU > 1: # model = nn.DataParallel(model) model = model.cuda() # DONOTCHANGE: Reserved for nsml use bind_model(model, config) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.01, weight_decay=0.0001) # DONOTCHANGE: They are reserved for nsml if config.pause: nsml.paused(scope=locals())
# Exact relation between Y and X def f(X): return np.log(10.0 * (abs(X - 0.03) + 0.03)) * np.sin(np.pi * (abs(X - 0.03) + 0.03)) # Generate test data N_star = 2000 X_star = np.linspace(-2., 2., N_star)[:, None] Y_star = f(X_star) # Model creation layers_P = np.array([X_dim + Z_dim, 100, 100, 100, Y_dim]) layers_Q = np.array([X_dim + Y_dim, 100, 100, 100, Z_dim]) layers_T = np.array([X_dim + Y_dim, 100, 100, 1]) model = Regression(X, Y, layers_P, layers_Q, layers_T, lam=1.5) model.train(nIter=20000, batch_size=N) # Prediction plt.figure(1) N_samples = 500 samples_mean = np.zeros((X_star.shape[0], N_samples)) for i in range(0, N_samples): samples_mean[:, i:i + 1] = model.generate_sample(X_star) plt.plot(X_star, samples_mean[:, i:i + 1], 'k.', alpha=0.005) plt.plot(X, Y, 'r*', alpha=0.2, label='%d training data' % N) mu_pred = np.mean(samples_mean, axis=1) Sigma_pred = np.var(samples_mean, axis=1)
args.add_argument('--output', type=int, default=1) args.add_argument('--max_epoch', type=int, default=10) args.add_argument('--batch', type=int, default=2000) args.add_argument('--strmaxlen', type=int, default=200) args.add_argument('--embedding', type=int, default=8) # Select model args.add_argument('--model', type=str, default='classification', choices=['regression', 'classification']) config = args.parse_args() print('HAS_DATASET :', HAS_DATASET) print('IS_ON_NSML :', IS_ON_NSML) print('DATASET_PATH :', DATASET_PATH) model_type = { 'regression' : Regression(config.embedding, config.strmaxlen), 'classification' : Classification(config.embedding, config.strmaxlen), } model = model_type[config.model] if GPU_NUM: model = model.cuda() # DONOTCHANGE: Reserved for nsml use bind_model(model, config) criterion_type = { 'regression' : nn.MSELoss(), 'classification' : nn.CrossEntropyLoss(), } criterion = criterion_type[config.model]
def main(): INPUT_DIM = 21 OUTPUT_DIM = 6 BATCH_SIZE = 64 EPOCH = 500 data_path = "A" criterion = nn.MSELoss().to(DEVICE) model = Regression(INPUT_DIM, OUTPUT_DIM).to(DEVICE) optim = Adam(model.parameters(), lr=1e-3, betas=(0.5, 0.99)) dataloader = get_dataloader(-1, dataset_path=data_path, train=True, batch_size=BATCH_SIZE, dataset_name="AirQualityV1") valid_loader = get_dataloader(-1, dataset_path=data_path, train=False, batch_size=5000, shuffle=False, dataset_name="AirQualityV1") loss_arr = [] loss_arr_valid = [] for i in range(EPOCH): # training total_loss = 0 for index, (predict_feature, label, _, _) in enumerate(dataloader): model.train() predict_feature, label = predict_feature.to(DEVICE), label.to( DEVICE) logit = model(predict_feature) loss = criterion(logit, label) optim.zero_grad() loss.backward() optim.step() total_loss += loss.item() loss_arr.append(total_loss / len(dataloader)) # valid # model.eval() # with torch.no_grad(): # valid_predict, valid_label, predict_feature, target_feature = next(iter(valid_loader)) # valid_predict, valid_label = valid_predict.to(DEVICE), valid_label.to(DEVICE) # t_logit = model(valid_predict) # t_loss = criterion(t_logit, valid_label) # t_aqi, t_index = calculate_aqi(t_logit.data.cpu().numpy() + predict_feature.data.numpy()) # r_aqi, r_index = calculate_aqi(target_feature.data.numpy()) # acc = accuracy_score(r_index, t_index) # f1 = f1_score(r_index, t_index, average="macro") # print("epoch: {}, training_loss: {}; validate_loss: {}, acc: {:.4f}, f1: {:.4f}" # .format(i+1, total_loss / len(dataloader), t_loss, acc, f1)) # loss_arr_valid.append(t_loss) # # if (i + 1) % 50 == 0: # plt.figure(figsize=(10, 10)) # y_labels = ["SO2(μg/m³)", "NO2(μg/m³)", "PM10(μg/m³)", "PM2.5(μg/m³)", "O3(μg/m³)", "CO(mg/m³)"] # for item in range(1, 5): # plt.rcParams["font.family"] = 'Arial Unicode MS' # plt.subplot(2, 2, item) # plt.plot(np.array(r_aqi)[:, item], 'orange', label='real AQI', linewidth=3) # plt.plot(np.array(t_aqi)[:, item], 'royalblue', label='predict AQI', linewidth=3) # plt.ylabel("AQI ({})".format(y_labels[item])) # plt.xlabel("Time") # plt.legend() # plt.xticks(rotation=45) # plt.savefig('./results/AQI{}_v1.png'.format(data_path), dpi=200) # # plt.figure(figsize=(6.4, 5.2)) # plt.rcParams["font.family"] = 'Arial Unicode MS' # plt.plot(np.array(loss_arr), 'orange', label='training loss', linewidth=3) # plt.plot(np.array(loss_arr_valid), 'royalblue', label='validate loss', linewidth=3) # plt.ylabel('MSE') # plt.xlabel('Epoch') # plt.xticks(rotation=45) # plt.legend() # plt.savefig('./results/loss{}_v1.png'.format(data_path), dpi=200) # torch.save(model, './results/Regression{}.pk'.format(data_path)) if (i + 1) % 50 == 0: test(model, data_path)