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)