def main(): args = parse_args() set_seed(args.seed) env = gym.envs.make(args.env_id) net = get_net(env) approximator = Approximator(net, alpha=args.alpha, loss=nn.MSELoss) get_eps = get_get_epsilon(args.it_at_min, args.min_epsilon) train(approximator, env, get_epsilon=get_eps, **vars(args))
def main(): if len(sys.argv) < 2: print('수행할 작업을 선택해주세요. --preprocess / --train / --test') elif sys.argv[1] == '--preprocess': print('전처리 시작') preprocess() elif sys.argv[1] == '--train': print('모델 학습 시작') train() elif sys.argv[1] == '--test': print('모델 테스트 시작') test() else: print('작업을 올바르게 압력해주세요. --preprocess / --train / --test')
def train_unet(net, path_train, path_valid, n_epoch, batch_size, lr, criterion, use_gpu): optimizer = optim.SGD(net.parameters(), lr=lr, momentum=0.9, weight_decay=0.0005) transform = NormalizeCropTransform(normalize=p_normalize, crop=(450, 256)) train(model=net, optimizer=optimizer, train_path=path_train, valid_path=path_valid, n_epoch=n_epoch, batch_size=batch_size, criterion=criterion, transform=transform, use_gpu=use_gpu, weight_adaptation=p_weight_augmentation) net.cpu() savefile(net, p_model_name_save)
def train_ner(): import os from server.helper import get_args_parser from src import train args = get_args_parser() if True: import sys param_str = '\n'.join( ['%20s = %s' % (k, v) for k, v in sorted(vars(args).items())]) print('usage: %s\n%20s %s\n%s\n%s\n' % (' '.join(sys.argv), 'ARG', 'VALUE', '_' * 50, param_str)) # print(args) os.environ['CUDA_VISIBLE_DEVICES'] = args.device_map train(args=args)
def refactored_pipeline(): """You should import the refactored methods here""" # Step 1 # You should put the `load` method here: X_train, X_test, y_train, y_test = src.load() # Step 2 # You should put the `train` method here: model, train_score = src.train(X_train, y_train) # Step 3 # You should put the `evaluate` method here: test_score = src.evaluate(model, X_test, y_test) # Final Step # Return the train_score and test_score return train_score, test_score
def main(filename='./data/BTC_USDT_5m.csv', plot_bool=True, train_bool=False): fin_data = FinData(filename) fin_data.window() fin_data.ta_columns() peaks, exclusion_zone_peaks, peaks_out, exclusion_zone_peaks_out = fin_data.peak_loc( ) if plot_bool == True: pl = Plotter(fin_data.data_in, peaks) pl.scaling() pl.save() if train_bool == True: tf, lf, tfo, lfo = tensor_agg(fin_data.data_in, peaks, fin_data.data_out, peaks_out) tr_set, tt_set, to_set = tensor_load(tf, lf, tfo, lfo) tf_length = len(tf) trained_model = train(tr_set, tf_length, EPOCH=8) model_eval(trained_model, to_set) return
from src import train if __name__ == '__main__': train()
model_config += str(count) + "\n" for i in range(len(network.Layers)): layer = network.Layers[i] if (isinstance(layer, LinearLayer)): model_config += "linear " + str(layer.W.size()[1]) + " " + str( layer.W.size()[0]) + "\n" if (isinstance(layer, ConvolutionLayer)): model_config += "convo " +str(layer.in_depth) + " " + str(layer.in_row) + \ " " + str(layer.in_col) + " " + str(layer.filter_row) + " " + str(layer.filter_col) + \ " " + str(layer.num_filters) + " " + str(layer.stride) + "\n" if (isinstance(layer, MaxPoolingLayer)): model_config += "maxpool " +str(layer.in_depth) + " " + str(layer.in_row) + \ " " + str(layer.in_col) + " " + str(layer.filter_row) + " " + str(layer.filter_col) + "\n" if (isinstance(layer, ReLULayer)): model_config += "relu" + "\n" if (isinstance(layer, BatchNormLayer)): model_config += "batchnorm " + str(layer.Gamma.size()[0]) + "\n" if (isinstance(layer, FlattenLayer)): model_config += "flatten" + "\n" model_config += model_W_loc + "\n" model_config += model_B_loc + "\n" file = open(model_config_loc, 'w') file.write(model_config) file.close() # Training the bestModel train(data, target, network, model_W_loc, model_B_loc)
args.non_static = True args.class_num = len(label_field.vocab) args.cuda = args.device != -1 and torch.cuda.is_available() args.filter_sizes = [int(size) for size in args.filter_sizes.split(',')] print('Parameters:') for attr, value in sorted(args.__dict__.items()): if attr in {'vectors'}: continue print('\t{}={}'.format(attr.upper(), value)) net = RCNN(args) if args.snapshot: print('\nLoading model from {}...\n'.format(args.snapshot)) net.load_state_dict(torch.load(args.snapshot)) if args.cuda: torch.cuda.set_device(args.device) net = net.cuda() try: train(train_iter, dev_iter, net, args) except KeyboardInterrupt: print('Exiting from training early') print('*' * 30 + ' Testing ' + '*' * 30) save_prefix = os.path.join(args.save_dir, 'best') save_path = '{}_model.pth'.format(save_prefix) state_dict = torch.load(os.path.join(save_path)) net.load_state_dict(state_dict) test_acc = test(test_iter, net, args)
#coding = utf-8 from src.train import * train_percentage=[0.05,0.2,0.4,0.6,0.8,0.95] if __name__ == "__main__": for i in range(len(train_percentage)): tree = train("data/adult.attr", "data/adult.data", "data/adult.test",train_percentage[i])
def main(config: DictConfig): # Train model return train(config)
def test_evaluate(): """Test that evaluate returns a float""" X_train, X_test, y_train, y_test = src.load() clf, score = src.train(X_train, y_train) test_score = src.evaluate(clf, X_test, y_test) assert isinstance(test_score, float)
def test_train(C, gamma): """Test that train returns the expected types""" X_train, X_test, y_train, y_test = src.load() clf, score = src.train(X_train, y_train) assert isinstance(clf, svm.SVC) assert isinstance(score, float)
from src.train import * if __name__ == '__main__': args = load_args() args.pop('my_config') train(**args)