def create_model(sess, FLAGS, mode): """Create model only used for train mode. """ if FLAGS.model == "vallina": model = LinearModel(FLAGS, mode) model.build() else: pass # other model # create task file model_path = os.path.join(FLAGS.logdir, FLAGS.task_name) if not os.path.exists(model_path): os.makedirs(model_path) print("Save model to {}".format(model_path)) elif (FLAGS.reset): shutil.rmtree(model_path) os.makedirs(model_path) print("Remove existing model at {} and restart.".format(model_path)) else: raise ValueError("Fail to create the new model.") # Save the current configurations config = dict(FLAGS.__flags.items()) with open("/".join([model_path, "config.json"]), "w") as file: json.dump(config, file) # initialize variables sess.run(tf.global_variables_initializer()) return model
def __init__(self, checkpoint_name, num_classes, num_input_features, max_epochs=100, lr=1e-2, weight_decay=5e-2): self.checkpoint_name = checkpoint_name self.checkpoint_dir = os.path.join(CHECKPOINT_DIR, self.checkpoint_name) if not os.path.exists(self.checkpoint_dir): os.makedirs(self.checkpoint_dir) self.max_epochs = max_epochs self.epoch = 0 self.lr = lr self.weight_decay = weight_decay self.num_classes = num_classes self.num_input_features = num_input_features self.model = LinearModel(num_classes=self.num_classes, num_input_features=self.num_input_features) self.loss_fn = nn.CrossEntropyLoss() self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr, amsgrad=True, weight_decay=weight_decay) # self.log_dir = os.path.join(LOG_DIR, self.checkpoint_name) self.log_writer = tensorboardX.SummaryWriter('logs/' + self.checkpoint_name) self.load_checkpoint('model.pt')
def train(args): os.makedirs(args.ckpt_dir, exist_ok=True) writer = SummaryWriter('log') dataloader = create_dataloader(args.train_data, args.batch_size, train=True) model = LinearModel(args.input_size) optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, betas=(args.b1, args.b2)) criterion = torch.nn.MSELoss() tqdm.write('[*] Start training') step = 0 epoch_bar = tqdm(range(args.n_epochs), desc='[Total Progress]', dynamic_ncols=True, leave=False, position=0) for epoch in epoch_bar: batch_bar = tqdm(dataloader, desc='[Train epoch {:2}]'.format(epoch), dynamic_ncols=True, leave=False, position=1) for i, data in enumerate(batch_bar): feature, label = data['feature'], data['label'] optimizer.zero_grad() #encoded, decoded = model(feature) pred = model(feature) loss = criterion(pred, label) loss.backward() optimizer.step() hitRate = hit_rate(pred, label) #hitRate = 0 if (step % 100 == 0): batch_bar.set_description('[Batch {}/{}] loss: {} hit_rate: {}'.format(i, len(dataloader), loss, hitRate)) writer.add_scalar('Loss', loss, step) if (step % args.save_fq == 0): save_path = os.path.join(args.ckpt_dir, '{}.ckpt'.format(step)) save_model(model, save_path) step += 1 tqdm.write('[*] Finish training') return
def create_model(sess, FLAGS, mode): model = LinearModel(FLAGS, mode) model.build() # initialize variables sess.run(tf.global_variables_initializer()) return model
def optimize(self, initial_weight, steps): w = initial_weight last_all_equal = False for i in range(steps): #if (last_all_equal): # sigma = sigma + 0.1 # print('New sigma is', sigma) #elif (sigma > initial_sigma): # sigma = sigma - 0.1 # print('New sigma is', sigma) N = np.random.randn(npop, LinearModel.weight_count) #N[0] = np.zeros((observation_size + 1) * action_size) # Always try the initial vector R = np.zeros(npop) F = np.zeros(npop) for j in range(npop): w_try = w + sigma * N[j] agent = LinearModel(w_try) R[j], actions, F[j], won = task.computeReward(agent, False) #print(R[j], w_try, j, i, summarize_actions(actions), won) #if (won): # _, _, _ = computeReward(agent, render=True) best_vector_index = np.argmax(R) if i % 100 == 0: reward, actions, frames, _ = task.computeReward( LinearModel(w + sigma * N[best_vector_index]), True) print(reward, frames, i, task.summarize_actions(actions)) print("break") mean = np.mean(R) #if (mean <= -10000): # Use frame count as the target function instead of the reward. # R = F # mean = np.mean(R) stdDev = np.std(R) if (stdDev == 0): print("All equal") if (won): task.close() break # Set a new random starting position #w = np.random.randn(LinearModel.weight_count) #last_all_equal = True else: last_all_equal = False A = (R - mean) / np.std(R) w = w + alpha / (npop * sigma) * np.dot(N.T, A) if ((i + 1) % 25 == 0): print("Mean", mean, won, i, repr(w)) else: dist = np.linalg.norm(w - initial_weight) print("Mean", mean, "Best", R[best_vector_index], won, dist, i) print(w) return w + sigma * N[best_vector_index], R[best_vector_index]
def load_model(sess, saved_path): class Config: def __init__(self, **entries): self.__dict__.update(entries) # Load configuration from trained model with open("/".join([saved_path, "config.json"]), "r") as file: saved = json.load(file) print ("Configuration recoverd:") pprint (saved) config = Config(**saved) if config.model == "vallina": model = LinearModel(config, "inference") model.build() else: pass # other model print ("Restore from previous results...") ckpt = tf.train.get_checkpoint_state(saved_path) if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path): print ("saved path: {}".format(saved_path)) model.restore(sess, saved_path) print ("Model reloaded from {}".format(ckpt.model_checkpoint_path)) else: raise ValueError("CAN NOT FIND CHECKPOINTS EXISTS!") return model
def __init__(self, state_size, action_size, seed, opts={}): """Initialise the agent Params ====== state_size (int): dimension of each state action_size (int): dimension of each action seed (int): Random seed opts (dict): optional settings BUFFER_SIZE (long): Max size for replay buffer BATCH_SIZE (int): Sample size of experiences from replay buffer GAMMA (float): discount factor TAU (float): soft update of target parameters LR (float): optimizer learning rate UPDATE_EVERY (int): how ofter to update the network """ self.state_size = state_size self.action_size = action_size self.seed = random.seed(seed) self.local_network = LinearModel(state_size, action_size, seed).to(device) self.fixed_network = LinearModel(state_size, action_size, seed).to(device) # Overwrite the default parameters self.buffer_size = opts['BUFFER_SIZE'] if 'BUFFER_SIZE' in opts else BUFFER_SIZE self.batch_size = opts['BATCH_SIZE'] if 'BATCH_SIZE' in opts else BATCH_SIZE self.gamma = opts['GAMMA'] if 'GAMMA' in opts else GAMMA self.tau = opts['TAU'] if 'TAU' in opts else TAU self.lr = opts['LR'] if 'LR' in opts else LR self.update_every = opts['UPDATE_EVERY'] if 'UPDATE_EVERY' in opts else UPDATE_EVERY self.optim = optim.Adam(self.local_network.parameters(), lr=self.lr) # Initialize replay buffer self.memory = ReplayBuffer(self.buffer_size, self.batch_size, seed) # Initialize time step (for updating every UPDATE_EVERY steps) self.t_step = 0 self.history = defaultdict(list)
def test(args): dataloader = create_dataloader(args.test_data, args.batch_size, train=False) model = LinearModel(args.input_size) load_model(model, os.path.join(args.ckpt_dir, '{}.ckpt'.format(args.step))) output_csv = open(args.test_output, 'w') output_writer = csv.writer(output_csv) output_writer.writerow(['building_id', 'total_price']) tqdm.write('[*] Start testing') step = 0 batch_bar = tqdm(dataloader, desc='[Testing]', dynamic_ncols=True, leave=False) for i, data in enumerate(batch_bar): id, feature, label = data['id'], data['feature'], data['label'] pred = model(feature) batch_bar.set_description('[Testing] [Batch {}/{}]'.format(i, len(dataloader))) for i, p in enumerate(pred): output_writer.writerow([id[i], p.item()]) #print(pred) tqdm.write('[*] Finish testing')
def grid_search(params_grid, X, Y, linear_model: LinearModel): linear_model_cv = GridSearchCV(linear_model.get_model(), params_grid, iid=False, cv=5) linear_model_cv.fit(X, Y) print("Best parameters set found on development set:") print() print(linear_model_cv.best_params_) print() print("Grid scores on development set:") print() means = linear_model_cv.cv_results_['mean_test_score'] stds = linear_model_cv.cv_results_['std_test_score'] for mean, std, params in zip(means, stds, linear_model_cv.cv_results_['params']): print("%0.3f (+/-%0.03f) for %r" % (mean, std * 2, params)) print() return linear_model_cv.best_params_
def main(): try: parser = parse.parseCV(cli.__version__) options, args = parser.parse_args() if len(args) < 1 or len(args) > 1: parser.error("Incorrect number of arguments. ") verbose = options.verbose fname = args[0] ds = MemoryDataset.load(fname, verbose=verbose) if len(ds.classes) > 2: model = GeneralizedLinearModel(ds.dim, len(ds.classes), biasterm=options.biasterm) else: model = LinearModel(ds.dim, biasterm=options.biasterm) if options.epochs == -1: options.epochs = math.ceil(10**6 / ((options.nfolds - 1) * (ds.n / options.nfolds))) print "epochs: ", options.epochs trainer = cli.create_trainer(options) print("%s %s" % ("Fold".ljust(5), "Error")) err = crossvalidation(ds, trainer, model, nfolds=options.nfolds, shuffle=options.shuffle, error=eval.errorrate, verbose=options.verbose, seed=options.seed) print("%s %s (%.2f)" % ("avg".ljust(5), ("%.2f" % np.mean(err)).rjust(5), np.std(err))) except Exception, exc: print "[ERROR] ", exc
from flask import flask from flask_restful import reqparse, abort, Api, Resource import pickle import numpy as np from model import LinearModel app = Flask(__name__) api = Api(app) model = LinearModel() clf_path = 'lib/models/LinearModel.pkl' with open(clf_path, 'rb') as f: model.clf = pickle.load(f) parser = reqparse.RequestParser() parser.add_argument('query') class PredictEnergy(Resource): def get(self): args = parser.parse_args() user_query = args['query'] uq_vectorized = model.vectorizer_transform( np.array([user_query])) prediction = model.predict(uq_vectorized)
use_canonical = args.use_canonical use_resnet50 = args.use_resnet50 use_2d_scale = args.use_2d_scale if exp_type == '2d3d': # 2D to 3D keypoint lifting using GT 2D pose if use_dataset == 'H36m': validation_dataset = H36MDataset(dataset_root, subset='test', without_image=True, use_pcl=use_pcl, \ calculate_scale_from_2d=use_2d_scale, use_slant_compensation=use_slant_compensation) else: # val_path = os.path.join(dataset_root, 'val') val_path = dataset_root validation_dataset = MpiInf3dDataset(val_path, without_image=True, use_pcl=use_pcl, \ calculate_scale_from_2d=use_2d_scale, use_slant_compensation=use_slant_compensation) model = model = LinearModel() model.to(device) model.apply(weight_init) else: if use_dataset == 'H36m': validation_dataset = H36MDataset(dataset_root, subset='test', without_image=False, use_pcl=use_pcl, \ calculate_scale_from_2d=use_2d_scale, use_slant_compensation=use_slant_compensation) if use_canonical: num_joints = 17 else: num_joints = 32 else: validation_dataset = MpiInf3dDataset(val_path, without_image=False, use_pcl=use_pcl, \
database = "../resources/database/bug_reports.db" database = path.abspath(database) sampler = Sampler.DbSampler(database, 'training_set', 'validation_set', 'test_set') # obtain training and test data X_train, y_train = sampler.getTrainingData() X_validation, y_validation = sampler.getValidationData() X_test, y_test = sampler.getTestData() cross_validation_k = 5 print('Using classic linear regression to evaluate...') regression = LinearModel.LinRegression(X_train, y_train, X_test, y_test, cross_validation_k) accuracy, f1_score, lin_reg_y_prediction, lin_reg_cv_score = regression.evaluate( ) print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score)) print('Using lasso linear regression to evaluate...') lasso_reg = LinearModel.LassoRegression(X_train, y_train, X_test, y_test, cross_validation_k) accuracy, f1_score, lasso_reg_y_prediction, lasso_reg_cv_score = lasso_reg.evaluate( alpha=0.5) print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score)) print('Using logistic regression to evaluate...') log_reg = LinearModel.LogisticRegression(X_train, y_train, X_test, y_test, cross_validation_k) accuracy, f1_score, log_reg_y_prediction, log_reg_cv_score = log_reg.evaluate(
def generate_embedding_model(text, y, batch_size=256, epochs=100, save=True, dim=200, val_split=0.2): # Preprocessing #MAX_SEQUENCE_LENGTH = len(max(text, key=lambda i: len(i))) + 1 MAX_SEQUENCE_LENGTH = 335 texts = [''.join(x) for x in text] # finally, vectorize the text samples into a 2D integer tensor tokenizer = Tokenizer() tokenizer.fit_on_texts(texts) sequences = tokenizer.texts_to_sequences(texts) word_index = tokenizer.word_index print('Found %s unique tokens.' % len(word_index)) data = pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH) labels = to_categorical(np.asarray(y)) print('Shape of data tensor:', data.shape) print('Shape of label tensor:', labels.shape) num_words = len(word_index) + 1 # split the data into a training set and a validation set indices = np.arange(data.shape[0]) np.random.shuffle(indices) data = data[indices] labels = labels[indices] num_validation_samples = int(val_split * data.shape[0]) x_train = data[:-num_validation_samples] y_train = labels[:-num_validation_samples] x_val = data[-num_validation_samples:] y_val = labels[-num_validation_samples:] emb = get_skipgram_embedding_matrix(text, epochs=1) emb = np.expand_dims(emb, 1) emb_train = emb[:-num_validation_samples] emb_val = emb[-num_validation_samples:] # Build model MAX_SEQUENCE_LENGTH = len(max(text, key=lambda i: len(i))) + 1 # sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32',name="embedding_input") # # glove_embedding_layer = Embedding(num_words, # dim, # weights=[get_glove_embedding_matrix(word_index, dim)], # input_length=MAX_SEQUENCE_LENGTH, # trainable=False)(sequence_input) # # skipgram_embedding_layer = Embedding(num_words, # dim, # weights=[get_skipgram_embedding_matrix(texts, dim)], # input_length=MAX_SEQUENCE_LENGTH, # trainable=False)(sequence_input) # # # skipgram_embedding = Input(shape=(1,dim,),name="skipgram_input") # # # own_embedding_layer = Embedding(num_words, # dim, # #embeddings_initializer=Constant(get_skipgram_embedding_matrix(text, epochs=1)), # #weights=get_skipgram_embedding_matrix(text, epochs=1), # input_length=MAX_SEQUENCE_LENGTH, # trainable=True)(sequence_input) # # combined = keras.backend.stack([glove_embedding_layer, skipgram_embedding_layer, own_embedding_layer], axis=3) # # #x = Conv2D(128, 5, activation='relu')(combined) # #x = MaxPooling2D(5)(x) # #x = Conv2D(128, 5, activation='relu')(x) # #x = MaxPooling2D(5)(x) # #x = Conv2D(128, 5, activation='relu')(x) # #x = GlobalMaxPooling2D()(x) # #x = Dense(128, activation='relu')(x) # x = DenseNet121(include_top=False, weights="imagenet", input_shape = (MAX_SEQUENCE_LENGTH, dim, 3))(combined) # x = GlobalAveragePooling2D()(x) # preds = Dense(3, activation='softmax')(x) # # model = Model(inputs=sequence_input, outputs=preds) # model.compile(loss='categorical_crossentropy', # optimizer='rmsprop', # metrics=['acc']) # # model.summary() # plot_model(model, to_file='model_combined.png') # # # Train model # model.fit(x_train, y_train, # batch_size=batch_size, # epochs=epochs, # validation_data=(x_val, y_val)) # Get glove and skipgram embedding matrices glove = get_glove_embedding_matrix(word_index, dim) #TODO: anpassen skipgram = get_skipgram_embedding_matrix(texts, dim) #TODO: anpassen # Get Model model = LinearModel(embedding_matrix_gl=glove, embedding_matrix_sg=skipgram, number_class=3) if save: model.save("data/sentqs_full.h5") return model
def main(opt): start_epoch = 0 acc_best = 0. glob_step = 0 lr_now = opt.lr # save options log.save_options(opt, opt.ckpt) tb_logdir = f'./exp/{opt.name}' if os.path.exists(tb_logdir): shutil.rmtree(tb_logdir) writer = SummaryWriter(log_dir=f'./exp/{opt.name}') exp_dir_ = dirname(opt.load) # create model print(">>> creating model") # TODO: This is how to avoid weird data reshaping for non-3-channel inputs. # Have ResNet model take in grayscale rather than RGB # model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) if opt.arch == 'cnn': model = ResNet(BasicBlock, [2, 2, 2, 2], num_classes=opt.num_classes) else: model = LinearModel() model = model.cuda() model.apply(weight_init) print(">>> total params: {:.2f}M".format( sum(p.numel() for p in model.parameters()) / 1000000.0)) criterion = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr) # load ckpt if opt.load: print(">>> loading ckpt from '{}'".format(opt.load)) ckpt = torch.load(opt.load) start_epoch = ckpt['epoch'] acc_best = ckpt['acc'] glob_step = ckpt['step'] lr_now = ckpt['lr'] model.load_state_dict(ckpt['state_dict']) optimizer.load_state_dict(ckpt['optimizer']) print(">>> ckpt loaded (epoch: {} | acc: {})".format( start_epoch, acc_best)) if opt.resume: logger = log.Logger(os.path.join(opt.ckpt, 'log.txt'), resume=True) else: logger = log.Logger(os.path.join(opt.ckpt, 'log.txt')) logger.set_names([ 'epoch', 'lr', 'loss_train', 'err_train', 'acc_train', 'loss_test', 'err_test', 'acc_test' ]) transforms = [ ToTensor(), ] train_datasets = [] for dataset_name in opt.train_datasets: train_datasets.append( ClassificationDataset(name=dataset_name, num_kpts=opt.num_kpts, transforms=transforms, split='train', arch=opt.arch, gt=opt.gt)) train_dataset = ConcatDataset(train_datasets) train_loader = DataLoader(train_dataset, batch_size=opt.train_batch, shuffle=True, num_workers=opt.job) split = 'test' if opt.test else 'valid' test_dataset = ClassificationDataset(name=opt.test_dataset, num_kpts=opt.num_kpts, transforms=transforms, split=split, arch=opt.arch, gt=opt.gt) test_loader = DataLoader(test_dataset, batch_size=opt.test_batch, shuffle=False, num_workers=opt.job) subset_loaders = {} for subset in test_dataset.create_subsets(): subset_loaders[subset.split] = DataLoader(subset, batch_size=opt.test_batch, shuffle=False, num_workers=opt.job) cudnn.benchmark = True for epoch in range(start_epoch, opt.epochs): torch.cuda.empty_cache() print('==========================') print('>>> epoch: {} | lr: {:.5f}'.format(epoch + 1, lr_now)) if not opt.test: glob_step, lr_now, loss_train, err_train, acc_train = \ train(train_loader, model, criterion, optimizer, num_kpts=opt.num_kpts, num_classes=opt.num_classes, lr_init=opt.lr, lr_now=lr_now, glob_step=glob_step, lr_decay=opt.lr_decay, gamma=opt.lr_gamma, max_norm=opt.max_norm) loss_test, err_test, acc_test, auc_test, prec_test = \ test(test_loader, model, criterion, num_kpts=opt.num_kpts, num_classes=opt.num_classes, batch_size=opt.test_batch) ## Test subsets ## subset_losses = {} subset_errs = {} subset_accs = {} subset_aucs = {} subset_precs = {} subset_openpose = {} subset_missing = {} subset_grids = {} if len(subset_loaders) > 0: bar = Bar('>>>', fill='>', max=len(subset_loaders)) for key_idx, key in enumerate(subset_loaders): loss_sub, err_sub, acc_sub, auc_sub, prec_sub = test( subset_loaders[key], model, criterion, num_kpts=opt.num_kpts, num_classes=opt.num_classes, batch_size=4, log=False) subset_losses[key] = loss_sub subset_errs[key] = err_sub subset_accs[key] = acc_sub subset_aucs[key] = auc_sub subset_precs[key] = prec_sub sub_dataset = subset_loaders[key].dataset if sub_dataset.gt_paths is not None: gt_X = load_gt(sub_dataset.gt_paths) subset_openpose[key] = mpjpe_2d_openpose(sub_dataset.X, gt_X) subset_missing[key] = mean_missing_parts(sub_dataset.X) else: subset_openpose[key] = 0. subset_missing[key] = 0. sample_idxs = extract_tb_sample(subset_loaders[key], model, batch_size=opt.test_batch) sample_X = sub_dataset.X[sample_idxs] sample_img_paths = [sub_dataset.img_paths[x] for x in sample_idxs] if opt.arch == 'cnn': subset_grids[key] = create_grid(sample_X, sample_img_paths) bar.suffix = f'({key_idx+1}/{len(subset_loaders)}) | {key}' bar.next() if len(subset_loaders) > 0: bar.finish() ################### if opt.test: subset_accs['all'] = acc_test subset_aucs['all'] = auc_test subset_precs['all'] = prec_test report_dict = { 'acc': subset_accs, 'auc': subset_aucs, 'prec': subset_precs } report_idx = 0 report_path = f'report/{opt.name}-{report_idx}.json' while os.path.exists(f'report/{opt.name}-{report_idx}.json'): report_idx += 1 report_path = f'report/{opt.name}-{report_idx}.json' print(f'>>> Saving report to {report_path}...') with open(report_path, 'w') as acc_f: json.dump(report_dict, acc_f, indent=4) print('>>> Exiting (test mode)...') break # update log file logger.append([ epoch + 1, lr_now, loss_train, err_train, acc_train, loss_test, err_test, acc_test ], [ 'int', 'float', 'float', 'float', 'float', 'float', 'float', 'float' ]) # save ckpt is_best = acc_test > acc_best acc_best = max(acc_test, acc_best) if is_best: log.save_ckpt( { 'epoch': epoch + 1, 'lr': lr_now, 'step': glob_step, 'acc': acc_best, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict() }, ckpt_path=opt.ckpt, is_best=True) else: log.save_ckpt( { 'epoch': epoch + 1, 'lr': lr_now, 'step': glob_step, 'acc': acc_best, 'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict() }, ckpt_path=opt.ckpt, is_best=False) writer.add_scalar('Loss/train', loss_train, epoch) writer.add_scalar('Loss/test', loss_test, epoch) writer.add_scalar('Error/train', err_train, epoch) writer.add_scalar('Error/test', err_test, epoch) writer.add_scalar('Accuracy/train', acc_train, epoch) writer.add_scalar('Accuracy/test', acc_test, epoch) for key in subset_losses: writer.add_scalar(f'Loss/Subsets/{key}', subset_losses[key], epoch) writer.add_scalar(f'Error/Subsets/{key}', subset_errs[key], epoch) writer.add_scalar(f'Accuracy/Subsets/{key}', subset_accs[key], epoch) writer.add_scalar(f'OpenPose/Subsets/{key}', subset_openpose[key], epoch) writer.add_scalar(f'Missing/Subsets/{key}', subset_missing[key], epoch) if opt.arch == 'cnn': writer.add_images(f'Subsets/{key}', subset_grids[key], epoch, dataformats='NHWC') logger.close() writer.close()
def trainLinear(maxiter=20, wp=(6 * 5, 6 * 1), lamuda=0.00, printOut=True): class SCADADataset(Dataset): # +jf33N train together def __init__(self, name): filename = 'dataGW' + name with open(filename, 'rb') as f: self.dataH, self.dataT = pickle.load(f) def __len__(self): return self.dataH.shape[0] def __getitem__(self, idx): x = np.copy(self.dataH[idx, :]) x = torch.from_numpy(x).float() y = np.copy(self.dataT[idx]) y = torch.from_numpy(y).float() return x, y windL, predL = wp (inputD, outD) = (windL, predL) batch_size = 512 lr = 2e-4 weight_decay = 0.0000 print(' lr: ', lr, ' weight_decay: ', weight_decay, ' windL: ', windL, ' predL: ', predL, ' batch_size: ', batch_size, ' inputD: ', inputD, ' outD: ', outD, ' lamuda:', lamuda) epochs = maxiter start_epoch = 0 loadModel = False outf = r'C:\YANG Luoxiao\Model\WindSpeed' model = LinearModel(inputD, outD).to(device) optimizer = optim.Adam(list(model.parameters()), lr=lr, weight_decay=weight_decay) scheduler = ReduceLROnPlateau(optimizer, 'min', patience=20, verbose=True) minloss = 10 # if loadModel: # checkpoint = torch.load('%s/%s%d.pth' % (outf, "LSTMMutiTS4Best", num)) # largeNew5 Large5 # model.load_state_dict(checkpoint['model']) # # D.load_state_dict(checkpoint['D']) # optimizer.load_state_dict(checkpoint['optimizer']) # # optimizerD.load_state_dict(checkpoint['optimizerD']) # start_epoch = num scadaTrainDataset = SCADADataset(name='Train') dataloader = torch.utils.data.DataLoader(scadaTrainDataset, batch_size=batch_size, shuffle=True, num_workers=int(0)) scadaValDataset = SCADADataset(name='Val') dataloaderVAl = torch.utils.data.DataLoader(scadaValDataset, batch_size=5000, shuffle=True, num_workers=int(0)) lossTrain = np.zeros(([1, 1])) lossVal = np.zeros(([1, 1])) acc = np.zeros(([1, 1])) for epoch in range(start_epoch, start_epoch + epochs): model.train() for i, (x, y) in enumerate(dataloader): optimizer.zero_grad() # y = y.to(torch.long) x = x.to(device).view(x.shape[0], -1) y = y.to(device=device, dtype=torch.int64).view(-1) ypred = model(x) # y=y.long() # l1loss=l1Norm(model) # loss=F.mse_loss(tgt_y* 25.55 + 0.4, tgtpred* 25.55 + 0.4) loss = F.cross_entropy(ypred, y) loss.backward() lossTrain = np.vstack( (lossTrain, loss.detach().cpu().numpy().reshape((-1, 1)))) optimizer.step() model.eval() c = 0 loss = 0 accucry = 0 with torch.no_grad(): for p, (x, y) in enumerate(dataloaderVAl): # if p>10: # break c += 1 x = x.to(device).view(x.shape[0], -1) y = y.to(device=device, dtype=torch.int64).view(-1) ypred = model(x) loss += F.cross_entropy(ypred, y) predict = torch.argmax(ypred, dim=1) accucry += torch.sum(predict == y) # break lengA = len(scadaValDataset) accucry = accucry.cpu().numpy() accucry = accucry / lengA lossVal = np.vstack((lossVal, (loss / c).cpu().numpy().reshape( (-1, 1)))) acc = np.vstack((acc, accucry.reshape((-1, 1)))) model.train() # # break if printOut: if (i) % 2000 == 0: print('[%d/%d][%d/%d]\tLoss: %.4f\t ' % (epoch, start_epoch + epochs, i, len(dataloader), loss)) model.eval() c = 0 loss = 0 accucry = 0 with torch.no_grad(): for l, (x, y) in enumerate(dataloaderVAl): c += 1 x = x.to(device).view(x.shape[0], -1) y = y.to(device=device, dtype=torch.int64).view(-1) ypred = model(x) loss += F.cross_entropy(ypred, y) predict = torch.argmax(ypred, dim=1) accucry += torch.sum(predict == y) lengA = len(scadaValDataset) accucry = accucry.cpu().numpy() accucry = accucry / lengA if printOut: print('VAL loss= ', loss / c, ' VAL accucry ', accucry) scheduler.step(loss / c) if minloss > (loss / c): state = { 'model': model.state_dict(), 'optimizer': optimizer.state_dict(), 'epoch': epoch } if lamuda == 0: torch.save(state, '%s/GWRLLinearWT%d.pth' % (outf, int(predL / 6))) else: torch.save(state, '%s/RLlassoWT%d.pth' % (outf, int(predL / 6))) minloss = loss / c # minmapeloss=lossm/ c if printOut: print('bestaccucry: ', accucry) return lossTrain[1:, :], lossVal[1:, :], acc[1:, :]
class Trainer: def __init__(self, checkpoint_name, num_classes, num_input_features, max_epochs=100, lr=1e-2, weight_decay=5e-2): self.checkpoint_name = checkpoint_name self.checkpoint_dir = os.path.join(CHECKPOINT_DIR, self.checkpoint_name) if not os.path.exists(self.checkpoint_dir): os.makedirs(self.checkpoint_dir) self.max_epochs = max_epochs self.epoch = 0 self.lr = lr self.weight_decay = weight_decay self.num_classes = num_classes self.num_input_features = num_input_features self.model = LinearModel(num_classes=self.num_classes, num_input_features=self.num_input_features) self.loss_fn = nn.CrossEntropyLoss() self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr, amsgrad=True, weight_decay=weight_decay) # self.log_dir = os.path.join(LOG_DIR, self.checkpoint_name) self.log_writer = tensorboardX.SummaryWriter('logs/' + self.checkpoint_name) self.load_checkpoint('model.pt') def train(self, train_dataset, test_dataset, batch_size, eval_batch_size): train_data_loader = data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, drop_last=True) test_data_loader = data.DataLoader(test_dataset, batch_size=eval_batch_size, shuffle=False, drop_last=False) start_epoch = self.epoch print("Training...\n") for epoch in range(start_epoch, self.max_epochs): self.epoch += 1 self.train_step(train_data_loader) train_acc = self.evaluate_step(train_data_loader) test_acc = self.evaluate_step(test_data_loader) self.log_writer.add_scalars('accuracy', { 'test': test_acc, 'train': train_acc }, self.epoch) if self.epoch % 20 == 0: print("===== Epoch {} =====".format(self.epoch)) print('test-acc: {0}\ttrain acc: {1}'.format( test_acc, train_acc)) def train_step(self, train_data_loader): self.model.train() epoch_losses = list() for (features, labels) in train_data_loader: # print(features.shape) self.optimizer.zero_grad() predictions = self.model(features) loss = self.loss_fn(predictions, labels.long().view(-1)) loss.backward() self.optimizer.step() epoch_losses.append(loss.item()) self.save_checkpoint('model.pt') self.log_writer.add_scalar('loss', np.mean(epoch_losses), self.epoch) def evaluate_step(self, test_data_loader): self.model.eval() num_correct = 0 num_data = 0 with torch.no_grad(): for (features, labels) in test_data_loader: predictons = self.model(features) predictions = torch.argmax( predictons, dim=1) # take the argmax over the class dimension N x C is_correct = torch.eq(predictions.view(-1), labels.long().view(-1)).int() num_correct += torch.sum(is_correct).item() num_data += labels.size(0) accuracy = num_correct / num_data return accuracy def save_checkpoint(self, filename): checkpoint_filepath = os.path.join(self.checkpoint_dir, filename) torch.save( { 'epoch': self.epoch, 'model': self.model.state_dict(), 'optim': self.optimizer.state_dict() }, checkpoint_filepath) def load_checkpoint(self, filename): checkpoint_filepath = os.path.join(self.checkpoint_dir, filename) if os.path.exists(checkpoint_filepath): checkpoint = torch.load(checkpoint_filepath) self.epoch = checkpoint['epoch'] self.model.load_state_dict(checkpoint['model']) self.optimizer.load_state_dict(checkpoint['optim']) print("Loaded checkpoint") else: print("Checkpoint not found, continuing...")
def evaluate_model_on_train(title, model_name, preprocessing, data, results_df: pd.DataFrame, model: LinearModel, verbose=cfg.verbose, visualize=True): """ Cross-validation, split train data frame to equally sized val and train data sets and evaluate R2 adjusted and RMSE :param title: name of experiment to be saved in results data frame :param model_name: name of linear model used in experiment :param preprocessing: type of postprocessing, if a massive change is preformed please write down in short what the postprocessing includes(like normal) :param data: train data frame with SalePrice given :param results_df: where to put the result of the experiment :param model: model that implements the LinearModel interface :param verbose: to print the results on console :return: """ print( "------------------ Training on train and CV on Train ------------------" ) X, Y = data if visualize: X_train, X_val, Y_train, Y_val = split_data(X, Y) model.model_fit(X_train, Y_train) y_val_pred = model.predict(X_val) plt.figure() sns.residplot(y_val_pred, Y_val, lowess=True, color="b") plt.xlabel("Fitted values") plt.ylabel("Residuals") plt.title(model_name) plt.savefig(cfg.visualization_dir + "/Residuals_{}".format(model_name)) print("------------------ Evaluating on Train ------------------") model.model_fit(X, Y) train_rmse, train_R2_adjusted = model.model_eval(X, Y, False) rmse_cv_score = np.sqrt( np.abs( cross_val_score(model.get_model(), X, Y, cv=5, scoring='neg_mean_squared_error'))) R2_cv_score = cross_val_score(model.get_model(), X, Y, cv=5, scoring='r2') if verbose: print("train: \n rmse: {}, R2_adj: {}".format(train_rmse, train_R2_adjusted)) print("cross validation rmse score: {} (+/- {}".format( rmse_cv_score.mean(), rmse_cv_score.std() * 2)) print("cross validation r2 score: {} (+/- {}".format( R2_cv_score.mean(), R2_cv_score.std() * 2)) results = [ build_result_line(title, 'train', model_name, preprocessing, train_rmse, train_R2_adjusted), build_result_line(title, 'val', model_name, preprocessing, rmse_cv_score.mean(), R2_cv_score.mean()) ] if title in results_df['title'].values: print( "Warning: Overwriting previous experiement due to colliding title") user_input = over_write_or_exit_from_usr() if user_input == 'e': print("not saving results, existing....") exit() if user_input == 'd': print("deleting previous results, existing....") criteria = results_df['title'].values != title results_df = results_df[criteria] results_df.to_pickle(path=cfg.results_df) results_df.to_csv(path_or_buf=cfg.results_path, index=False) exit() criteria = results_df['title'].values != title results_df = results_df[criteria] results_df = results_df.append( pd.DataFrame(results, columns=[ 'title', 'dataset', 'model_name', 'preprocessing', 'rmse', 'R2_adjusted' ])) results_df.to_pickle(path=cfg.results_df) results_df.to_csv(path_or_buf=cfg.results_path, index=False)
def run_manual(): w = [] final_reward, actions, _ = computeReward(LinearModel(w), True) print("Final reward = ", final_reward, task.summarize_actions(actions))
Y_data[1] = 100.0 Y_data[-5] = 100.0 Y_data = Y_data.reshape((-1,1)) X_test = 3.2*np.ones((1,1)) Y_test = true_function(X_test, noise=False) num_train_points = X_data.shape[0] tf.reset_default_graph() x = tf.placeholder(dtype=tf.float32, shape=(None, 1)) y_true = tf.placeholder(dtype=tf.float32, shape=(None, 1)) model = LinearModel(x, y_true) train_op = model.optimize loss_op = model.error param_op = model.params gradient_op = model.gradients hessian_op = model.hessians init_op = tf.global_variables_initializer() with tf.Session() as sess: sess.run(init_op) for e in range(EPOCHS):
#encoding=utf-8 import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim from utils import accuracy, makedata from model import LinearModel, RandomTree, HufTree import time chose_features, chose_labels, chose_weight_dict, idx_train, idx_val, idx_test = makedata( ) l_model = LinearModel(chose_features.shape[1], 7) r_model = RandomTree(chose_features.shape[1], 8, 7, chose_weight_dict, 0.2) h_model = HufTree(chose_features.shape[1], 8, 7, chose_weight_dict, 0.2) optimer1 = optim.Adam(l_model.parameters(), lr=0.01, weight_decay=1e-5) optimer2 = optim.Adam(r_model.parameters(), lr=0.01, weight_decay=1e-5) optimer3 = optim.Adam(h_model.parameters(), lr=0.01, weight_decay=1e-5) def train(epoch): t = time.time() optimer1.zero_grad() optimer2.zero_grad() optimer3.zero_grad() output1 = l_model(chose_features) output2 = r_model(chose_features) output3 = h_model(chose_features) loss_train1 = F.nll_loss(output1[idx_train], chose_labels[idx_train])
parser.add_argument('--visualize', '-v', action='store_true', help='Visualize training progress') parser.add_argument( '--batchsize', '-b', default=1000, type=int, help='Batch size for training the network (default: %(default)s)') args = parser.parse_args() np.random.seed(args.seed) loss = L2Loss() model = LinearModel(widths=[2, 12, 32, 12, 2], lr=0.01, loss=loss) optimizer = None if args.optimizer == 'ibfgs': optimizer = InverseBFGS(nparams=model.nparams, gamma=0.0001, eta=0.9) elif args.optimizer == 'bfgs': optimizer = BFGS(nparams=model.nparams, gamma=0.0001, eta=0.9) elif args.optimizer == 'armijo': optimizer = DescentMethod(nparams=model.nparams, beta=1 / 2, gamma=0.0001) elif args.optimizer == 'bbv1' or args.optimizer == 'barzilaiborweinv1': optimizer = BarzilaiBorwein(nparams=model.nparams, beta=1 / 2, gamma=0.0001, strategy='v1') elif args.optimizer == 'bbv2' or args.optimizer == 'barzilaiborweinv2': optimizer = BarzilaiBorwein(nparams=model.nparams,
class DQNAgent(): """Implementation of DQN""" def __init__(self, state_size, action_size, seed, opts={}): """Initialise the agent Params ====== state_size (int): dimension of each state action_size (int): dimension of each action seed (int): Random seed opts (dict): optional settings BUFFER_SIZE (long): Max size for replay buffer BATCH_SIZE (int): Sample size of experiences from replay buffer GAMMA (float): discount factor TAU (float): soft update of target parameters LR (float): optimizer learning rate UPDATE_EVERY (int): how ofter to update the network """ self.state_size = state_size self.action_size = action_size self.seed = random.seed(seed) self.local_network = LinearModel(state_size, action_size, seed).to(device) self.fixed_network = LinearModel(state_size, action_size, seed).to(device) # Overwrite the default parameters self.buffer_size = opts['BUFFER_SIZE'] if 'BUFFER_SIZE' in opts else BUFFER_SIZE self.batch_size = opts['BATCH_SIZE'] if 'BATCH_SIZE' in opts else BATCH_SIZE self.gamma = opts['GAMMA'] if 'GAMMA' in opts else GAMMA self.tau = opts['TAU'] if 'TAU' in opts else TAU self.lr = opts['LR'] if 'LR' in opts else LR self.update_every = opts['UPDATE_EVERY'] if 'UPDATE_EVERY' in opts else UPDATE_EVERY self.optim = optim.Adam(self.local_network.parameters(), lr=self.lr) # Initialize replay buffer self.memory = ReplayBuffer(self.buffer_size, self.batch_size, seed) # Initialize time step (for updating every UPDATE_EVERY steps) self.t_step = 0 self.history = defaultdict(list) def act(self, state, eps): """Returns the action for specified state Params ====== state (array_like): environment state eps (float): epsilon, to use in greedy-policy """ if random.random() < eps: return random.choice(range(self.action_size)) else: # convert the state to tensor state = torch.from_numpy(state).float().unsqueeze(0).to(device) # change network into evaluation mode with no gradients self.local_network.eval() with torch.no_grad(): action_values = self.local_network(state) # change network back to training mode self.local_network.train() return np.argmax(action_values.cpu().data.numpy()) def step(self, state, action, reward, next_state, done): """Collects experience and learns from experience Params ====== state (array_like): environment state (S) action (int): action taken on state (A) reward (float): reward (R) received by taking action A in state S next_state (array_like): environment state (S') received after taking action A in state S done (boolean): whether the episode ended after taking action A in state S """ self.memory.add(state, action, reward, next_state, done) self.t_step += 1 if self.t_step % self.update_every == 0: if len(self.memory) > self.batch_size: experiences = self.memory.sample() self.learn(experiences, self.gamma) def learn(self, experiences, gamma): """Use experience to learn from it Params ====== experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples gamma (float): discount factor """ # logger.debug('learn gamma: {}'.format(gamma)) states, actions, rewards, next_states, dones = experiences Q_next = self.fixed_network(next_states).detach().max(1)[0].unsqueeze(1) Q_target = rewards + (gamma * Q_next * (1 - dones)) Q_estimates = self.local_network(states).gather(1, actions) loss = F.mse_loss(Q_estimates, Q_target) self.history['loss'].append(loss.item()) # logger.debug('Loss: {}'.format(loss.item())) self.optim.zero_grad() loss.backward() self.optim.step() # Update fixed network self.update_fixed_network(self.local_network, self.fixed_network, self.tau) def update_fixed_network(self, local_model, target_model, tau): """Updates fixed target network weights using following: target = tau * target_model weights + (1 - tau) * local_model weights Params ====== local_model (Pytorch model): source model to copy weights from target_model (Pytorch model): target model to copy weights to tau (float): decide how much weight to apply when updating weights """ for target_weights, local_weights in zip(target_model.parameters(), local_model.parameters()): target_weights.data.copy_(tau * target_weights + (1 - tau) * local_weights) def save(self, filename): """Save local model parameters Params ====== filename (string): filename """ torch.save(self.local_network.state_dict(), filename)
def main(): try: parser = parse.parseSB(__version__) options, args = parser.parse_args() if len(args) < 1 or len(args) > 1: parser.error("incorrect number of arguments (`--help` for help).") if options.test_only and not options.model_file: parser.error("option -m is required for --test-only.") if options.test_only and options.test_file: parser.error("options --test-only and -t are mutually exclusive.") verbose = options.verbose data_file = args[0] dtrain = MemoryDataset.load(data_file, verbose = verbose) if not options.test_only: if verbose > 0: print("---------") print("Training:") print("---------") if len(dtrain.classes) > 2: model = GeneralizedLinearModel(dtrain.dim,len(dtrain.classes), biasterm = options.biasterm) else: model = LinearModel(dtrain.dim, biasterm = options.biasterm) trainer = create_trainer(options) if isinstance(trainer, (OVA,MaxentSGD,AveragedPerceptron)): if not isinstance(model, GeneralizedLinearModel): raise ValueError("Multi-class classifiers "\ "require > 2 classes. ") else: if isinstance(model, GeneralizedLinearModel): raise ValueError("%s cannot be used "\ "for multi-class problems." % str(trainer)) trainer.train(model,dtrain,verbose = verbose, shuffle = options.shuffle) if options.computetrainerror: test_model(model, dtrain, text="Training error") if options.model_file: f = open(options.model_file, 'w+') try: pickle.dump(model,f) finally: f.close() if options.test_file: dtest = MemoryDataset.load(options.test_file, verbose = verbose) if options.prediction_file: write_predictions(model, dtest, options.prediction_file) else: test_model(model, dtest) else: model = None f = open(options.model_file, 'r') try: model = pickle.load(f) finally: f.close() if not model: raise Exception("cannot deserialize "\ "model in '%s'. " % options.model_file) if options.prediction_file: write_predictions(model, dtrain, options.prediction_file) else: test_model(model, dtrain) except Exception, exc: print "[ERROR] ", exc
def trainLinear(maxiter=20, wp=(6 * 5, 6 * 1), lamuda=0.00, printOut=True, k0=10, t=4): class SCADADataset(Dataset): # +jf33N train together def __init__(self, name): filename = 'dataTW10' + name with open(filename, 'rb') as f: self.dataH, self.dataT = pickle.load(f) kMeans = KMeans(k0).fit(self.dataH) self.labels = kMeans.labels_ def __len__(self): return self.dataH.shape[0] def __getitem__(self, idx): x = np.copy(self.dataH[idx, :]) x = torch.from_numpy(x).float() lb = self.labels[idx] y = np.copy(self.dataT[idx]) # y = torch.from_numpy(y).float() return x, y, lb windL, predL = wp (inputD, outD) = (windL, predL) batch_size = 1024 lr = 2e-4 weight_decay = 0.0000 print(' lr: ', lr, ' weight_decay: ', weight_decay, ' windL: ', windL, ' predL: ', predL, ' batch_size: ', batch_size, ' inputD: ', inputD, ' outD: ', outD, ' lamuda:', lamuda) epochs = maxiter start_epoch = 0 loadModel = False outf = r'C:\YANG Luoxiao\Model\WindSpeed' model = LinearModel(inputD, outD).to(device) optimizer = optim.Adam(list(model.parameters()), lr=lr, weight_decay=weight_decay) scheduler = ReduceLROnPlateau(optimizer, 'min', patience=20, verbose=True) minloss = 10 # if loadModel: # checkpoint = torch.load('%s/%s%d.pth' % (outf, "LSTMMutiTS4Best", num)) # largeNew5 Large5 # model.load_state_dict(checkpoint['model']) # # D.load_state_dict(checkpoint['D']) # optimizer.load_state_dict(checkpoint['optimizer']) # # optimizerD.load_state_dict(checkpoint['optimizerD']) # start_epoch = num scadaTrainDataset = SCADADataset(name='Train') dataloader = torch.utils.data.DataLoader(scadaTrainDataset, batch_size=batch_size, shuffle=True, num_workers=int(0)) scadaValDataset = SCADADataset(name='Val') dataloaderVAl = torch.utils.data.DataLoader(scadaValDataset, batch_size=1024, shuffle=True, num_workers=int(0)) lossTrain = np.zeros(([1, 1])) lossVal = np.zeros(([1, 1])) acc = np.zeros(([1, 1])) for epoch in range(start_epoch, start_epoch + epochs): model.train() ckD = {} for kk in range(k0): ckD[kk] = 0 lossTotal = 0 for i, (x, y, lb) in enumerate(dataloader): loss1 = 0 loss2 = 0 loss3 = 0 optimizer.zero_grad() # y = y.to(torch.long) x = x.to(device).view(x.shape[0], -1) y = y.to(device=device, dtype=torch.int64).view(-1) gh = model(x) for kk in range(k0): ghk = gh[lb == kk, :] if ghk.shape[0] == 0: ckD[kk] = torch.zeros((windL)).to(device) # k=k0-1 continue ckD[kk] = torch.sum(ghk, dim=0) / (ghk.shape[0]) / (i + 1) loss1 += F.mse_loss(ghk, ckD[kk]) for kkk in range(k0): for kkkk in range(kkk, k0): loss2 += torch.sum((ckD[kkk] - ckD[kkkk])**2) for tt in range(t): ght = gh[y == tt, :] if ght.shape[0] < 2: continue loss3 += torch.sum((ght[0, :] - ght[1, :])**2) # y=y.long() # l1loss=l1Norm(model) loss1 /= k0 loss2 /= (k0 * (k0 + 1) / 2) loss3 /= t # loss=F.mse_loss(tgt_y* 25.55 + 0.4, tgtpred* 25.55 + 0.4) loss = loss1 + loss2 + loss3 loss.backward() lossTrain = np.vstack( (lossTrain, loss.detach().cpu().numpy().reshape((-1, 1)))) optimizer.step() model.eval() trans = np.zeros((k0, t)) gh = model( torch.from_numpy(scadaTrainDataset.dataH).float().to( device)).detach().cpu().numpy() kMeans = KMeans(k0).fit(gh) scadaTrainDataset.labels = kMeans.labels_ for b in range(k0): tk0 = scadaTrainDataset.dataT[scadaTrainDataset.labels == b] for bb in range(t): trans[b, bb] = np.sum(tk0 == bb) / len(tk0) # print(trans) classP = np.argmax(trans, axis=1) c = 0 accucry = 0 with torch.no_grad(): for p, (x, y, lb) in enumerate(dataloaderVAl): # if p>10: # break c += 1 x = x.numpy() labx = kMeans.predict(x) pry = classP[labx] y = y.view(-1).numpy() # predict=torch.argmax(ypred,dim=1) accucry += np.sum(pry == y) lengA = len(scadaValDataset) # accucry = accucry.cpu().numpy() accucry = accucry / lengA # lossVal = np.vstack((lossVal, (loss/c).cpu().numpy().reshape((-1, 1)))) acc = np.vstack((acc, accucry.reshape((-1, 1)))) model.train() # # break if printOut: if (i) % 20 == 0: print('[%d/%d][%d/%d]\tLoss: %.4f\t ' % (epoch, start_epoch + epochs, i, len(dataloader), loss)) # model.eval() # trans = np.zeros((k0, t)) # gh = model(torch.from_numpy(scadaTrainDataset.dataH).float().to(device)).detach().cpu().numpy() # kMeans = KMeans(k0).fit(gh) # scadaTrainDataset.labels = kMeans.labels_ # for b in range(k0): # tk0 = scadaTrainDataset.dataT[scadaTrainDataset.labels == b] # for bb in range(t): # trans[b, bb] = np.sum(tk0 == bb) / len(tk0) # print(trans) # classP=np.argmax(trans,axis=1) # c=0 # loss = 0 # accucry=0 # with torch.no_grad(): # for l, (x,y,lb) in enumerate(dataloaderVAl): # c += 1 # x = x.numpy() # labx=kMeans.predict(x) # pry=classP[labx] # y = y.view(-1).numpy() # # # predict=torch.argmax(ypred,dim=1) # accucry+=np.sum(pry==y) # lengA=len(scadaValDataset) # # accucry=accucry.cpu().numpy() # accucry=accucry/lengA # if printOut: # print('VAL loss= ', loss / c, ' VAL accucry ', accucry) # # # scheduler.step(loss / c) # if minloss > (loss / c): # state = {'model': model.state_dict(),'optimizer': optimizer.state_dict(), # 'epoch': epoch} # if lamuda==0: # # torch.save(state, '%s/TW10RLLinearWT%d.pth' % (outf, int(predL / 6))) # else: # # torch.save(state, '%s/RLlassoWT%d.pth' % (outf, int(predL / 6))) # minloss = loss / c # # minmapeloss=lossm/ c # if printOut: # print('bestaccucry: ', accucry) # k0=k # print(k) return lossTrain[1:, :], lossVal[1:, :], acc[1:, :]
def main(): parser = argparse.ArgumentParser(description='D2L Linear Regression') parser.add_argument('--run_mode', type=str, nargs='?', default='mxnet', help='input run_mode. "raw" or "mxnet"') args = parser.parse_args() run_mode = args.run_mode num_inputs = 2 num_examples = 1000 batch_size = 10 lr = 0.03 # Learning rate num_epochs = 10 # Number of iterations print(f'run {run_mode} code ...') if run_mode == 'raw': data_loader = Dataloader(TRUE_W, TRUE_B, num_inputs, num_examples, batch_size) features, labels = data_loader.get_data() model = LinearModel(num_inputs, lr, batch_size) for epoch in range(num_epochs): # Assuming the number of examples can be divided by the batch size, all # the examples in the training data set are used once in one epoch # iteration. The features and tags of mini-batch examples are given by X # and y respectively for X, y in data_loader.data_iter(): with autograd.record(): # Minibatch loss in X and y l = model.squared_loss(model.linreg(X), y) l.backward() # Compute gradient on l with respect to [w,b] model.sgd() # sgd([w, b], lr, batch_size) # Update parameters using their gradient train_l = model.squared_loss(model.linreg(features), labels) print('epoch %d, loss %f' % (epoch + 1, train_l.mean().asnumpy())) else: data_loader = MxDataLoader(TRUE_W, TRUE_B, num_inputs, num_examples, batch_size) features, labels = data_loader.get_data() model = MxLinearModel(lr) for epoch in range(num_epochs): for X, y in data_loader.data_iter: with autograd.record(): l = model.loss(model.net(X), y) l.backward() model.trainer.step(batch_size) l = model.loss(model.net(features), labels) print('epoch %d, loss: %f' % (epoch, l.mean().asnumpy())) model.print_result(TRUE_W, TRUE_B)