def model_fn(model_dir): """Load the PyTorch model from the `model_dir` directory.""" print("Loading model.") # First, load the parameters used to create the model. model_info = {} model_info_path = os.path.join(model_dir, 'model_info.pth') with open(model_info_path, 'rb') as f: model_info = torch.load(f) print("model_info: {}".format(model_info)) # Determine the device and construct the model. device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = SimpleNet(model_info['input_dim'], model_info['hidden_dim'], model_info['num_hidden'], model_info['output_dim']) # Load the stored model parameters. model_path = os.path.join(model_dir, 'model.pth') with open(model_path, 'rb') as f: model.load_state_dict(torch.load(f)) # prep for testing model.to(device).eval() print("Done loading model.") return model
def model_fn(model_dir): logger.info("Loading model.") # First, load the parameters used to create the model. model_info = {} model_info_path = os.path.join(model_dir, 'model_info.pth') with open(model_info_path, 'rb') as f: model_info = torch.load(f) logger.info("model_info: {}".format(model_info)) # Determine the device and construct the model. device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = SimpleNet(model_info['input_dim'], model_info['hidden_dim'], model_info['output_dim']) # Load the stored model parameters. model_path = os.path.join(model_dir, 'model.pth') with open(model_path, 'rb') as f: model.load_state_dict(torch.load(f)) return model.to(device)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--arch', default="model", help='architecture (model_dir)') parser.add_argument('--do_train', action='store_true') parser.add_argument('--do_predict', action='store_true') parser.add_argument('--do_plot', action='store_true') parser.add_argument('--hidden_size', default=256, type=int) parser.add_argument('--batch_size', default=256, type=int) parser.add_argument('--max_epoch', default=10000, type=int) parser.add_argument('--lr', default=1e-3, type=float) parser.add_argument('--step_lr', default=0.5, type=float) parser.add_argument('--cuda', default=0, type=int) parser.add_argument('--ckpt', type=int, help='load pre-trained model epoch') args = parser.parse_args() if args.do_train: dataset = pd.read_csv("../../data/train.csv") dataset.drop("Id", axis=1, inplace=True) train_set, valid_set = train_test_split(dataset, test_size=0.1, random_state=73) feature_for_training = ["F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"] feature_for_prediction = ["F1"] train = preprocess_samples(train_set, feature_for_training, feature_for_prediction) valid = preprocess_samples(valid_set, feature_for_training, feature_for_prediction) trainData = FeatureDataset(train) validData = FeatureDataset(valid) device = torch.device( 'cuda:%d' % args.cuda if torch.cuda.is_available() else 'cpu') max_epoch = args.max_epoch trainer = Trainer(device, trainData, validData, args) for epoch in range(1, max_epoch + 1): print('Epoch: {}'.format(epoch)) trainer.run_epoch(epoch, True) trainer.run_epoch(epoch, False) if args.do_predict: dataset = pd.read_csv("../../data/test.csv") dataset.drop("Id", axis=1, inplace=True) feature_for_testing = ["F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9"] test = preprocess_samples(dataset, feature_for_testing) testData = FeatureDataset(test) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = SimpleNet(input_size=9, output_size=12, hidden_size=args.hidden_size) model.load_state_dict( torch.load('%s/model.pkl.%d' % (args.arch, args.ckpt))) model.train(False) model.to(device) dataloader = DataLoader(dataset=testData, batch_size=args.batch_size, shuffle=False, collate_fn=testData.collate_fn, num_workers=4) trange = tqdm(enumerate(dataloader), total=len(dataloader), desc='Predict') prediction = [] for i, (ft, _, y) in trange: b = ft.shape[0] missing_ft = torch.zeros(b, 1) all_ft = torch.cat([missing_ft, ft], dim=1) o_labels, _ = model(all_ft.to(device)) o_labels = torch.argmax(o_labels, axis=1) prediction.append(o_labels.to('cpu').numpy().tolist()) prediction = sum(prediction, []) SubmitGenerator(prediction, "../../data/sampleSubmission.csv") if args.do_plot: plot_history("{file}/history.json".format(file=args.arch))
args = parser.parse_args() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # set the seed for generating random numbers torch.manual_seed(args.seed) if torch.cuda.is_available(): torch.cuda.manual_seed(args.seed) # get train loader train_loader = _get_train_loader(args.batch_size, args.data_dir) # data_dir from above.. ## DONE: Build the model by passing in the input params # To get params from the parser, call args.argument_name, ex. args.epochs or args.hidden_dim # Don't forget to move your model .to(device) to move to GPU , if appropriate model = SimpleNet(args.input_dim, args.hidden_dim, args.output_dim, args.dropout) model.to(device) # Given: save the parameters used to construct the model save_model_params(model, args.model_dir) ## DONE: Define an optimizer and loss function for training optimizer = optim.Adam(model.parameters(), lr=args.lr) criterion = nn.BCELoss() # Trains the model (given line of code, which calls the above training function) # This function *also* saves the model state dictionary train(model, train_loader, args.epochs, optimizer, criterion, device)
args = parser.parse_args() device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # set the seed for generating random numbers torch.manual_seed(args.seed) if torch.cuda.is_available(): torch.cuda.manual_seed(args.seed) # get train loader train_loader = _get_train_loader(args.batch_size, args.data_dir) # data_dir from above.. ## TODO: Build the model by passing in the input params # To get params from the parser, call args.argument_name, ex. args.epochs or ards.hidden_dim # Don't forget to move your model .to(device) to move to GPU , if appropriate model = SimpleNet(args.input_dim, args.hidden_dim, args.output_dim) model = model.to(device) # Given: save the parameters used to construct the model save_model_params(model, args.model_dir) ## TODO: Define an optimizer and loss function for training optimizer = optim.Adam(model.parameters(), lr=args.lr) criterion = nn.BCELoss() # Trains the model (given line of code, which calls the above training function) # This function *also* saves the model state dictionary train(model, train_loader, args.epochs, optimizer, criterion, device)
def _train_pred(self, column, test_features, SEED=None): ''' One training session. self.train_features are features to be used for training. self.train_targets[column] are the answers to the training questions. self.val_features are features to be used for validate self.val_targets[column] is the answer to validate. ''' x_train, x_val, y_train, y_val = train_test_split( self.features, self.targets[column], test_size=0.1, shuffle=True, # stratify=True, ) model = SimpleNet( self.num_hidden_layers, self.dropout_rate, len(x_train.columns), self.hidden_size, 1, ) model.to(self.device) train_dataset = TrainDataset(x_train, y_train) trainloader = torch.utils.data.DataLoader( train_dataset, batch_size=self.batch_size, shuffle=True, ) optimizer = torch.optim.AdamW(model.parameters(), lr=self.learning_rate, weight_decay=1e-3) best_loss = np.inf i = torch.tensor(self.test_features.values, dtype=torch.float) for epoch in range(1, self.epochs): train_loss = train_fn(model, optimizer, nn.BCEWithLogitsLoss(), trainloader, self.device) valid_loss = valid_fn(model, nn.BCEWithLogitsLoss(), x_val, y_val, self.device) self.logger.info( 'Epoch:{}, train_loss:{:.5f}, valid_loss:{:.5f}'.format( epoch, train_loss, valid_loss)) if valid_loss < best_loss: not_update_epoch = 0 best_loss = valid_loss torch.save(model.state_dict(), 'best_model_{}.pth'.format(column)) else: not_update_epoch += 1 # if early_stopping_epoch == not_update_epoch: # print('early stopping') # torch.save(model.state_dict(), 'best_model_{}.pth'.format(column)) # break self.score += best_loss self.num_add += 1 self.logger.info("column:{} validation loss {}".format( column, best_loss)) gc.collect() y_pred = inference_fn(model, self.test_features, self.device) return y_pred, best_loss