def run_small_net(): global training_data2, n2, t2, testing_data layers = [] layers.append({'type': 'input', 'out_sx': 24, 'out_sy': 24, 'out_depth': 1}) #layers.append({'type': 'fc', 'num_neurons': 50, 'activation': 'relu'}) layers.append({'type': 'softmax', 'num_classes': 10}) print 'Layers made...' n2 = Net(layers) print 'Smaller Net made...' print n2 t2 = Trainer(n2, {'method': 'sgd', 'momentum': 0.0}) print 'Trainer made for smaller net...' print 'In training of smaller net...' print 'k', 'time\t\t ', 'loss\t ', 'training accuracy' print '----------------------------------------------------' try: for x, y in training_data2: stats = t2.train(x, y) print stats['k'], stats['time'], stats['loss'], stats['accuracy'] except: #hit control-c or other pass print 'Testing smaller net: 5000 trials' right = 0 count = 5000 for x, y in sample(testing_data, count): n2.forward(x) right += n2.getPrediction() == y accuracy = float(right) / count * 100 print accuracy
def OpenNET(url): try: net = Net(cookie_file=cookiejar) #net = Net(cookiejar) try: second_response = net.http_GET(url) except: second_response = net.http_GET(url.encode("utf-8")) return second_response.content except: d = xbmcgui.Dialog() d.ok(url,"Can't Connect to site",'Try again in a moment')
class FeatureExtractor: ''' Class for extracting trained features Feature will be stored in a txt file as a matrix. The size of the feature matrix is [num_img, feature_dimension] Run it as:: >>> extractor = FeatureExtractor(solver_file, snapshot, gpu_idx) >>> extractor.build_net() >>> extractor.run(layer_name, feature_path) :ivar str solver_file: path of the solver file in Caffe's proto format :ivar int snapshot: the snapshot for testing :ivar str layer_name: name of the ayer that produce feature :ivar int gpu_idx: which gpu to perform the test ''' def __init__(self, solver_file, snapshot, gpu_idx = 0): self.solver_file = solver_file self.snapshot = snapshot self.gpu = owl.create_gpu_device(gpu_idx) owl.set_device(self.gpu) def build_net(self): self.owl_net = Net() self.builder = CaffeNetBuilder(self.solver_file) self.snapshot_dir = self.builder.snapshot_dir self.builder.build_net(self.owl_net) self.owl_net.compute_size('TEST') self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot) def run(s, layer_name, feature_path): ''' Run feature extractor :param str layer_name: the layer to extract feature from :param str feature_path: feature output path ''' feature_unit = s.owl_net.units[s.owl_net.name_to_uid[layer_name][0]] feature_file = open(feature_path, 'w') batch_dir = 0 for testiteridx in range(s.owl_net.solver.test_iter[0]): s.owl_net.forward('TEST') feature = feature_unit.out.to_numpy() feature_shape = np.shape(feature) img_num = feature_shape[0] feature_length = np.prod(feature_shape[1:len(feature_shape)]) feature = np.reshape(feature, [img_num, feature_length]) for imgidx in range(img_num): for feaidx in range(feature_length): info ='%f ' % (feature[imgidx, feaidx]) feature_file.write(info) feature_file.write('\n') print "Finish One Batch %d" % (batch_dir) batch_dir += 1 feature_file.close()
class MultiviewTester: ''' Class for performing multi-view testing Run it as:: >>> tester = MultiviewTester(solver_file, softmax_layer, snapshot, gpu_idx) >>> tester.build_net() >>> tester.run() :ivar str solver_file: path of the solver file in Caffe's proto format :ivar int snapshot: the snapshot for testing :ivar str softmax_layer_name: name of the softmax layer that produce prediction :ivar int gpu_idx: which gpu to perform the test ''' def __init__(self, solver_file, softmax_layer_name, snapshot, gpu_idx = 0): self.solver_file = solver_file self.softmax_layer_name = softmax_layer_name self.snapshot = snapshot self.gpu = owl.create_gpu_device(gpu_idx) owl.set_device(self.gpu) def build_net(self): self.owl_net = Net() self.builder = CaffeNetBuilder(self.solver_file) self.snapshot_dir = self.builder.snapshot_dir self.builder.build_net(self.owl_net) self.owl_net.compute_size('MULTI_VIEW') self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot) def run(s): #multi-view test acc_num = 0 test_num = 0 loss_unit = s.owl_net.units[s.owl_net.name_to_uid[s.softmax_layer_name][0]] for testiteridx in range(s.owl_net.solver.test_iter[0]): for i in range(10): s.owl_net.forward('MULTI_VIEW') if i == 0: softmax_val = loss_unit.ff_y batch_size = softmax_val.shape[1] softmax_label = loss_unit.y else: softmax_val = softmax_val + loss_unit.ff_y test_num += batch_size predict = softmax_val.argmax(0) truth = softmax_label.argmax(0) correct = (predict - truth).count_zero() acc_num += correct print "Accuracy the %d mb: %f, batch_size: %d" % (testiteridx, correct, batch_size) sys.stdout.flush() print "Testing Accuracy: %f" % (float(acc_num)/test_num)
def test_basic(): net = Net([2, 2, 1], 1, weights=1) err = net.train([0, 0], [1]) for a, b in zip(basic_weights1, net.weights): print a print b print a == b n.testing.assert_array_almost_equal(a, b) err = net.train([0, 1], [0]) for a, b in zip(basic_weights2, net.weights): print a print b print a == b n.testing.assert_array_almost_equal(a, b)
def __init__(self, verbose=1, maxq=200): Net.__init__(self) Tools.__init__(self) """ Multithreaded network tools """ self.verbose = verbose self.maxq = maxq self.timeout = 0.2 # self.buffers = 256 #for check_port
class Solver(): def __init__(self, args): # prepare a datasets self.train_data = Dataset(train=True, data_root=args.data_root, size=args.image_size) self.test_data = Dataset(train=False, data_root=args.data_root, size=args.image_size) self.train_loader = DataLoader(self.train_data, batch_size=args.batch_size, num_workers=1, shuffle=True, drop_last=True) self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.net = Net().to(self.device) self.loss_fn = torch.nn.L1Loss() self.optim = torch.optim.Adam(self.net.parameters(), args.lr) self.args = args if not os.path.exists(args.ckpt_dir): os.makedirs(args.ckpt_dir) def fit(self): args = self.args for epoch in range(args.max_epochs): self.net.train() for step, inputs in enumerate(self.train_loader): gt_gray = inputs[0].to(self.device) gt_ab = inputs[1].to(self.device) pred_ab = self.net(gt_gray) loss = self.loss_fn(pred_ab, gt_ab) self.optim.zero_grad() loss.backward() self.optim.step() if (epoch+1) % args.print_every == 0: print("Epoch [{}/{}] loss: {:.6f}".format(epoch+1, args.max_epochs, loss.item())) self.save(args.ckpt_dir, args.ckpt_name, epoch+1) def save(self, ckpt_dir, ckpt_name, global_step): save_path = os.path.join( ckpt_dir, "{}_{}.pth".format(ckpt_name, global_step)) torch.save(self.net.state_dict(), save_path)
def train(args): # prepare the MNIST dataset train_dataset = datasets.MNIST(root="./data/", train=True, transform=transforms.ToTensor(), download=True) test_dataset = datasets.MNIST(root="./data/", train=False, transform=transforms.ToTensor()) # create the data loader train_loader = DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=True, drop_last=True) test_loader = DataLoader(dataset=test_dataset, batch_size=args.batch_size, shuffle=False) # turn on the CUDA if available device = torch.device("cuda" if torch.cuda.is_available() else "cpu") net = Net().to(device) loss_op = nn.CrossEntropyLoss() optim = torch.optim.Adam(net.parameters(), lr=args.lr) for epoch in range(args.max_epochs): net.train() for step, inputs in enumerate(train_loader): images = inputs[0].to(device) labels = inputs[1].to(device) # forward-propagation outputs = net(images) loss = loss_op(outputs, labels) # back-propagation optim.zero_grad() loss.backward() optim.step() acc = evaluate(net, test_loader, device) print("Epoch [{}/{}] loss: {:.5f} test acc: {:.3f}" .format(epoch+1, args.max_epochs, loss.item(), acc)) torch.save(net.state_dict(), "mnist-final.pth")
def __init__(self, args): self.epsilonStart = args.epsilonStart self.epsilonEnd = args.epsilonEnd self.epsilonDecayLength = args.epsilonDecayLength self.testEpsilon = args.testEpsilon self.replaySize = args.replaySize self.minReplaySize = args.minReplaySize self.framesPerState = args.framesPerState self.learnFrequency = args.learnFrequency self.targetNetworkUpdateFrequency = args.targetNetworkUpdateFrequency self.batchSize = args.batchSize self.actionNb = args.actionNb self.lastAction = 0 self.lastFrame = None self.rng = np.random.RandomState(42) self.data = Data(self.replaySize, self.framesPerState, (100,100)) self.tickCount = 0 self.learnCount = 0 self.rewardAcc = 0.0 self.episodeNb = 0 self.qValueAcc = 0.0 self.qValueNb = 0 self.maxReward = 0 self.episodeReward = 0 self.test = False self.lastQs = collections.deque(maxlen=60) self.net = Net(args) self.qValues = [] self.rewards = [] self.tickCount = 0
def __init__(self, meta, layers=[], rate=.05, target=None, momentum=None, trans=None, wrange=100): Learner.__init__(self, meta, target) inputs = len(self.meta.names()) - 1 _, possible = self.meta[self.target] self.outputs = possible self.net = Net([inputs] + layers + [len(possible)], rate=rate, momentum=momentum, wrange=wrange, trans=trans)
def build_net(self): self.owl_net = Net() self.builder = CaffeNetBuilder(self.solver_file) self.snapshot_dir = self.builder.snapshot_dir self.builder.build_net(self.owl_net) self.owl_net.compute_size('TEST') self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def __init__(self, args): # prepare a datasets self.train_data = Dataset(args.scale, train=True, data_root=args.data_root, size=args.image_size) self.test_data = Dataset(args.scale, train=False, data_root=args.data_root, size=args.image_size) self.train_loader = DataLoader(self.train_data, batch_size=args.batch_size, num_workers=1, shuffle=True, drop_last=True) self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.net = Net(args.scale).to(self.device) self.loss_fn = torch.nn.L1Loss() self.optim = torch.optim.Adam(self.net.parameters(), args.lr) self.args = args if not os.path.exists(args.ckpt_dir): os.makedirs(args.ckpt_dir) if not os.path.exists(args.result_dir): os.makedirs(args.result_dir)
def __init__(self, args): # prepare SST dataset train_iter, val_iter, test_iter, sst_info = load_sst(args.batch_size, args.max_vocab) vocab_size = sst_info["vocab_size"] num_class = sst_info["num_class"] TEXT = sst_info["TEXT"] print("[!] vocab_size: {}, num_class: {}".format(vocab_size, num_class)) self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.net = Net(TEXT, args.hidden_dim, args.num_layers, num_class).to(self.device) self.optim = torch.optim.Adam( filter(lambda p: p.requires_grad, self.net.parameters()), args.lr, weight_decay=args.weight_decay) self.loss_fn = torch.nn.CrossEntropyLoss() self.args = args self.train_iter = train_iter self.val_iter = val_iter self.test_iter = test_iter if not os.path.exists(args.ckpt_dir): os.makedirs(args.ckpt_dir)
class Solver(object): """Docstring for Solver. """ def __init__(self, param): """TODO: to be defined1. """ self.param = param self.init_train_net(param) def init_train_net(self, param): net_param = pb.NetParameter() with open(param.net, "rb") as f: text_format.Merge(f.read(), net_param) net_state = pb.NetState() net_state.phase = pb.TRAIN # net_state.MergeFrom(net_param.state) # net_state.MergeFrom(param.train_state) net_param.state.CopyFrom(net_state) self.train_net = Net(net_param) def step(self, iters): avg_loss = self.param.average_loss losses = [] smoothed_loss = 0 for i in range(iters): loss = self.train_net.forward_backward() if len(losses) < avg_loss: losses.append(loss) size = len(losses) smoothed_loss = (smoothed_loss * (size - 1) + loss) / size else: idx = (i - 0) % avg_loss smoothed_loss += (loss - losses[idx]) / avg_loss log.info("Iteration %d, loss %f", i, smoothed_loss) self.compute_update_value(i) # self.train_net.update() def compute_update_value(self, i): current_step = i / 100000.0 base_lr = 0.01 gamma = 0.1 rate = base_lr * pow(gamma, current_step) weight_decay = 0.0005 momentum = 0.9 self.train_net.update_params(rate, weight_decay, momentum)
def setup_net(self): if not self.setup: self.setup = True self.net = Net(*SimpleParser(open(self.sisc_file)).parse(), **self.options) for c,i in enumerate(self.net.inputs): self.net.inputs[i] = self.inputs[c] == 1 for c,i in enumerate(self.net.outputs): self.net.outputs[i] = self.outputs[c] == 1 self.components = TwoWayDict(dict(enumerate(self.net.gates.keys())))
class BackProp(Learner): def __init__(self, meta, layers=[], rate=.05, target=None, momentum=None, trans=None, wrange=100): Learner.__init__(self, meta, target) inputs = len(self.meta.names()) - 1 _, possible = self.meta[self.target] self.outputs = possible self.net = Net([inputs] + layers + [len(possible)], rate=rate, momentum=momentum, wrange=wrange, trans=trans) def state(self): return [x.copy() for x in self.net.weights] def use_state(self, state): self.net.weights = state def classify(self, data): output = self.net.classify(data) # print 'result' # print output # print 'result', output, self.outputs return self.outputs[output[-1].argmax()] def validate(self, data, real): output = self.net.classify(data)[-1] label = self.outputs[output.argmax()] target = n.zeros(len(self.outputs)) target[self.outputs.index(real)] = 1 squerr = (target - output)**2 return label, squerr.mean() def train(self, data, target): output = n.zeros(len(self.outputs)) # print self.outputs, target output[self.outputs.index(target)] = 1 if LOG: print 'training' print 'data', data print 'expected', output print 'weights' for level in self.net.weights: print ' ', level err = self.net.train(data, output) return err
def run_big_net(): global training_data, testing_data, n, t, training_data2 training_data = load_data() testing_data = load_data(False) training_data2 = [] print 'Data loaded...' layers = [] layers.append({'type': 'input', 'out_sx': 24, 'out_sy': 24, 'out_depth': 1}) layers.append({'type': 'fc', 'num_neurons': 100, 'activation': 'relu', 'drop_prob': 0.5}) #layers.append({'type': 'fc', 'num_neurons': 800, 'activation': 'relu', 'drop_prob': 0.5}) layers.append({'type': 'softmax', 'num_classes': 10}) print 'Layers made...' n = Net(layers) print 'Net made...' print n t = Trainer(n, {'method': 'sgd', 'momentum': 0.0}) print 'Trainer made...' print 'In training...' print 'k', 'time\t\t ', 'loss\t ', 'training accuracy' print '----------------------------------------------------' try: for x, y in training_data: stats = t.train(x, y) print stats['k'], stats['time'], stats['loss'], stats['accuracy'] training_data2.append((x, n.getPrediction())) except: #hit control-c or other pass print 'In testing: 5000 trials' right = 0 count = 5000 for x, y in sample(testing_data, count): n.forward(x) right += n.getPrediction() == y accuracy = float(right) / count * 100 print accuracy
def init_train_net(self, param): net_param = pb.NetParameter() with open(param.net, "rb") as f: text_format.Merge(f.read(), net_param) net_state = pb.NetState() net_state.phase = pb.TRAIN # net_state.MergeFrom(net_param.state) # net_state.MergeFrom(param.train_state) net_param.state.CopyFrom(net_state) self.train_net = Net(net_param)
class IscasOracleOld(IscasOracle): def __init__(self, sisc_file, inputs, mutated_gates, **options): super(IscasOracleOld, self).__init__(None, [], [], **options) self.sisc_file = sisc_file self.mutated_gates = mutated_gates self.net = Net(*SimpleParser(open(sisc_file)).parse(), **options) for c,i in enumerate(self.net.inputs): self.net.inputs[i] = inputs[c] == 1 orig_gates = self.net.mutate_net(mutated_gates) self.net.calculate_outputs() self.net.mutate_net(orig_gates) self.comp_calls = 0 self.check_calls = 0 self.comp_time = 0 self.check_time = 0 self.scs = set() self.components = TwoWayDict(dict(enumerate(self.net.gates.keys()))) def setup_net(self): pass
def build_net(self): ''' Build network structure using Caffe's proto definition. It will also initialize the network either from given snapshot or from scratch (using proper initializer). During initialization, it will first try to load weight from snapshot. If failed, it will then initialize the weight accordingly. ''' self.owl_net = Net() self.builder = CaffeNetBuilder(self.solver_file) self.snapshot_dir = self.builder.snapshot_dir self.builder.build_net(self.owl_net, self.num_gpu) self.owl_net.compute_size() self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot)
def __init__(self, grid, mdp, moves=40): self.grid = grid self.mdp = mdp self.svm = LinearSVM(grid, mdp) self.net = Net(grid,mdp) self.moves = moves #self.reward = np.zeros(40) self.super_pi = mdp.pi self.reward = np.zeros(self.moves) self.animate = False self.record = True self.recent_rollout_states = None
def __init__(self, grid, mdp, moves=40,net = 'Net'): self.grid = grid self.mdp = mdp self.net_name = net self.svm = LinearSVM(grid, mdp) self.net = Net(grid,mdp,net,T=moves) self.moves = moves #self.reward = np.zeros(40) self.super_pi = mdp.pi self.mdp.pi_noise = False self.reward = np.zeros(self.moves) self.animate = False self.train_loss = 0 self.test_loss = 0 self.record = True
def __init__(self, args): # prepare shakespeare dataset train_iter, data_info = load_shakespeare(args.batch_size, args.bptt_len) self.vocab_size = data_info["vocab_size"] self.TEXT = data_info["TEXT"] self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.net = Net(self.vocab_size, args.embed_dim, args.hidden_dim, args.num_layers).to(self.device) self.loss_fn = torch.nn.CrossEntropyLoss(ignore_index=1) # <pad>: 1 self.optim = torch.optim.Adam(self.net.parameters(), args.lr) self.args = args self.train_iter = train_iter if not os.path.exists(args.ckpt_dir): os.makedirs(args.ckpt_dir)
def predict(weights_path, image_path): ''' Function: loads a trained model and predicts the class of given image Input: weights_path (.h5 file, prefer adding absolute path) image_path (image to predict, prefer adding absolute path) Returns: none ''' model = Net.build(32, 32, 3, weights_path) image = load_image(image_path, show=True) # load image, rescale to 0 to 1 class_ = model.predict(image) # predict the output, returns 36 length array print("Detected: ", class_[0]) # print what is predicted output_indice = -1 # set it initially to -1 # get class index having maximum predicted score for i in range(36): if(i == 0): max = class_[0][i] output_indice = 0 else: if(class_[0][i] > max): max = class_[0][i] output_indice = i # append 26 characters (A to Z) to list characters characters = [] for i in range(65, 65+26): characters.append(chr(i)) # if output indice > 9 (means characters) if(output_indice > 9): final_result = characters[(output_indice - 9) - 1] print("Predicted: ", final_result) print("value: ", max) # print predicted score # else it's a digit, print directly else: print("Predicted: ", output_indice) print("value: ", max) # print it's predicted score
class HeatmapVisualizer: ''' Class of heatmap visualizer. Heat map can reveal which part of the activation is important. This information is useful when conducting detection and segmentation tasks. :ivar str solver_file: name of the solver_file, it will tell Minerva the network configuration and model saving path :ivar snapshot: saved model snapshot index :ivar str layer_name: name of the layer whose activation will be viusualized as heatmap :ivar str result_path: path for the result of visualization, heatmapvisualizer will generate a heatmap jpg for each testing image and save the image under result path. :ivar gpu: the gpu to run testing ''' def __init__(self, solver_file, snapshot, gpu_idx = 0): self.solver_file = solver_file self.snapshot = snapshot self.gpu = owl.create_gpu_device(gpu_idx) owl.set_device(self.gpu) def build_net(self): self.owl_net = Net() self.builder = CaffeNetBuilder(self.solver_file) self.snapshot_dir = self.builder.snapshot_dir self.builder.build_net(self.owl_net) self.owl_net.compute_size('TEST') self.builder.init_net_from_file(self.owl_net, self.snapshot_dir, self.snapshot) def run(s, layer_name, result_path): ''' Run heatmap visualizer :param str layer_name: the layer to visualize :param str result_path: the path to save heatmap ''' feature_unit = s.owl_net.units[s.owl_net.name_to_uid[layer_name][0]] #We need the testing data unit data_unit = None for i in range(len(s.owl_net.name_to_uid['data'])): if s.owl_net.units[s.owl_net.name_to_uid['data'][i]].params.include[0].phase == 1: data_unit = s.owl_net.units[s.owl_net.name_to_uid['data'][i]] assert(data_unit) #get the mean data bp = BlobProto() #get mean file if len(data_unit.params.transform_param.mean_file) == 0: mean_data = np.ones([3, 256, 256], dtype=np.float32) assert(len(data_unit.params.transform_param.mean_value) == 3) mean_data[0] = data_unit.params.transform_param.mean_value[0] mean_data[1] = data_unit.params.transform_param.mean_value[1] mean_data[2] = data_unit.params.transform_param.mean_value[2] h_w = 256 else: with open(data_unit.params.transform_param.mean_file, 'rb') as f: bp.ParseFromString(f.read()) mean_narray = np.array(bp.data, dtype=np.float32) h_w = np.sqrt(np.shape(mean_narray)[0] / 3) mean_data = np.array(bp.data, dtype=np.float32).reshape([3, h_w, h_w]) #get the cropped img crop_size = data_unit.params.transform_param.crop_size crop_h_w = (h_w - crop_size) / 2 mean_data = mean_data[:, crop_h_w:crop_h_w + crop_size, crop_h_w:crop_h_w + crop_size] cur_img = 0 for testiteridx in range(s.owl_net.solver.test_iter[0]): s.owl_net.forward('TEST') feature = feature_unit.out.to_numpy() feature_shape = np.shape(feature) data = data_unit.out.to_numpy() img_num = feature_shape[0] #processing each image for imgidx in range(img_num): img_feature = feature[imgidx,:] #get the image gbr_img_data = data[imgidx,:] + mean_data img_data = np.zeros([data_unit.crop_size, data_unit.crop_size, 3], dtype=np.float32) img_data[:,:,0] = gbr_img_data[2,:,:] img_data[:,:,1] = gbr_img_data[1,:,:] img_data[:,:,2] = gbr_img_data[0,:,:] img_data /= 256 #get the heatmap f_h = feature_shape[2] f_w = feature_shape[3] f_c = feature_shape[1] heatmap = np.zeros([f_h, f_w], dtype=np.float32) for cidx in range(f_c): feature_map = img_feature[cidx,:] f = np.max(np.max(feature_map)) - np.mean(np.mean(feature_map)) heatmap = heatmap + f * f * feature_map #resize heatmap = scipy.misc.imresize(heatmap,[data_unit.crop_size, data_unit.crop_size]) #save fig, ax = plt.subplots(1,2) ax[0].axis('off') ax[1].axis('off') ax[0].imshow(img_data, aspect='equal') ax[1].imshow(heatmap, aspect='equal') #ax[1] = plt.pcolor(heatmap) info = '%s/%d.jpg' % (result_path, cur_img) print info fig.savefig(info) plt.close('all') cur_img += 1 if cur_img == 100: exit(0) print "Finish One Batch %d" % (batch_dir) batch_dir += 1 feature_file.close()
result[i][targets[i]] = 1 return result train = 60000 iteratin = 20 test = 10000 train_images, train_labels = load_mnist_train('ANN\\mnist', 'train') train_images = train_images / 255 train_goals = onehot(train_labels, 10) test_images, test_labels = load_mnist_train('ANN\\mnist', 't10k') test_images = test_images / 255 test_goals = onehot(test_labels, 10) recognizeFigure = Net([784, 14, 14, 10]) print('Training: 0.00%') for j in range(iteratin): for i in range(train): train_results = recognizeFigure.train(train_images[i], train_goals[i]) if i == train - 1: loss = np.sqrt(np.sum((train_results - train_goals[i])**2) / 10) print('Training: {:.2f}%----Loss: {:.4f}'.format( (j + 1) * 100 / iteratin, loss)) precison = 0 test_results = np.empty(test, dtype=int) for i in range(test): test_results[i] = np.argmax(recognizeFigure.recognize(test_images[i])) if test_results[i] == test_labels[i]: precison += 1
optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() pbar.close() print('Epoch - {} --> Loss - {}'.format(epoch + 1, running_loss / STEPS)) #get_grad(epoch) if __name__ == '__main__': mnist_dataset = MNISTDataset() mnist_loader = DataLoader(mnist_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) net = Net() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # Assuming that we are on a CUDA machine, this should print a CUDA device: print(device) net.to(device) train(net, mnist_loader)
class Brain: def __init__(self, pool): self.pool = pool self.model = Net() self.model_ = Net() print("Network architecture:\n" + str(self.model)) def _load(self): self.model.load_state_dict(torch.load("model")) self.model_.load_state_dict(torch.load("model_")) def _save(self): torch.save(self.model.state_dict(), "model") torch.save(self.model_.state_dict(), "model_") def predict_pt(self, s, target): s = Variable(s) if target: return self.model_(s).data else: return self.model(s).data def predict_np(self, s, target=False): s = torch.from_numpy(s).cuda() res = self.predict_pt(s, target) return res.cpu().numpy() def train(self): s, a, r, s_ = self.pool.sample(BATCH_SIZE) # extract the mask m_ = torch.FloatTensor(BATCH_SIZE, ACTION_DIM).zero_().cuda() m_[:, CLASSES:] = s_[:, FEATURE_DIM:] # compute q_current = self.predict_pt(s_, target=False) - ( MAX_MASK_CONST * m_) # masked actions do not influence the max q_target = self.predict_pt(s_, target=True) _, amax = q_current.max(1, keepdim=True) q_ = q_target.gather(1, amax) q_[a < CLASSES] = 0 q_ = q_ + r # bound the values to theoretical q function range q_.clamp_(-1, 0) self.model.train_network(s, a, q_) self.model_.copy_weights(self.model) def update_lr(self, epoch): lr = OPT_LR * (LR_SC_FACTOR**(epoch // LR_SC_EPOCHS)) lr = max(lr, LR_SC_MIN) self.model.set_lr(lr) print("Setting LR:", lr)
##程式沒修改(部分理解) from net import Net net = Net() x = net.variable(1) y = net.variable(3) x2 = net.mul(x, x) y2 = net.mul(y, y) o = net.add(x2, y2) ''' print('net.forward()=', net.forward()) print('net.backward()') net.backward() print('x=', x, 'y=', y, 'o=', o) print('gfx = x.g/o.g = ', x.g/o.g, 'gfy = y.g/o.g=', y.g/o.g) print('x2=', x2, 'y2=', y2) ''' net.gradient_descendent() print('x=', x.v, 'y=', y.v)
import theano.tensor as T from theano import shared from theano import function import theano.printing as pp import layer from layer import Layer import math import sys import matplotlib.pyplot as plt import six.moves.cPickle as pickle import shutil from shutil import copyfile import net from net import Net ANN = Net() saves = [] fileName = 'model.zip' if args.fileName is not None: fileName = args.fileName saves.extend([fileName]) ANN.showPlot = True if args.noPlot: ANN.showPlot = False layerCount = 1 if args.layerCount is not None: layerCount = args.layerCount
#coding: utf-8 import torch import torch.nn as nn import torch.nn.functional as F import numpy as np # ネットワークの読み込み from net import Net model = Net() def predict(X): X = torch.as_tensor(torch.from_numpy(np.array(X)).float()) outputs = model(X) print(outputs) return np.argmax(outputs.data.numpy()) model.load_state_dict(torch.load("./iris_model.pth")) model.eval() print("predict[5.6, 4.3, 1.5, 0.35] => " + str(predict((5.6, 4.3, 1.5, 0.35)))) print("predict[5.9, 3. , 5.1, 1.8] => " + str(predict((5.9, 3., 5.1, 1.8))))
class TFProcess: def __init__(self, cfg): self.cfg = cfg self.net = Net() self.root_dir = os.path.join(self.cfg['training']['path'], self.cfg['name']) # Network structure self.RESIDUAL_FILTERS = self.cfg['model']['filters'] self.RESIDUAL_BLOCKS = self.cfg['model']['residual_blocks'] self.SE_ratio = self.cfg['model']['se_ratio'] self.policy_channels = self.cfg['model'].get('policy_channels', 32) precision = self.cfg['training'].get('precision', 'single') loss_scale = self.cfg['training'].get('loss_scale', 128) self.virtual_batch_size = self.cfg['model'].get( 'virtual_batch_size', None) if precision == 'single': self.model_dtype = tf.float32 elif precision == 'half': self.model_dtype = tf.float16 else: raise ValueError("Unknown precision: {}".format(precision)) # Scale the loss to prevent gradient underflow self.loss_scale = 1 if self.model_dtype == tf.float32 else loss_scale policy_head = self.cfg['model'].get('policy', 'convolution') value_head = self.cfg['model'].get('value', 'wdl') moves_left_head = self.cfg['model'].get('moves_left', 'v1') input_mode = self.cfg['model'].get('input_type', 'classic') self.POLICY_HEAD = None self.VALUE_HEAD = None self.MOVES_LEFT_HEAD = None self.INPUT_MODE = None if policy_head == "classical": self.POLICY_HEAD = pb.NetworkFormat.POLICY_CLASSICAL elif policy_head == "convolution": self.POLICY_HEAD = pb.NetworkFormat.POLICY_CONVOLUTION else: raise ValueError( "Unknown policy head format: {}".format(policy_head)) self.net.set_policyformat(self.POLICY_HEAD) if value_head == "classical": self.VALUE_HEAD = pb.NetworkFormat.VALUE_CLASSICAL self.wdl = False elif value_head == "wdl": self.VALUE_HEAD = pb.NetworkFormat.VALUE_WDL self.wdl = True else: raise ValueError( "Unknown value head format: {}".format(value_head)) self.net.set_valueformat(self.VALUE_HEAD) if moves_left_head == "none": self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_NONE self.moves_left = False elif moves_left_head == "v1": self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_V1 self.moves_left = True else: raise ValueError( "Unknown moves left head format: {}".format(moves_left_head)) self.net.set_movesleftformat(self.MOVES_LEFT_HEAD) if input_mode == "classic": self.INPUT_MODE = pb.NetworkFormat.INPUT_CLASSICAL_112_PLANE elif input_mode == "frc_castling": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CASTLING_PLANE elif input_mode == "canonical": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION elif input_mode == "canonical_100": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES elif input_mode == "canonical_armageddon": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON else: raise ValueError( "Unknown input mode format: {}".format(input_mode)) self.net.set_input(self.INPUT_MODE) self.swa_enabled = self.cfg['training'].get('swa', False) # Limit momentum of SWA exponential average to 1 - 1/(swa_max_n + 1) self.swa_max_n = self.cfg['training'].get('swa_max_n', 0) self.renorm_enabled = self.cfg['training'].get('renorm', False) self.renorm_max_r = self.cfg['training'].get('renorm_max_r', 1) self.renorm_max_d = self.cfg['training'].get('renorm_max_d', 0) self.renorm_momentum = self.cfg['training'].get( 'renorm_momentum', 0.99) gpus = tf.config.experimental.list_physical_devices('GPU') tf.config.experimental.set_visible_devices(gpus[self.cfg['gpu']], 'GPU') tf.config.experimental.set_memory_growth(gpus[self.cfg['gpu']], True) if self.model_dtype == tf.float16: tf.keras.mixed_precision.experimental.set_policy('mixed_float16') self.global_step = tf.Variable(0, name='global_step', trainable=False, dtype=tf.int64) def init_v2(self, train_dataset, test_dataset, validation_dataset=None): self.train_dataset = train_dataset self.train_iter = iter(train_dataset) self.test_dataset = test_dataset self.test_iter = iter(test_dataset) self.validation_dataset = validation_dataset self.init_net_v2() def init_net_v2(self): self.l2reg = tf.keras.regularizers.l2(l=0.5 * (0.0001)) input_var = tf.keras.Input(shape=(112, 8 * 8)) x_planes = tf.keras.layers.Reshape([112, 8, 8])(input_var) policy, value, moves_left = self.construct_net_v2(x_planes) if self.moves_left: outputs = [policy, value, moves_left] else: outputs = [policy, value] self.model = tf.keras.Model(inputs=input_var, outputs=outputs) # swa_count initialized reguardless to make checkpoint code simpler. self.swa_count = tf.Variable(0., name='swa_count', trainable=False) self.swa_weights = None if self.swa_enabled: # Count of networks accumulated into SWA self.swa_weights = [ tf.Variable(w, trainable=False) for w in self.model.weights ] self.active_lr = 0.01 self.optimizer = tf.keras.optimizers.SGD( learning_rate=lambda: self.active_lr, momentum=0.9, nesterov=True) self.orig_optimizer = self.optimizer if self.loss_scale != 1: self.optimizer = tf.keras.mixed_precision.experimental.LossScaleOptimizer( self.optimizer, self.loss_scale) def correct_policy(target, output): output = tf.cast(output, tf.float32) # Calculate loss on policy head if self.cfg['training'].get('mask_legal_moves'): # extract mask for legal moves from target policy move_is_legal = tf.greater_equal(target, 0) # replace logits of illegal moves with large negative value (so that it doesn't affect policy of legal moves) without gradient illegal_filler = tf.zeros_like(output) - 1.0e10 output = tf.where(move_is_legal, output, illegal_filler) # y_ still has -1 on illegal moves, flush them to 0 target = tf.nn.relu(target) return target, output def policy_loss(target, output): target, output = correct_policy(target, output) policy_cross_entropy = tf.nn.softmax_cross_entropy_with_logits( labels=tf.stop_gradient(target), logits=output) return tf.reduce_mean(input_tensor=policy_cross_entropy) self.policy_loss_fn = policy_loss def policy_accuracy(target, output): target, output = correct_policy(target, output) return tf.reduce_mean( tf.cast( tf.equal(tf.argmax(input=target, axis=1), tf.argmax(input=output, axis=1)), tf.float32)) self.policy_accuracy_fn = policy_accuracy self.policy_accuracy_fn = policy_accuracy def moves_left_mean_error_fn(target, output): output = tf.cast(output, tf.float32) return tf.reduce_mean(tf.abs(target - output)) self.moves_left_mean_error = moves_left_mean_error_fn q_ratio = self.cfg['training'].get('q_ratio', 0) assert 0 <= q_ratio <= 1 # Linear conversion to scalar to compute MSE with, for comparison to old values wdl = tf.expand_dims(tf.constant([1.0, 0.0, -1.0]), 1) self.qMix = lambda z, q: q * q_ratio + z * (1 - q_ratio) # Loss on value head if self.wdl: def value_loss(target, output): output = tf.cast(output, tf.float32) value_cross_entropy = tf.nn.softmax_cross_entropy_with_logits( labels=tf.stop_gradient(target), logits=output) return tf.reduce_mean(input_tensor=value_cross_entropy) self.value_loss_fn = value_loss def mse_loss(target, output): output = tf.cast(output, tf.float32) scalar_z_conv = tf.matmul(tf.nn.softmax(output), wdl) scalar_target = tf.matmul(target, wdl) return tf.reduce_mean(input_tensor=tf.math.squared_difference( scalar_target, scalar_z_conv)) self.mse_loss_fn = mse_loss else: def value_loss(target, output): return tf.constant(0) self.value_loss_fn = value_loss def mse_loss(target, output): output = tf.cast(output, tf.float32) scalar_target = tf.matmul(target, wdl) return tf.reduce_mean(input_tensor=tf.math.squared_difference( scalar_target, output)) self.mse_loss_fn = mse_loss if self.moves_left: def moves_left_loss(target, output): # Scale the loss to similar range as other losses. scale = 20.0 # Bigger loss for low amount of moves left. # We care more about the accuracy of the prediction # when close to the end of the game. importance = tf.square(30.0 / (target + 30.0)) importance = importance / tf.reduce_mean(importance) target = target / scale output = tf.cast(output, tf.float32) / scale huber = tf.keras.losses.Huber(10.0 / scale) return tf.reduce_mean(importance * huber(target, output)) else: moves_left_loss = None self.moves_left_loss_fn = moves_left_loss pol_loss_w = self.cfg['training']['policy_loss_weight'] val_loss_w = self.cfg['training']['value_loss_weight'] if self.moves_left: moves_loss_w = self.cfg['training']['moves_left_loss_weight'] else: moves_loss_w = tf.constant(0.0, dtype=tf.float32) def _lossMix(policy, value, moves_left): return pol_loss_w * policy + val_loss_w * value + moves_loss_w * moves_left self.lossMix = _lossMix def accuracy(target, output): output = tf.cast(output, tf.float32) return tf.reduce_mean( tf.cast( tf.equal(tf.argmax(input=target, axis=1), tf.argmax(input=output, axis=1)), tf.float32)) self.accuracy_fn = accuracy self.avg_policy_loss = [] self.avg_value_loss = [] self.avg_moves_left_loss = [] self.avg_mse_loss = [] self.avg_reg_term = [] self.time_start = None self.last_steps = None # Set adaptive learning rate during training self.cfg['training']['lr_boundaries'].sort() self.warmup_steps = self.cfg['training'].get('warmup_steps', 0) self.lr = self.cfg['training']['lr_values'][0] self.test_writer = tf.summary.create_file_writer( os.path.join(os.getcwd(), "leelalogs/{}-test".format(self.cfg['name']))) self.train_writer = tf.summary.create_file_writer( os.path.join(os.getcwd(), "leelalogs/{}-train".format(self.cfg['name']))) if vars(self).get('validation_dataset', None) is not None: self.validation_writer = tf.summary.create_file_writer( os.path.join( os.getcwd(), "leelalogs/{}-validation".format(self.cfg['name']))) if self.swa_enabled: self.swa_writer = tf.summary.create_file_writer( os.path.join(os.getcwd(), "leelalogs/{}-swa-test".format(self.cfg['name']))) self.swa_validation_writer = tf.summary.create_file_writer( os.path.join( os.getcwd(), "leelalogs/{}-swa-validation".format(self.cfg['name']))) self.checkpoint = tf.train.Checkpoint(optimizer=self.orig_optimizer, model=self.model, global_step=self.global_step, swa_count=self.swa_count) self.checkpoint.listed = self.swa_weights self.manager = tf.train.CheckpointManager( self.checkpoint, directory=self.root_dir, max_to_keep=50, keep_checkpoint_every_n_hours=24, checkpoint_name=self.cfg['name']) def replace_weights_v2(self, proto_filename, ignore_errors=False): self.net.parse_proto(proto_filename) filters, blocks = self.net.filters(), self.net.blocks() if not ignore_errors: if self.RESIDUAL_FILTERS != filters: raise ValueError("Number of filters doesn't match the network") if self.RESIDUAL_BLOCKS != blocks: raise ValueError("Number of blocks doesn't match the network") if self.POLICY_HEAD != self.net.pb.format.network_format.policy: raise ValueError("Policy head type doesn't match the network") if self.VALUE_HEAD != self.net.pb.format.network_format.value: raise ValueError("Value head type doesn't match the network") # List all tensor names we need weights for. names = [] for weight in self.model.weights: names.append(weight.name) new_weights = self.net.get_weights_v2(names) for weight in self.model.weights: if 'renorm' in weight.name: # Renorm variables are not populated. continue try: new_weight = new_weights[weight.name] except KeyError: error_string = 'No values for tensor {} in protobuf'.format( weight.name) if ignore_errors: print(error_string) continue else: raise KeyError(error_string) if reduce(operator.mul, weight.shape.as_list(), 1) != len(new_weight): error_string = 'Tensor {} has wrong length. Tensorflow shape {}, size in protobuf {}'.format( weight.name, weight.shape.as_list(), len(new_weight)) if ignore_errors: print(error_string) continue else: raise KeyError(error_string) if weight.shape.ndims == 4: # Rescale rule50 related weights as clients do not normalize the input. if weight.name == 'input/conv2d/kernel:0' and self.net.pb.format.network_format.input < pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES: num_inputs = 112 # 50 move rule is the 110th input, or 109 starting from 0. rule50_input = 109 for i in range(len(new_weight)): if (i % (num_inputs * 9)) // 9 == rule50_input: new_weight[i] = new_weight[i] * 99 # Convolution weights need a transpose # # TF (kYXInputOutput) # [filter_height, filter_width, in_channels, out_channels] # # Leela/cuDNN/Caffe (kOutputInputYX) # [output, input, filter_size, filter_size] s = weight.shape.as_list() shape = [s[i] for i in [3, 2, 0, 1]] new_weight = tf.constant(new_weight, shape=shape) weight.assign(tf.transpose(a=new_weight, perm=[2, 3, 1, 0])) elif weight.shape.ndims == 2: # Fully connected layers are [in, out] in TF # # [out, in] in Leela # s = weight.shape.as_list() shape = [s[i] for i in [1, 0]] new_weight = tf.constant(new_weight, shape=shape) weight.assign(tf.transpose(a=new_weight, perm=[1, 0])) else: # Biases, batchnorm etc new_weight = tf.constant(new_weight, shape=weight.shape) weight.assign(new_weight) # Replace the SWA weights as well, ensuring swa accumulation is reset. if self.swa_enabled: self.swa_count.assign(tf.constant(0.)) self.update_swa_v2() # This should result in identical file to the starting one # self.save_leelaz_weights_v2('restored.pb.gz') def restore_v2(self): if self.manager.latest_checkpoint is not None: print("Restoring from {0}".format(self.manager.latest_checkpoint)) self.checkpoint.restore(self.manager.latest_checkpoint) def process_loop_v2(self, batch_size, test_batches, batch_splits=1): # Get the initial steps value in case this is a resume from a step count # which is not a multiple of total_steps. steps = self.global_step.read_value() total_steps = self.cfg['training']['total_steps'] for _ in range(steps % total_steps, total_steps): self.process_v2(batch_size, test_batches, batch_splits=batch_splits) @tf.function() def read_weights(self): return [w.read_value() for w in self.model.weights] @tf.function() def process_inner_loop(self, x, y, z, q, m): with tf.GradientTape() as tape: outputs = self.model(x, training=True) policy = outputs[0] value = outputs[1] policy_loss = self.policy_loss_fn(y, policy) reg_term = sum(self.model.losses) if self.wdl: value_ce_loss = self.value_loss_fn(self.qMix(z, q), value) value_loss = value_ce_loss else: value_mse_loss = self.mse_loss_fn(self.qMix(z, q), value) value_loss = value_mse_loss if self.moves_left: moves_left = outputs[2] moves_left_loss = self.moves_left_loss_fn(m, moves_left) else: moves_left_loss = tf.constant(0.) total_loss = self.lossMix(policy_loss, value_loss, moves_left_loss) + reg_term if self.loss_scale != 1: total_loss = self.optimizer.get_scaled_loss(total_loss) if self.wdl: mse_loss = self.mse_loss_fn(self.qMix(z, q), value) else: value_loss = self.value_loss_fn(self.qMix(z, q), value) return policy_loss, value_loss, mse_loss, moves_left_loss, reg_term, tape.gradient( total_loss, self.model.trainable_weights) def process_v2(self, batch_size, test_batches, batch_splits=1): if not self.time_start: self.time_start = time.time() # Get the initial steps value before we do a training step. steps = self.global_step.read_value() if not self.last_steps: self.last_steps = steps if self.swa_enabled: # split half of test_batches between testing regular weights and SWA weights test_batches //= 2 # Run test before first step to see delta since end of last run. if steps % self.cfg['training']['total_steps'] == 0: # Steps is given as one higher than current in order to avoid it # being equal to the value the end of a run is stored against. self.calculate_test_summaries_v2(test_batches, steps + 1) if self.swa_enabled: self.calculate_swa_summaries_v2(test_batches, steps + 1) # Make sure that ghost batch norm can be applied if self.virtual_batch_size and batch_size % self.virtual_batch_size != 0: # Adjust required batch size for batch splitting. required_factor = self.virtual_batch_size * self.cfg[ 'training'].get('num_batch_splits', 1) raise ValueError( 'batch_size must be a multiple of {}'.format(required_factor)) # Determine learning rate lr_values = self.cfg['training']['lr_values'] lr_boundaries = self.cfg['training']['lr_boundaries'] steps_total = steps % self.cfg['training']['total_steps'] self.lr = lr_values[bisect.bisect_right(lr_boundaries, steps_total)] if self.warmup_steps > 0 and steps < self.warmup_steps: self.lr = self.lr * tf.cast(steps + 1, tf.float32) / self.warmup_steps # need to add 1 to steps because steps will be incremented after gradient update if (steps + 1) % self.cfg['training']['train_avg_report_steps'] == 0 or ( steps + 1) % self.cfg['training']['total_steps'] == 0: before_weights = self.read_weights() # Run training for this batch grads = None for _ in range(batch_splits): x, y, z, q, m = next(self.train_iter) policy_loss, value_loss, mse_loss, moves_left_loss, reg_term, new_grads = self.process_inner_loop( x, y, z, q, m) if not grads: grads = new_grads else: grads = [tf.math.add(a, b) for (a, b) in zip(grads, new_grads)] # Keep running averages # Google's paper scales MSE by 1/4 to a [0, 1] range, so do the same to # get comparable values. mse_loss /= 4.0 self.avg_policy_loss.append(policy_loss) if self.wdl: self.avg_value_loss.append(value_loss) if self.moves_left: self.avg_moves_left_loss.append(moves_left_loss) self.avg_mse_loss.append(mse_loss) self.avg_reg_term.append(reg_term) # Gradients of batch splits are summed, not averaged like usual, so need to scale lr accordingly to correct for this. self.active_lr = self.lr / batch_splits if self.loss_scale != 1: grads = self.optimizer.get_unscaled_gradients(grads) max_grad_norm = self.cfg['training'].get('max_grad_norm', 10000.0) * batch_splits grads, grad_norm = tf.clip_by_global_norm(grads, max_grad_norm) self.optimizer.apply_gradients(zip(grads, self.model.trainable_weights)) # Update steps. self.global_step.assign_add(1) steps = self.global_step.read_value() if steps % self.cfg['training'][ 'train_avg_report_steps'] == 0 or steps % self.cfg['training'][ 'total_steps'] == 0: pol_loss_w = self.cfg['training']['policy_loss_weight'] val_loss_w = self.cfg['training']['value_loss_weight'] moves_loss_w = self.cfg['training']['moves_left_loss_weight'] time_end = time.time() speed = 0 if self.time_start: elapsed = time_end - self.time_start steps_elapsed = steps - self.last_steps speed = batch_size * (tf.cast(steps_elapsed, tf.float32) / elapsed) avg_policy_loss = np.mean(self.avg_policy_loss or [0]) avg_moves_left_loss = np.mean(self.avg_moves_left_loss or [0]) avg_value_loss = np.mean(self.avg_value_loss or [0]) avg_mse_loss = np.mean(self.avg_mse_loss or [0]) avg_reg_term = np.mean(self.avg_reg_term or [0]) print( "step {}, lr={:g} policy={:g} value={:g} mse={:g} moves={:g} reg={:g} total={:g} ({:g} pos/s)" .format( steps, self.lr, avg_policy_loss, avg_value_loss, avg_mse_loss, avg_moves_left_loss, avg_reg_term, pol_loss_w * avg_policy_loss + val_loss_w * avg_value_loss + avg_reg_term + moves_loss_w * avg_moves_left_loss, speed)) after_weights = self.read_weights() with self.train_writer.as_default(): tf.summary.scalar("Policy Loss", avg_policy_loss, step=steps) tf.summary.scalar("Value Loss", avg_value_loss, step=steps) if self.moves_left: tf.summary.scalar("Moves Left Loss", avg_moves_left_loss, step=steps) tf.summary.scalar("Reg term", avg_reg_term, step=steps) tf.summary.scalar("LR", self.lr, step=steps) tf.summary.scalar("Gradient norm", grad_norm / batch_splits, step=steps) tf.summary.scalar("MSE Loss", avg_mse_loss, step=steps) self.compute_update_ratio_v2(before_weights, after_weights, steps) self.train_writer.flush() self.time_start = time_end self.last_steps = steps self.avg_policy_loss = [] self.avg_moves_left_loss = [] self.avg_value_loss = [] self.avg_mse_loss = [] self.avg_reg_term = [] if self.swa_enabled and steps % self.cfg['training']['swa_steps'] == 0: self.update_swa_v2() # Calculate test values every 'test_steps', but also ensure there is # one at the final step so the delta to the first step can be calculted. if steps % self.cfg['training']['test_steps'] == 0 or steps % self.cfg[ 'training']['total_steps'] == 0: self.calculate_test_summaries_v2(test_batches, steps) if self.swa_enabled: self.calculate_swa_summaries_v2(test_batches, steps) if self.validation_dataset is not None and ( steps % self.cfg['training']['validation_steps'] == 0 or steps % self.cfg['training']['total_steps'] == 0): if self.swa_enabled: self.calculate_swa_validations_v2(steps) else: self.calculate_test_validations_v2(steps) # Save session and weights at end, and also optionally every 'checkpoint_steps'. if steps % self.cfg['training']['total_steps'] == 0 or ( 'checkpoint_steps' in self.cfg['training'] and steps % self.cfg['training']['checkpoint_steps'] == 0): evaled_steps = steps.numpy() self.manager.save(checkpoint_number=evaled_steps) print("Model saved in file: {}".format( self.manager.latest_checkpoint)) path = os.path.join(self.root_dir, self.cfg['name']) leela_path = path + "-" + str(evaled_steps) swa_path = path + "-swa-" + str(evaled_steps) self.net.pb.training_params.training_steps = evaled_steps self.save_leelaz_weights_v2(leela_path) if self.swa_enabled: self.save_swa_weights_v2(swa_path) def calculate_swa_summaries_v2(self, test_batches, steps): backup = self.read_weights() for (swa, w) in zip(self.swa_weights, self.model.weights): w.assign(swa.read_value()) true_test_writer, self.test_writer = self.test_writer, self.swa_writer print('swa', end=' ') self.calculate_test_summaries_v2(test_batches, steps) self.test_writer = true_test_writer for (old, w) in zip(backup, self.model.weights): w.assign(old) @tf.function() def calculate_test_summaries_inner_loop(self, x, y, z, q, m): outputs = self.model(x, training=False) policy = outputs[0] value = outputs[1] policy_loss = self.policy_loss_fn(y, policy) policy_accuracy = self.policy_accuracy_fn(y, policy) if self.wdl: value_loss = self.value_loss_fn(self.qMix(z, q), value) mse_loss = self.mse_loss_fn(self.qMix(z, q), value) value_accuracy = self.accuracy_fn(self.qMix(z, q), value) else: value_loss = self.value_loss_fn(self.qMix(z, q), value) mse_loss = self.mse_loss_fn(self.qMix(z, q), value) value_accuracy = tf.constant(0.) if self.moves_left: moves_left = outputs[2] moves_left_loss = self.moves_left_loss_fn(m, moves_left) moves_left_mean_error = self.moves_left_mean_error(m, moves_left) else: moves_left_loss = tf.constant(0.) moves_left_mean_error = tf.constant(0.) return policy_loss, value_loss, moves_left_loss, mse_loss, policy_accuracy, value_accuracy, moves_left_mean_error def calculate_test_summaries_v2(self, test_batches, steps): sum_policy_accuracy = 0 sum_value_accuracy = 0 sum_moves_left = 0 sum_moves_left_mean_error = 0 sum_mse = 0 sum_policy = 0 sum_value = 0 for _ in range(0, test_batches): x, y, z, q, m = next(self.test_iter) policy_loss, value_loss, moves_left_loss, mse_loss, policy_accuracy, value_accuracy, moves_left_mean_error = self.calculate_test_summaries_inner_loop( x, y, z, q, m) sum_policy_accuracy += policy_accuracy sum_mse += mse_loss sum_policy += policy_loss if self.wdl: sum_value_accuracy += value_accuracy sum_value += value_loss if self.moves_left: sum_moves_left += moves_left_loss sum_moves_left_mean_error += moves_left_mean_error sum_policy_accuracy /= test_batches sum_policy_accuracy *= 100 sum_policy /= test_batches sum_value /= test_batches if self.wdl: sum_value_accuracy /= test_batches sum_value_accuracy *= 100 # Additionally rescale to [0, 1] so divide by 4 sum_mse /= (4.0 * test_batches) if self.moves_left: sum_moves_left /= test_batches sum_moves_left_mean_error /= test_batches self.net.pb.training_params.learning_rate = self.lr self.net.pb.training_params.mse_loss = sum_mse self.net.pb.training_params.policy_loss = sum_policy # TODO store value and value accuracy in pb self.net.pb.training_params.accuracy = sum_policy_accuracy with self.test_writer.as_default(): tf.summary.scalar("Policy Loss", sum_policy, step=steps) tf.summary.scalar("Value Loss", sum_value, step=steps) tf.summary.scalar("MSE Loss", sum_mse, step=steps) tf.summary.scalar("Policy Accuracy", sum_policy_accuracy, step=steps) if self.wdl: tf.summary.scalar("Value Accuracy", sum_value_accuracy, step=steps) if self.moves_left: tf.summary.scalar("Moves Left Loss", sum_moves_left, step=steps) tf.summary.scalar("Moves Left Mean Error", sum_moves_left_mean_error, step=steps) for w in self.model.weights: tf.summary.histogram(w.name, w, step=steps) self.test_writer.flush() print("step {}, policy={:g} value={:g} policy accuracy={:g}% value accuracy={:g}% mse={:g}".\ format(steps, sum_policy, sum_value, sum_policy_accuracy, sum_value_accuracy, sum_mse), end = '') if self.moves_left: print(" moves={:g} moves mean={:g}".format( sum_moves_left, sum_moves_left_mean_error)) else: print() def calculate_swa_validations_v2(self, steps): backup = self.read_weights() for (swa, w) in zip(self.swa_weights, self.model.weights): w.assign(swa.read_value()) true_validation_writer, self.validation_writer = self.validation_writer, self.swa_validation_writer print('swa', end=' ') self.calculate_test_validations_v2(steps) self.validation_writer = true_validation_writer for (old, w) in zip(backup, self.model.weights): w.assign(old) def calculate_test_validations_v2(self, steps): sum_policy_accuracy = 0 sum_value_accuracy = 0 sum_moves_left = 0 sum_moves_left_mean_error = 0 sum_mse = 0 sum_policy = 0 sum_value = 0 counter = 0 for (x, y, z, q, m) in self.validation_dataset: policy_loss, value_loss, moves_left_loss, mse_loss, policy_accuracy, value_accuracy, moves_left_mean_error = self.calculate_test_summaries_inner_loop( x, y, z, q, m) sum_policy_accuracy += policy_accuracy sum_mse += mse_loss sum_policy += policy_loss if self.moves_left: sum_moves_left += moves_left_loss sum_moves_left_mean_error += moves_left_mean_error counter += 1 if self.wdl: sum_value_accuracy += value_accuracy sum_value += value_loss sum_policy_accuracy /= counter sum_policy_accuracy *= 100 sum_policy /= counter sum_value /= counter if self.wdl: sum_value_accuracy /= counter sum_value_accuracy *= 100 if self.moves_left: sum_moves_left /= counter sum_moves_left_mean_error /= counter # Additionally rescale to [0, 1] so divide by 4 sum_mse /= (4.0 * counter) with self.validation_writer.as_default(): tf.summary.scalar("Policy Loss", sum_policy, step=steps) tf.summary.scalar("Value Loss", sum_value, step=steps) tf.summary.scalar("MSE Loss", sum_mse, step=steps) tf.summary.scalar("Policy Accuracy", sum_policy_accuracy, step=steps) if self.wdl: tf.summary.scalar("Value Accuracy", sum_value_accuracy, step=steps) if self.moves_left: tf.summary.scalar("Moves Left Loss", sum_moves_left, step=steps) tf.summary.scalar("Moves Left Mean Error", sum_moves_left_mean_error, step=steps) self.validation_writer.flush() print("step {}, validation: policy={:g} value={:g} policy accuracy={:g}% value accuracy={:g}% mse={:g}".\ format(steps, sum_policy, sum_value, sum_policy_accuracy, sum_value_accuracy, sum_mse), end='') if self.moves_left: print(" moves={:g} moves mean={:g}".format( sum_moves_left, sum_moves_left_mean_error)) else: print() @tf.function() def compute_update_ratio_v2(self, before_weights, after_weights, steps): """Compute the ratio of gradient norm to weight norm. Adapted from https://github.com/tensorflow/minigo/blob/c923cd5b11f7d417c9541ad61414bf175a84dc31/dual_net.py#L567 """ deltas = [ after - before for after, before in zip(after_weights, before_weights) ] delta_norms = [tf.math.reduce_euclidean_norm(d) for d in deltas] weight_norms = [ tf.math.reduce_euclidean_norm(w) for w in before_weights ] ratios = [(tensor.name, tf.cond(w != 0., lambda: d / w, lambda: -1.)) for d, w, tensor in zip(delta_norms, weight_norms, self.model.weights) if not 'moving' in tensor.name] for name, ratio in ratios: tf.summary.scalar('update_ratios/' + name, ratio, step=steps) # Filtering is hard, so just push infinities/NaNs to an unreasonably large value. ratios = [ tf.cond(r > 0, lambda: tf.math.log(r) / 2.30258509299, lambda: 200.) for (_, r) in ratios ] tf.summary.histogram('update_ratios_log10', tf.stack(ratios), buckets=1000, step=steps) def update_swa_v2(self): num = self.swa_count.read_value() for (w, swa) in zip(self.model.weights, self.swa_weights): swa.assign(swa.read_value() * (num / (num + 1.)) + w.read_value() * (1. / (num + 1.))) self.swa_count.assign(min(num + 1., self.swa_max_n)) def save_swa_weights_v2(self, filename): backup = self.read_weights() for (swa, w) in zip(self.swa_weights, self.model.weights): w.assign(swa.read_value()) self.save_leelaz_weights_v2(filename) for (old, w) in zip(backup, self.model.weights): w.assign(old) def save_leelaz_weights_v2(self, filename): numpy_weights = [] for weight in self.model.weights: numpy_weights.append([weight.name, weight.numpy()]) self.net.fill_net_v2(numpy_weights) self.net.save_proto(filename) def batch_norm_v2(self, input, name, scale=False): if self.renorm_enabled: clipping = { "rmin": 1.0 / self.renorm_max_r, "rmax": self.renorm_max_r, "dmax": self.renorm_max_d } return tf.keras.layers.BatchNormalization( epsilon=1e-5, axis=1, fused=False, center=True, scale=scale, renorm=True, renorm_clipping=clipping, renorm_momentum=self.renorm_momentum, name=name)(input) else: return tf.keras.layers.BatchNormalization( epsilon=1e-5, axis=1, center=True, scale=scale, virtual_batch_size=self.virtual_batch_size, name=name)(input) def squeeze_excitation_v2(self, inputs, channels, name): assert channels % self.SE_ratio == 0 pooled = tf.keras.layers.GlobalAveragePooling2D( data_format='channels_first')(inputs) squeezed = tf.keras.layers.Activation('relu')(tf.keras.layers.Dense( channels // self.SE_ratio, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, name=name + '/se/dense1')(pooled)) excited = tf.keras.layers.Dense(2 * channels, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, name=name + '/se/dense2')(squeezed) return ApplySqueezeExcitation()([inputs, excited]) def conv_block_v2(self, inputs, filter_size, output_channels, name, bn_scale=False): conv = tf.keras.layers.Conv2D(output_channels, filter_size, use_bias=False, padding='same', kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, data_format='channels_first', name=name + '/conv2d')(inputs) return tf.keras.layers.Activation('relu')(self.batch_norm_v2( conv, name=name + '/bn', scale=bn_scale)) def residual_block_v2(self, inputs, channels, name): conv1 = tf.keras.layers.Conv2D(channels, 3, use_bias=False, padding='same', kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, data_format='channels_first', name=name + '/1/conv2d')(inputs) out1 = tf.keras.layers.Activation('relu')(self.batch_norm_v2( conv1, name + '/1/bn', scale=False)) conv2 = tf.keras.layers.Conv2D(channels, 3, use_bias=False, padding='same', kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, data_format='channels_first', name=name + '/2/conv2d')(out1) out2 = self.squeeze_excitation_v2(self.batch_norm_v2(conv2, name + '/2/bn', scale=True), channels, name=name + '/se') return tf.keras.layers.Activation('relu')(tf.keras.layers.add( [inputs, out2])) def construct_net_v2(self, inputs): flow = self.conv_block_v2(inputs, filter_size=3, output_channels=self.RESIDUAL_FILTERS, name='input', bn_scale=True) for i in range(self.RESIDUAL_BLOCKS): flow = self.residual_block_v2(flow, self.RESIDUAL_FILTERS, name='residual_{}'.format(i + 1)) # Policy head if self.POLICY_HEAD == pb.NetworkFormat.POLICY_CONVOLUTION: conv_pol = self.conv_block_v2( flow, filter_size=3, output_channels=self.RESIDUAL_FILTERS, name='policy1') conv_pol2 = tf.keras.layers.Conv2D( 80, 3, use_bias=True, padding='same', kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, bias_regularizer=self.l2reg, data_format='channels_first', name='policy')(conv_pol) h_fc1 = ApplyPolicyMap()(conv_pol2) elif self.POLICY_HEAD == pb.NetworkFormat.POLICY_CLASSICAL: conv_pol = self.conv_block_v2(flow, filter_size=1, output_channels=self.policy_channels, name='policy') h_conv_pol_flat = tf.keras.layers.Flatten()(conv_pol) h_fc1 = tf.keras.layers.Dense(1858, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, bias_regularizer=self.l2reg, name='policy/dense')(h_conv_pol_flat) else: raise ValueError("Unknown policy head type {}".format( self.POLICY_HEAD)) # Value head conv_val = self.conv_block_v2(flow, filter_size=1, output_channels=32, name='value') h_conv_val_flat = tf.keras.layers.Flatten()(conv_val) h_fc2 = tf.keras.layers.Dense(128, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, activation='relu', name='value/dense1')(h_conv_val_flat) if self.wdl: h_fc3 = tf.keras.layers.Dense(3, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, bias_regularizer=self.l2reg, name='value/dense2')(h_fc2) else: h_fc3 = tf.keras.layers.Dense(1, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, activation='tanh', name='value/dense2')(h_fc2) # Moves left head if self.moves_left: conv_mov = self.conv_block_v2(flow, filter_size=1, output_channels=8, name='moves_left') h_conv_mov_flat = tf.keras.layers.Flatten()(conv_mov) h_fc4 = tf.keras.layers.Dense( 128, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, activation='relu', name='moves_left/dense1')(h_conv_mov_flat) h_fc5 = tf.keras.layers.Dense(1, kernel_initializer='glorot_normal', kernel_regularizer=self.l2reg, activation='relu', name='moves_left/dense2')(h_fc4) else: h_fc5 = None return h_fc1, h_fc3, h_fc5
def __init__(self, cfg): self.cfg = cfg self.net = Net() self.root_dir = os.path.join(self.cfg['training']['path'], self.cfg['name']) # Network structure self.RESIDUAL_FILTERS = self.cfg['model']['filters'] self.RESIDUAL_BLOCKS = self.cfg['model']['residual_blocks'] self.SE_ratio = self.cfg['model']['se_ratio'] self.policy_channels = self.cfg['model'].get('policy_channels', 32) precision = self.cfg['training'].get('precision', 'single') loss_scale = self.cfg['training'].get('loss_scale', 128) self.virtual_batch_size = self.cfg['model'].get( 'virtual_batch_size', None) if precision == 'single': self.model_dtype = tf.float32 elif precision == 'half': self.model_dtype = tf.float16 else: raise ValueError("Unknown precision: {}".format(precision)) # Scale the loss to prevent gradient underflow self.loss_scale = 1 if self.model_dtype == tf.float32 else loss_scale policy_head = self.cfg['model'].get('policy', 'convolution') value_head = self.cfg['model'].get('value', 'wdl') moves_left_head = self.cfg['model'].get('moves_left', 'v1') input_mode = self.cfg['model'].get('input_type', 'classic') self.POLICY_HEAD = None self.VALUE_HEAD = None self.MOVES_LEFT_HEAD = None self.INPUT_MODE = None if policy_head == "classical": self.POLICY_HEAD = pb.NetworkFormat.POLICY_CLASSICAL elif policy_head == "convolution": self.POLICY_HEAD = pb.NetworkFormat.POLICY_CONVOLUTION else: raise ValueError( "Unknown policy head format: {}".format(policy_head)) self.net.set_policyformat(self.POLICY_HEAD) if value_head == "classical": self.VALUE_HEAD = pb.NetworkFormat.VALUE_CLASSICAL self.wdl = False elif value_head == "wdl": self.VALUE_HEAD = pb.NetworkFormat.VALUE_WDL self.wdl = True else: raise ValueError( "Unknown value head format: {}".format(value_head)) self.net.set_valueformat(self.VALUE_HEAD) if moves_left_head == "none": self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_NONE self.moves_left = False elif moves_left_head == "v1": self.MOVES_LEFT_HEAD = pb.NetworkFormat.MOVES_LEFT_V1 self.moves_left = True else: raise ValueError( "Unknown moves left head format: {}".format(moves_left_head)) self.net.set_movesleftformat(self.MOVES_LEFT_HEAD) if input_mode == "classic": self.INPUT_MODE = pb.NetworkFormat.INPUT_CLASSICAL_112_PLANE elif input_mode == "frc_castling": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CASTLING_PLANE elif input_mode == "canonical": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION elif input_mode == "canonical_100": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES elif input_mode == "canonical_armageddon": self.INPUT_MODE = pb.NetworkFormat.INPUT_112_WITH_CANONICALIZATION_HECTOPLIES_ARMAGEDDON else: raise ValueError( "Unknown input mode format: {}".format(input_mode)) self.net.set_input(self.INPUT_MODE) self.swa_enabled = self.cfg['training'].get('swa', False) # Limit momentum of SWA exponential average to 1 - 1/(swa_max_n + 1) self.swa_max_n = self.cfg['training'].get('swa_max_n', 0) self.renorm_enabled = self.cfg['training'].get('renorm', False) self.renorm_max_r = self.cfg['training'].get('renorm_max_r', 1) self.renorm_max_d = self.cfg['training'].get('renorm_max_d', 0) self.renorm_momentum = self.cfg['training'].get( 'renorm_momentum', 0.99) gpus = tf.config.experimental.list_physical_devices('GPU') tf.config.experimental.set_visible_devices(gpus[self.cfg['gpu']], 'GPU') tf.config.experimental.set_memory_growth(gpus[self.cfg['gpu']], True) if self.model_dtype == tf.float16: tf.keras.mixed_precision.experimental.set_policy('mixed_float16') self.global_step = tf.Variable(0, name='global_step', trainable=False, dtype=tf.int64)
def train(): check_point_path = '' transform = transforms.Compose([transforms.Scale(IMAGE_SIZE), transforms.CenterCrop(IMAGE_SIZE), transforms.ToTensor(), transforms.Lambda(lambda x: x.mul(255))]) train_dataset = datasets.ImageFolder(DATASET_FOLDER, transform) train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE) style_model = Net(ngf=FILTER_CHANNEL, dv=device).to(device) if RESUME is not None: print('Resuming, initializing using weight from {}.'.format(RESUME)) style_model.load_state_dict(torch.load(RESUME)) print(style_model) optimizer = Adam(style_model.parameters(), LEARNING_RATE) mse_loss = torch.nn.MSELoss() vgg = Vgg16() utils.init_vgg16(VGG_DIR) vgg.load_state_dict(torch.load(os.path.join(VGG_DIR, "vgg16.weight"))) vgg.to(device) style_loader = utils.StyleLoader(STYLE_FOLDER, IMAGE_SIZE, device) tbar = tqdm(range(EPOCHS)) for e in tbar: style_model.train() agg_content_loss = 0. agg_style_loss = 0. count = 0 for batch_id, (x, _) in enumerate(train_loader): n_batch = len(x) count += n_batch optimizer.zero_grad() x = Variable(utils.preprocess_batch(x)).to(device) style_v = style_loader.get(batch_id) style_model.setTarget(style_v) style_v = utils.subtract_imagenet_mean_batch(style_v, device) features_style = vgg(style_v) gram_style = [utils.gram_matrix(y) for y in features_style] y = style_model(x) xc = Variable(x.data.clone()) y = utils.subtract_imagenet_mean_batch(y, device) xc = utils.subtract_imagenet_mean_batch(xc, device) features_y = vgg(y) features_xc = vgg(xc) f_xc_c = Variable(features_xc[1].data, requires_grad=False) content_loss = CONT_WEIGHT * mse_loss(features_y[1], f_xc_c) style_loss = 0. for m in range(len(features_y)): gram_y = utils.gram_matrix(features_y[m]) gram_s = Variable(gram_style[m].data, requires_grad=False).repeat(BATCH_SIZE, 1, 1, 1) style_loss += STYLE_WEIGHT * mse_loss(gram_y.unsqueeze_(1), gram_s[:n_batch, :, :]) total_loss = content_loss + style_loss total_loss.backward() optimizer.step() agg_content_loss += content_loss.data[0] agg_style_loss += style_loss.data[0] if (batch_id + 1) % 100 == 0: mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format( time.ctime(), e + 1, count, len(train_dataset), agg_content_loss / (batch_id + 1), agg_style_loss / (batch_id + 1), (agg_content_loss + agg_style_loss) / (batch_id + 1) ) tbar.set_description(mesg) if (batch_id + 1) % (4 * 100) == 0: # save model style_model.eval() style_model.cpu() save_model_filename = "Epoch_" + str(e) + "iters_" + str(count) + "_" + str(time.ctime()).replace(' ', '_') + "_" + str( CONT_WEIGHT) + "_" + str(STYLE_WEIGHT) + ".model" save_model_path = os.path.join(SAVE_MODEL_DIR, save_model_filename) torch.save(style_model.state_dict(), save_model_path) if check_point_path: os.remove(check_point_path) check_point_path = save_model_path style_model.train() style_model.cuda() tbar.set_description("\nCheckpoint, trained model saved at", save_model_path) # save model style_model.eval() style_model.cpu() save_model_filename = "Final_epoch_" + str(EPOCHS) + "_" + str(time.ctime()).replace(' ', '_') + "_" + str( CONT_WEIGHT) + "_" + str(STYLE_WEIGHT) + ".model" save_model_path = os.path.join(SAVE_MODEL_DIR, save_model_filename) torch.save(style_model.state_dict(), save_model_path) print("\nDone, trained model saved at", save_model_path)
import os import cv2 import pickle from skimage import color from net import Net from utils import * import tensorflowjs as tfjs img = cv2.imread('./demo/ILSVRC2012_val_00046524.JPEG') img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_rgb = (img_rgb.astype(dtype=np.float32)) / 255.0 img_rs = cv2.resize(img_rgb, (224, 224), interpolation=cv2.INTER_NEAREST) img_lab_rs = color.rgb2lab(img_rs) img_l_rs = img_lab_rs[:, :, 0] - 50 img_l_rs = img_l_rs[None, :, :, None] autocolor = Net(train=False) model = autocolor.create_model([1, 224, 224, 1]) file_name = '{}.pkl'.format('caffe_weights') with open(file_name, 'rb') as f: layer_dict = pickle.load(f) layer_name_dict = dict([(layer.name, i) for i, layer in enumerate(model.layers)]) for layer in layer_dict: if layer['type'] != 'Convolution' and layer['type'] != 'Deconvolution': continue if layer['name'] == 'class8_ab': continue
from net import Net net = Net() x = net.variable(1) y = net.variable(2) z = net.variable(3) x2 = net.mul(x, x) y2 = net.mul(y, y) z2 = net.mul(z, z) o1 = net.add(x2, y2) o = net.add(o1, z2) net.gradient_descendent() print('x=', x.v, 'y=', y.v, 'z=', z.v)
import torch import cv2 import numpy as np from torch.autograd import Variable from net import Net from util import prep_image def get_test_input(): img = cv2.imread("dog-cycle-car.png") img = cv2.resize(img, (416, 416)) # Resize to the input dimension img_ = img[:, :, ::-1].transpose((2, 0, 1)) # BGR -> RGB | H X W C -> C X H X W img_ = img_[np.newaxis, :, :, :] / 255.0 # Add a channel at 0 (for batch) | Normalise img_ = torch.from_numpy(img_).float() # Convert to float img_ = Variable(img_) # Convert to Variable return img_ model = Net("cfg/yolov3.cfg") inp = prep_image(cv2.imread("image/dog-cycle-car.png"), int(model.net_info['width'])) pred = model(inp) print(pred)
net = Net( module=RNNModel, max_epochs=args.epochs, batch_size=args.batch_size, use_cuda=args.cuda, callbacks=[ skorch.callbacks.Checkpoint(), skorch.callbacks.ProgressBar(), LRAnnealing(), ExamplePrinter() ], module__rnn_type='LSTM', module__ntoken=ntokens, module__ninp=200, module__nhid=200, module__nlayers=2, # Use (corpus.train, corpus.valid) as validation split. # Even though we are doing a grid search, we use an internal # validation set to determine when to save (Checkpoint callback) # and when to decrease the learning rate (LRAnnealing callback). train_split=my_train_split, # To demonstrate that skorch is able to use already available # data loaders as well, we use the data loader from the word # language model. iterator_train=data.Loader, iterator_train__use_cuda=args.cuda, iterator_train__bptt=args.bptt, iterator_valid=data.Loader, iterator_valid__use_cuda=args.cuda, iterator_valid__bptt=args.bptt)
def preprocessing(x): x = np.expand_dims(x, 1) x = x.astype(np.float) x /= 255.0 x -= x.mean() x /= x.std() return x x = preprocessing(x) xt = preprocessing(xt) #x = np.random.random((n, 1, 28, 28)) #y = np.random.randint(2, size=(n)) # Model net = Net() net.push(Conv2d(5, 5, 1, 6)) # 1x28x28 -> 6x24x24 net.push(Relu()) net.push(Maxpooling(2, 2)) # 6x24x24 -> 6x12x12 net.push(Conv2d(5, 5, 6, 16)) # 6x12x12 -> 16x8x8 net.push(Relu()) net.push(Maxpooling(2, 2)) # 16x8x8 -> 16x4x4 net.push(Reshape((256))) net.push(Linear(256, 84)) net.push(Relu()) net.push(Softmax(84, 10)) # Data data = DataProvider() n = 10000 data.train_input(x[:n], y[:n])
def test_pg(args=get_args()): env = gym.make(args.task) args.state_shape = env.observation_space.shape or env.observation_space.n args.action_shape = env.action_space.shape or env.action_space.n # train_envs = gym.make(args.task) # you can also use tianshou.env.SubprocVectorEnv train_envs = VectorEnv( [lambda: gym.make(args.task) for _ in range(args.training_num)]) # test_envs = gym.make(args.task) test_envs = VectorEnv( [lambda: gym.make(args.task) for _ in range(args.test_num)]) # seed np.random.seed(args.seed) torch.manual_seed(args.seed) train_envs.seed(args.seed) test_envs.seed(args.seed) # model net = Net(args.layer_num, args.state_shape, args.action_shape, device=args.device, softmax=True) net = net.to(args.device) optim = torch.optim.Adam(net.parameters(), lr=args.lr) dist = torch.distributions.Categorical policy = PGPolicy(net, optim, dist, args.gamma) # collector train_collector = Collector(policy, train_envs, ReplayBuffer(args.buffer_size)) test_collector = Collector(policy, test_envs) # log log_path = os.path.join(args.logdir, args.task, 'pg') writer = SummaryWriter(log_path) def save_fn(policy): torch.save(policy.state_dict(), os.path.join(log_path, 'policy.pth')) def stop_fn(x): return x >= env.spec.reward_threshold # trainer result = onpolicy_trainer(policy, train_collector, test_collector, args.epoch, args.step_per_epoch, args.collect_per_step, args.repeat_per_collect, args.test_num, args.batch_size, stop_fn=stop_fn, save_fn=save_fn, writer=writer) assert stop_fn(result['best_reward']) train_collector.close() test_collector.close() if __name__ == '__main__': pprint.pprint(result) # Let's watch its performance! env = gym.make(args.task) collector = Collector(policy, env) result = collector.collect(n_episode=1, render=args.render) print(f'Final reward: {result["rew"]}, length: {result["len"]}') collector.close()
def loadModel(): global ANN, learningRate, patienceThreshold, fileName ANN = Net.loadModel(fileName) ANN.patienceThreshold = patienceThreshold ANN.setLearningRate(learningRate)
) # 检查cuda是否可用 use_cuda = torch.cuda.is_available() # 生成log now_time = datetime.now() time_str = datetime.strftime(now_time, '%m-%d_%H-%M-%S') log_path = os.path.join(os.getcwd(), "log") log_dir = os.path.join(log_path, time_str) if not os.path.exists(log_dir): os.makedirs(log_dir) writer = SummaryWriter(log_dir) # ---------------------搭建网络-------------------------- cnn = Net() # 创建CNN cnn.init_weights() # 初始化权值 cnn = cnn.double() # --------------------设置损失函数和优化器---------------------- optimizer = optim.Adam(cnn.parameters()) # lr:(default: 1e-3)优化器 criterion = nn.CrossEntropyLoss() # 损失函数 scheduler = torch.optim.lr_scheduler.StepLR( optimizer, step_size=EPOCH/2, gamma=0.5) # 设置学习率下降策略 # --------------------训练------------------------------ if(use_cuda): # 使用GPU cnn = cnn.cuda() for epoch in range(EPOCH): loss_sigma = 0.0 # 记录一个epoch的loss之和 correct = 0.0
from keras.preprocessing.image import ImageDataGenerator import matplotlib.pyplot as plt from keras import optimizers from net import Net # creating modelNameName wdthIm, hghtIm = 32, 32 # set image size channelNo = 3 # set image number data_dir_train = 'test_together/' data_dirc_validation = 'test_together/' epochNo = 120 batchSize = 52 modelName = Net.build(width=wdthIm, height=hghtIm, depth=channelNo) #modelName name print('building done!!') Rms = optimizers.Rmsprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0) #compiling model print('optimizing done!!') modelName.compile(loss='categorical_crossentropy', optimizer=Rms, metrics=['accuracy']) print('compiling.....') train_datagenerator = ImageDataGenerator( featurewise_centering=True, featurewise_std_normaliztn=True, shear_ranges=0.1, zoom_ranges=0.1, rotation_ranges=5,
from torch import jit from net import Net import torch if __name__ == '__main__': model = Net() model.load_state_dict(torch.load("./params/9.t")) # 模拟一个输入 input = torch.randn(1, 784) # 打包 traced_script_moudle = torch.jit.trace(model, input) traced_script_moudle.save("mnist.pt")
def train_regression(config, checkpoint_dir=None, data_dir=None): net = Net(config["l1"], config["l2"]) net.to(device) criterion = nn.MSELoss() optimizer = optim.Adam(net.parameters(), lr=config["lr"]) # if checkpoint_dir: # model_state, optimizer_state = torch.load( # os.path.join(checkpoint_dir, "checkpoint")) # net.load_state_dict(model_state) # optimizer.load_state_dict(optimizer_state) trainset = get_dataloader(data_dir, 'train') valset = get_dataloader(data_dir, 'validation') trainloader = torch.utils.data.DataLoader(trainset, batch_size=int( config["batch_size"])) valloader = torch.utils.data.DataLoader(valset, batch_size=int( config["batch_size"])) for epoch in range(50): # loop over the dataset multiple times running_loss = 0.0 epoch_steps = 0 for i, data in enumerate(trainloader, 0): # get the inputs; data is a list of [inputs, labels] inputs, labels = data inputs, labels = inputs.to(device), labels.to(device) # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = torch.sqrt(criterion(outputs, labels)) loss.backward() optimizer.step() # print statistics running_loss += loss.item() epoch_steps += 1 if i % 2000 == 1999: # print every 2000 mini-batches print("[%d, %5d] loss: %.3f" % (epoch + 1, i + 1, running_loss / epoch_steps)) running_loss = 0.0 # Validation loss val_loss = 0.0 val_steps = 0 total = 0 correct = 0 for i, data in enumerate(valloader, 0): with torch.no_grad(): inputs, labels = data inputs, labels = inputs.to(device), labels.to(device) outputs = net(inputs) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) loss = torch.sqrt(criterion(outputs, labels)) val_loss += loss.cpu().numpy() val_steps += 1 with tune.checkpoint_dir(epoch) as checkpoint_dir: path = os.path.join(checkpoint_dir, "checkpoint") torch.save((net.state_dict(), optimizer.state_dict()), path) tune.report(loss=(val_loss / val_steps)) print("Finished Training")
def main(): # Training settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--batch-size', type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument("--index-array", help="lr array", type=int, default=None) parser.add_argument("-o", help="save folder", default=None) args = parser.parse_args() if args.index_array is not None: lin = np.linspace(0.0001, 0.5, 50) args.lr = lin[args.index_array] prep_output(args) use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} train_loader = torch.utils.data.DataLoader( datasets.MNIST('../data', train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])), batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader( datasets.MNIST('../data', train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])), batch_size=args.test_batch_size, shuffle=True, **kwargs) model = Net().to(device) optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) if args.o is not None: f = open(os.path.join(args.o, "log.csv"), "w") print("epoch, loss, test loss, test acc", file=f) for epoch in tqdm(range(1, args.epochs + 1), desc="epoch"): loss = train(args, model, device, train_loader, optimizer, epoch) test_loss, acc = test(args, model, device, test_loader) if args.o is not None: print("%d, %f, %f, %.2f" % (epoch, loss, test_loss, acc), file=f)
class Solver_Heatmap(object): def __init__(self, train=True, common_params=None, solver_params=None, net_params=None, dataset_params=None): if common_params: self.device_id = int(common_params['gpus']) self.image_size = int(common_params['image_size']) self.height = self.image_size self.width = self.image_size self.batch_size = int(common_params['batch_size']) self.num_gpus = 1 self.restore_model = True self.logs_dir = "logs/" self.data_dir = "Data_zoo/flowers" if solver_params: self.learning_rate = float(solver_params['learning_rate']) self.moment = float(solver_params['moment']) self.max_steps = int(solver_params['max_iterators']) self.train_dir = str(solver_params['train_dir']) self.lr_decay = float(solver_params['lr_decay']) self.decay_steps = int(solver_params['decay_steps']) self.train = train self.net = Net(train=train, common_params=common_params, net_params=net_params) #self.dataset = DataSet(common_params=common_params, dataset_params=dataset_params) self.train_images, self.test_images = flowers.read_dataset(self.data_dir) image_options = {"resize": True, "resize_size": 224, "color": "LAB"} self.batch_reader = dataset.BatchDatset(self.train_images, image_options) self.batch_reader_test = dataset.BatchDatset(self.test_images, image_options) def construct_graph(self, scope): with tf.device('/gpu:' + str(self.device_id)): self.data_l = tf.placeholder(tf.float32, (self.batch_size, self.height, self.width, 1)) self.gt_ab_313 = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 313)) self.prior_boost_nongray = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 1)) self.conv8_313 = self.net.inference(self.data_l) new_loss, g_loss = self.net.loss_heatmap(scope, self.conv8_313, self.prior_boost_nongray, self.gt_ab_313) tf.summary.scalar('new_loss', new_loss) tf.summary.scalar('total_loss', g_loss) return new_loss, g_loss, self.conv8_313 def pred_image(self, images): #img = img[None, :, :, None] #data_l = (img.astype(dtype=np.float32)) / 255.0 * 100 - 50 #data_l = tf.placeholder(tf.float32, shape=(None, None, None, 1)) autocolor = Net(train=False) conv8_313 = autocolor.inference(images) return conv8_313 #imsave('color.jpg', img_rgb) def train_model(self): with tf.device('/gpu:' + str(self.device_id)): tf.reset_default_graph() self.global_step = tf.get_variable('global_step', [], initializer=tf.constant_initializer(0), trainable=False) learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps, self.lr_decay, staircase=True) opt = tf.train.AdamOptimizer(learning_rate=learning_rate, beta2=0.99) images = tf.placeholder(tf.float32, shape=[None, None, None, 1], name='L_image') with tf.name_scope('gpu') as scope: self.data_l = tf.placeholder(tf.float32, (self.batch_size, self.height, self.width, 1)) self.gt_ab_313 = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 313)) self.prior_boost_nongray = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 1)) self.heat_maps = tf.placeholder(tf.float32, (self.batch_size, int(self.height / 4), int(self.width / 4), 313), name="heat_map") conv8_313 = self.net.inference(self.data_l) new_loss, g_loss = self.net.loss_heatmap(scope, conv8_313, self.prior_boost_nongray, self.gt_ab_313, self.heat_maps) tf.summary.scalar('new_loss', new_loss) tf.summary.scalar('total_loss', g_loss) self.total_loss = g_loss self.summaries = tf.get_collection(tf.GraphKeys.SUMMARIES, scope) grads = opt.compute_gradients(new_loss) self.summaries.append(tf.summary.scalar('learning_rate', learning_rate)) for grad, var in grads: if grad is not None: self.summaries.append(tf.summary.histogram(var.op.name + '/gradients', grad)) apply_gradient_op = opt.apply_gradients(grads, global_step=self.global_step) for var in tf.trainable_variables(): self.summaries.append(tf.summary.histogram(var.op.name, var)) variable_averages = tf.train.ExponentialMovingAverage( 0.999, self.global_step) variables_averages_op = variable_averages.apply(tf.trainable_variables()) train_op = tf.group(apply_gradient_op, variables_averages_op, conv8_313) saver = tf.train.Saver(write_version=1) summary_op = tf.summary.merge(self.summaries) init = tf.global_variables_initializer() config = tf.ConfigProto(allow_soft_placement=True) config.gpu_options.allow_growth = True sess = tf.Session(config=config) sess.run(init) #saver1.restore(sess, './models/model.ckpt') #nilboy if self.restore_model: ckpt = tf.train.get_checkpoint_state(self.logs_dir + 'model_without_heatmap/') if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) print("Model restored...") summary_writer = tf.summary.FileWriter(self.train_dir, sess.graph) for step in range(self.max_steps): print(step) start_time = time.time() t1 = time.time() data_l, gt_ab_313, prior_boost_nongray,color_image, hm_ab_313 = self.batch_reader.next_batch(16) t2 = time.time() _, loss_value = sess.run([train_op, self.total_loss], feed_dict={self.data_l:data_l, self.gt_ab_313:gt_ab_313, self.prior_boost_nongray:prior_boost_nongray, self.heat_maps:hm_ab_313}) duration = time.time() - start_time t3 = time.time() print('io: ' + str(t2 - t1) + '; compute: ' + str(t3 - t2)) assert not np.isnan(loss_value), 'Model diverged with loss = NaN' if step % 1 == 0: num_examples_per_step = self.batch_size * self.num_gpus examples_per_sec = num_examples_per_step / duration sec_per_batch = duration / self.num_gpus format_str = ('%s: step %d, loss = %.2f (%.1f examples/sec; %.3f ' 'sec/batch)') print (format_str % (datetime.now(), step, loss_value, examples_per_sec, sec_per_batch)) if step % 10 == 0: summary_str = sess.run(summary_op, feed_dict={self.data_l:data_l, self.gt_ab_313:gt_ab_313, self.prior_boost_nongray:prior_boost_nongray, self.heat_maps:hm_ab_313}) summary_writer.add_summary(summary_str, step) # Save the model checkpoint periodically. if step % 100 == 0: checkpoint_path = os.path.join(self.train_dir, 'model.ckpt') saver.save(sess, self.logs_dir + "model_with_heatmap/model.ckpt", global_step=step) pred = sess.run(conv8_313, feed_dict={self.data_l:data_l, self.gt_ab_313:gt_ab_313, self.prior_boost_nongray:prior_boost_nongray}) idx = np.random.randint(0, self.batch_size) save_dir = os.path.join(self.logs_dir, "image_checkpoints") save_image(color_image[idx], save_dir, "gt" + str(step // 1)) print (pred[idx].shape) #pred[idx] = tf.expand_dims(pred[idx], 0) #print (pred[idx].shape) predict = decode(data_l[idx:idx+1], pred[idx:idx+1],2.63) save_image(predict.astype(np.float64), save_dir, "pred" + str(step // 1)) print("%s --> Model saved" % datetime.now()) if step % 1000 == 0: count = 16 data_l_test, gt_ab_313_test, prior_boost_nongray_test, color_image_test, hm_ab_313 = self.batch_reader_test.get_random_batch(count) feed_dict = {self.data_l:data_l_test, self.gt_ab_313:gt_ab_313_test, self.prior_boost_nongray:prior_boost_nongray_test} save_dir = os.path.join(self.logs_dir, "image_pred_withhm/") pred = sess.run(conv8_313, feed_dict=feed_dict) for itr in range(count): save_image(color_image_test[itr], save_dir, "gt" + str(itr)) predict = decode(data_l_test[itr:itr+1], pred[itr:itr+1],2.63) save_image(predict, save_dir, "pred" + str(itr)) print("--- Images saved on test run ---")
class Brain(object): def __init__(self, num_states, num_actions, opt={}): """ in number of time steps, of temporal memory the ACTUAL input to the net will be (x,a) temporal_window times, and followed by current x so to have no information from previous time step going into value function, set to 0. """ self.temporal_window = getopt(opt, 'temporal_window', 1) """size of experience replay memory""" self.experience_size = getopt(opt, 'experience_size', 30000) """number of examples in experience replay memory before we begin learning""" self.start_learn_threshold = getopt(opt, 'start_learn_threshold', int(min(self.experience_size * 0.1, 1000))) """gamma is a crucial parameter that controls how much plan-ahead the agent does. In [0,1]""" self.gamma = getopt(opt, 'gamma', 0.8) """number of steps we will learn for""" self.learning_steps_total = getopt(opt, 'learning_steps_total', 100000) """how many steps of the above to perform only random actions (in the beginning)?""" self.learning_steps_burnin = getopt(opt, 'learning_steps_burnin', 3000) """what epsilon value do we bottom out on? 0.0 => purely deterministic policy at end""" self.epsilon_min = getopt(opt, 'epsilon_min', 0.05) """what epsilon to use at test time? (i.e. when learning is disabled)""" self.epsilon_test_time = getopt(opt, 'epsilon_test_time', 0.01) """ advanced feature. Sometimes a random action should be biased towards some values for example in flappy bird, we may want to choose to not flap more often """ if 'random_action_distribution' in opt: #this better sum to 1 by the way, and be of length this.num_actions self.random_action_distribution = opt['random_action_distribution'] if len(self.random_action_distribution) != num_actions: print 'TROUBLE. random_action_distribution should be same length as num_actions.' a = self.random_action_distribution s = sum(a) if abs(s - 1.0) > 0.0001: print 'TROUBLE. random_action_distribution should sum to 1!' else: self.random_action_distribution = [] """ states that go into neural net to predict optimal action look as x0,a0,x1,a1,x2,a2,...xt this variable controls the size of that temporal window. Actions are encoded as 1-of-k hot vectors """ self.net_inputs = num_states * self.temporal_window + num_actions * self.temporal_window + num_states self.num_states = num_states self.num_actions = num_actions self.window_size = max(self.temporal_window, 2) #must be at least 2, but if we want more context even more self.state_window = zeros(self.window_size) self.action_window = zeros(self.window_size) self.reward_window = zeros(self.window_size) self.net_window = zeros(self.window_size) #create [state -> value of all possible actions] modeling net for the value function layers = [] if 'layers' in opt: """ this is an advanced usage feature, because size of the input to the network, and number of actions must check out. """ layers = opt['layers'] if len(layers) < 2: print 'TROUBLE! must have at least 2 layers' if layers[0]['type'] != 'input': print 'TROUBLE! first layer must be input layer!' if layers[-1]['type'] != 'regression': print 'TROUBLE! last layer must be input regression!' if layers[0]['out_depth'] * layers[0]['out_sx'] * layers[0]['out_sy'] != self.net_inputs: print 'TROUBLE! Number of inputs must be num_states * temporal_window + num_actions * temporal_window + num_states!' if layers[-1]['num_neurons'] != self.num_actions: print 'TROUBLE! Number of regression neurons should be num_actions!' else: #create a very simple neural net by default layers.append({'type': 'input', 'out_sx': 1, 'out_sy': 1, 'out_depth': self.net_inputs}) if 'hidden_layer_sizes' in opt: #allow user to specify this via the option, for convenience for size in opt['hidden_layer_sizes']: layers.append({'type': 'fc', 'num_neurons': size, 'activation': 'relu'}) layers.append({'type': 'regression', 'num_neurons': self.num_actions}) #value function output self.value_net = Net(layers) #and finally we need a Temporal Difference Learning trainer! trainer_ops_default = {'learning_rate': 0.01, 'momentum': 0.0, 'batch_size': 64, 'l2_decay': 0.01} tdtrainer_options = getopt(opt, 'tdtrainer_options', trainer_ops_default) self.tdtrainer = Trainer(self.value_net, tdtrainer_options) #experience replay self.experience = [] #various housekeeping variables self.age = 0 #incremented every backward() self.forward_passes = 0 #incremented every forward() self.epsilon = 1.0 #controls exploration exploitation tradeoff. Should be annealed over time self.latest_reward = 0 self.last_input_array = [] self.average_reward_window = Window(1000, 10) self.average_loss_window = Window(1000, 10) self.learning = True def random_action(self): """ a bit of a helper function. It returns a random action we are abstracting this away because in future we may want to do more sophisticated things. For example some actions could be more or less likely at "rest"/default state. """ if len(random_action_distribution) == 0: return randi(0, self.num_actions) else: #okay, lets do some fancier sampling p = randf(0, 1.0) cumprob = 0.0 for k in xrange(self.num_actions): cumprob += self.random_action_distribution[k] if p < cumprob: return k def policy(self, s): """ compute the value of doing any action in this state and return the argmax action and its value """ V = Vol(s) action_values = self.value_net.forward(V) weights = action_values.w max_val = max(weights) max_k = weights.index(maxval) return { 'action': max_k, 'value': max_val } def getNetInput(self, xt): """ return s = (x,a,x,a,x,a,xt) state vector It's a concatenation of last window_size (x,a) pairs and current state x """ w = [] w.extend(xt) #start with current state #and now go backwards and append states and actions from history temporal_window times n = self.window_size for k in xrange(self.temporal_window): index = n - 1 - k w.extend(self.state_window[index]) #state #action, encoded as 1-of-k indicator vector. We scale it up a bit because #we dont want weight regularization to undervalue this information, as it only exists once action1ofk = zeros(self.num_actions) action1ofk[index] = 1.0 * self.num_states w.extend(action1ofk) return w def forward(self, input_array): self.forward_passes += 1 self.last_input_array = input_array # create network input action = None if self.forward_passes > self.temporal_window: #we have enough to actually do something reasonable net_input = self.getNetInput(input_array) if self.learning: #compute epsilon for the epsilon-greedy policy self.epsilon = min( 1.0, max( self.epsilon_min, 1.0 - \ (self.age - self.learning_steps_burnin) / \ (self.learning_steps_total - self.learning_steps_burnin) ) ) else: self.epsilon = self.epsilon_test_time #use test-time value rf = randf(0, 1) if rf < self.epsilon: #choose a random action with epsilon probability action = self.random_action() else: #otherwise use our policy to make decision maxact = self.policy(net_input) action = maxact['action'] else: #pathological case that happens first few iterations #before we accumulate window_size inputs net_input = [] action = self.random_action() #remember the state and action we took for backward pass self.net_window.pop(0) self.net_window.append(net_input) self.state_window.pop(0) self.state_window.append(input_array) self.action_window.pop(0) self.action_window.append(action) def backward(self, reward): self.latest_reward = reward self.average_reward_window.add(reward) self.reward_window.pop(0) self.reward_window.append(reward) if not self.learning: return self.age += 1 #it is time t+1 and we have to store (s_t, a_t, r_t, s_{t+1}) as new experience #(given that an appropriate number of state measurements already exist, of course) if self.forward_passes > self.temporal_window + 1: n = self.window_size e = Experience( self.net_window[n - 2], self.action_window[n - 2], self.reward_window[n - 2], self.net_window[n - 1] ) if len(self.experience) < self.experience_size: self.experience.append(e) else: ri = randi(0, self.experience_size) self.experience[ri] = e #learn based on experience, once we have some samples to go on #this is where the magic happens... if len(self.experience) > self.start_learn_threshold: avcost = 0.0 for k in xrange(self.tdtrainer.batch_size): re = randi(0, len(self.experience)) e = self.experience[re] x = Vol(1, 1, self.net_inputs) x.w = e.state0 maxact = self.policy(e.state1) r = e.reward0 + self.gamma * maxact.value ystruct = {'dim': e.action0, 'val': r} stats = self.tdtrainer.train(x, ystruct) avcost += stats['loss'] avcost /= self.tdtrainer.batch_size self.average_loss_window.add(avcost)
def __init__(self): self.quality = '' self.net = Net()
class Dagger(): def __init__(self, grid, mdp, moves=40): self.grid = grid self.mdp = mdp self.svm = LinearSVM(grid, mdp) self.net = Net(grid,mdp) self.moves = moves #self.reward = np.zeros(40) self.super_pi = mdp.pi self.reward = np.zeros(self.moves) self.animate = False self.record = True self.recent_rollout_states = None def rollout(self): self.grid.reset_mdp() self.reward = np.zeros(self.moves) self.recent_rollout_states = [self.mdp.state] self.mistakes = 0.0 for t in range(self.moves): if self.record: assert self.super_pi.desc == ClassicPolicy.desc self.net.add_datum(self.mdp.state, self.super_pi.get_next(self.mdp.state)) #Get current state and action x_t = self.mdp.state a_t = self.mdp.pi.get_next(x_t) self.compare_policies(x_t, a_t) #Take next step self.grid.step(self.mdp) x_t_1 = self.mdp.state #Evaualte reward recieved self.reward[t] = self.grid.reward(x_t,a_t,x_t_1) self.recent_rollout_states.append(self.mdp.state) if(self.animate): self.grid.show_recording() #print self.svm.data def compare_policies(self, x, a): if self.super_pi.get_next(x) != a: self.mistakes += 1 def get_states(self): return self.net.get_states() def get_reward(self): return np.sum(self.reward) def set_supervisor_pi(self, pi): self.super_pi = pi def get_loss(self): return float(self.mistakes) / float(self.moves) def get_recent_rollout_states(self): N = len(self.recent_rollout_states) states = np.zeros([N,2]) for i in range(N): x = self.recent_rollout_states[i].toArray() states[i,:] = x return states def retrain(self): self.net.fit() self.mdp.pi = NetPolicy(self.net)
"""random split TODO: various distribution methods """ splited_trainset = torch.utils.data.random_split( trainset, [int(len(trainset) / ns) for _ in range(ns)]) splited_testset = torch.utils.data.random_split( testset, [int(len(testset) / ns) for _ in range(ns)]) # print(len(splited_trainset[0]), len(splited_trainset[1]), len(splited_trainset[2])) """set nodes""" clients = [] for i in range(ns): clients.append( Client(trainset=splited_trainset[i], testset=splited_testset[i], net=Net(), _id=i)) tmp_client = Client( # tmp trainset=None, testset=splited_testset[i], net=Net(), _id=-1) """set DAG""" global_id = -1 nodes = [] genesis = Node(r=-1, w=clients[0].get_weights(), _id=global_id) nodes.append(genesis) global_id += 1 """run simulator""" latest_nodes = deepcopy(nodes) # in DAG for r in range(rs):
#libs = [] libs = ["/mnt/Multimedia_NV/","/mnt/Anime/Filmes/","/mnt/Filmes/"] plexserver = "192.168.1.71" finalpath = True finalpathloc = "/mnt/Filmes/Filmes" filepath = "movieList.txt" deleteonError = True plexUpdate = True user_agent = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:40.0) Gecko/20100101 Firefox/40.0' cf_cookie_file = os.path.join(os.path.dirname(__file__), 'tugaio.cache') net = Net() net.set_cookies(cf_cookie_file) net.set_user_agent(user_agent) #####Codigo Addon Kodi def cf_decrypt_ddos(url, agent, cookie_file): class NoRedirection(urllib2.HTTPErrorProcessor): def http_response(self, request, response): return response if len(agent) == 0: agent = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:6.0) Gecko/20100101 Firefox/6.0' cj = cookielib.CookieJar() opener = urllib2.build_opener(NoRedirection, urllib2.HTTPCookieProcessor(cj))
def train(args): check_paths(args) np.random.seed(args.seed) torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) kwargs = {'num_workers': 0, 'pin_memory': False} else: kwargs = {} transform = transforms.Compose([ transforms.Scale(args.image_size), transforms.CenterCrop(args.image_size), transforms.ToTensor(), transforms.Lambda(lambda x: x.mul(255)) ]) train_dataset = datasets.ImageFolder(args.dataset, transform) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, **kwargs) style_model = Net(ngf=args.ngf) if args.resume is not None: print('Resuming, initializing using weight from {}.'.format( args.resume)) style_model.load_state_dict(torch.load(args.resume)) print(style_model) optimizer = Adam(style_model.parameters(), args.lr) mse_loss = torch.nn.MSELoss() vgg = Vgg16() utils.init_vgg16(args.vgg_model_dir) vgg.load_state_dict( torch.load(os.path.join(args.vgg_model_dir, "vgg16.weight"))) if args.cuda: style_model.cuda() vgg.cuda() style_loader = utils.StyleLoader(args.style_folder, args.style_size) tbar = trange(args.epochs) for e in tbar: style_model.train() agg_content_loss = 0. agg_style_loss = 0. count = 0 for batch_id, (x, _) in enumerate(train_loader): n_batch = len(x) count += n_batch optimizer.zero_grad() x = Variable(utils.preprocess_batch(x)) if args.cuda: x = x.cuda() style_v = style_loader.get(batch_id) style_model.setTarget(style_v) style_v = utils.subtract_imagenet_mean_batch(style_v) features_style = vgg(style_v) gram_style = [utils.gram_matrix(y) for y in features_style] y = style_model(x) xc = Variable(x.data.clone()) y = utils.subtract_imagenet_mean_batch(y) xc = utils.subtract_imagenet_mean_batch(xc) features_y = vgg(y) features_xc = vgg(xc) f_xc_c = Variable(features_xc[1].data, requires_grad=False) content_loss = args.content_weight * mse_loss( features_y[1], f_xc_c) style_loss = 0. for m in range(len(features_y)): gram_y = utils.gram_matrix(features_y[m]) gram_s = Variable(gram_style[m].data, requires_grad=False).repeat( args.batch_size, 1, 1, 1) style_loss += args.style_weight * mse_loss( gram_y, gram_s[:n_batch, :, :]) total_loss = content_loss + style_loss total_loss.backward() optimizer.step() agg_content_loss += content_loss.data[0] agg_style_loss += style_loss.data[0] if (batch_id + 1) % args.log_interval == 0: mesg = "{}\tEpoch {}:\t[{}/{}]\tcontent: {:.6f}\tstyle: {:.6f}\ttotal: {:.6f}".format( time.ctime(), e + 1, count, len(train_dataset), agg_content_loss / (batch_id + 1), agg_style_loss / (batch_id + 1), (agg_content_loss + agg_style_loss) / (batch_id + 1)) tbar.set_description(mesg) if (batch_id + 1) % (4 * args.log_interval) == 0: # save model style_model.eval() style_model.cpu() save_model_filename = "Epoch_" + str(e) + "iters_" + str(count) + "_" + \ str(time.ctime()).replace(' ', '_') + "_" + str( args.content_weight) + "_" + str(args.style_weight) + ".model" save_model_path = os.path.join(args.save_model_dir, save_model_filename) torch.save(style_model.state_dict(), save_model_path) style_model.train() style_model.cuda() tbar.set_description("\nCheckpoint, trained model saved at", save_model_path) # save model style_model.eval() style_model.cpu() save_model_filename = "Final_epoch_" + str(args.epochs) + "_" + \ str(time.ctime()).replace(' ', '_') + "_" + str( args.content_weight) + "_" + str(args.style_weight) + ".model" save_model_path = os.path.join(args.save_model_dir, save_model_filename) torch.save(style_model.state_dict(), save_model_path) print("\nDone, trained model saved at", save_model_path)
import torch.nn.functional as F from torchvision import transforms from net import Net from tqdm import tqdm # parser = argparse.ArgumentParser() # parser.add_argument("epoch", type=str, help="test epoch") # args = parser.parse_args() device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') Transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.5], std=[0.5]), ]) net = Net().to(device) epoch = 32 net.load_state_dict(torch.load('./checkpoints/' + epoch + '.pkl')) net.eval() root = 'data/test/' for item in tqdm(os.listdir(root)): img = Image.open(root + item).convert('L') x_data = Transform(img).float().unsqueeze(0).to(device) outputs = net(x_data) prediction = torch.max(F.softmax(outputs, dim=1), dim=1)[1].cpu().numpy()[0] age = prediction + 1 if len(str(age)) == 1: result = '00' + str(age)
def __init__(self, num_states, num_actions, opt={}): """ in number of time steps, of temporal memory the ACTUAL input to the net will be (x,a) temporal_window times, and followed by current x so to have no information from previous time step going into value function, set to 0. """ self.temporal_window = getopt(opt, 'temporal_window', 1) """size of experience replay memory""" self.experience_size = getopt(opt, 'experience_size', 30000) """number of examples in experience replay memory before we begin learning""" self.start_learn_threshold = getopt(opt, 'start_learn_threshold', int(min(self.experience_size * 0.1, 1000))) """gamma is a crucial parameter that controls how much plan-ahead the agent does. In [0,1]""" self.gamma = getopt(opt, 'gamma', 0.8) """number of steps we will learn for""" self.learning_steps_total = getopt(opt, 'learning_steps_total', 100000) """how many steps of the above to perform only random actions (in the beginning)?""" self.learning_steps_burnin = getopt(opt, 'learning_steps_burnin', 3000) """what epsilon value do we bottom out on? 0.0 => purely deterministic policy at end""" self.epsilon_min = getopt(opt, 'epsilon_min', 0.05) """what epsilon to use at test time? (i.e. when learning is disabled)""" self.epsilon_test_time = getopt(opt, 'epsilon_test_time', 0.01) """ advanced feature. Sometimes a random action should be biased towards some values for example in flappy bird, we may want to choose to not flap more often """ if 'random_action_distribution' in opt: #this better sum to 1 by the way, and be of length this.num_actions self.random_action_distribution = opt['random_action_distribution'] if len(self.random_action_distribution) != num_actions: print 'TROUBLE. random_action_distribution should be same length as num_actions.' a = self.random_action_distribution s = sum(a) if abs(s - 1.0) > 0.0001: print 'TROUBLE. random_action_distribution should sum to 1!' else: self.random_action_distribution = [] """ states that go into neural net to predict optimal action look as x0,a0,x1,a1,x2,a2,...xt this variable controls the size of that temporal window. Actions are encoded as 1-of-k hot vectors """ self.net_inputs = num_states * self.temporal_window + num_actions * self.temporal_window + num_states self.num_states = num_states self.num_actions = num_actions self.window_size = max(self.temporal_window, 2) #must be at least 2, but if we want more context even more self.state_window = zeros(self.window_size) self.action_window = zeros(self.window_size) self.reward_window = zeros(self.window_size) self.net_window = zeros(self.window_size) #create [state -> value of all possible actions] modeling net for the value function layers = [] if 'layers' in opt: """ this is an advanced usage feature, because size of the input to the network, and number of actions must check out. """ layers = opt['layers'] if len(layers) < 2: print 'TROUBLE! must have at least 2 layers' if layers[0]['type'] != 'input': print 'TROUBLE! first layer must be input layer!' if layers[-1]['type'] != 'regression': print 'TROUBLE! last layer must be input regression!' if layers[0]['out_depth'] * layers[0]['out_sx'] * layers[0]['out_sy'] != self.net_inputs: print 'TROUBLE! Number of inputs must be num_states * temporal_window + num_actions * temporal_window + num_states!' if layers[-1]['num_neurons'] != self.num_actions: print 'TROUBLE! Number of regression neurons should be num_actions!' else: #create a very simple neural net by default layers.append({'type': 'input', 'out_sx': 1, 'out_sy': 1, 'out_depth': self.net_inputs}) if 'hidden_layer_sizes' in opt: #allow user to specify this via the option, for convenience for size in opt['hidden_layer_sizes']: layers.append({'type': 'fc', 'num_neurons': size, 'activation': 'relu'}) layers.append({'type': 'regression', 'num_neurons': self.num_actions}) #value function output self.value_net = Net(layers) #and finally we need a Temporal Difference Learning trainer! trainer_ops_default = {'learning_rate': 0.01, 'momentum': 0.0, 'batch_size': 64, 'l2_decay': 0.01} tdtrainer_options = getopt(opt, 'tdtrainer_options', trainer_ops_default) self.tdtrainer = Trainer(self.value_net, tdtrainer_options) #experience replay self.experience = [] #various housekeeping variables self.age = 0 #incremented every backward() self.forward_passes = 0 #incremented every forward() self.epsilon = 1.0 #controls exploration exploitation tradeoff. Should be annealed over time self.latest_reward = 0 self.last_input_array = [] self.average_reward_window = Window(1000, 10) self.average_loss_window = Window(1000, 10) self.learning = True
from net import Net import visdom from dataset import DataSet from BP import BP config = { 'lr': 0.0001, 'max_epoch': 500, 'vis': visdom.Visdom(env=u'plus_loss_test'), 'net': Net(2, [5, 3, 1], 0.0001, 'relu'), 'data': DataSet('x1+x2') } process = BP(config=config) process.run()
f4.close() print('SWA Finished!') def get_test(df): xs = [] for i in df: img = i.reshape(28, 28) img = img * 1. / 255. xs.append(img) xs = np.array(xs, dtype=np.float32).reshape(-1, height, width, 1) return xs get_new_weight() model = Net((height, width, channels), numclass) model.load_weights(new_weight_path, by_name=True) df = pd.read_csv(TEST_CSV) test = df.values result = [] xs = get_test(test) # print(xs.shape) pre = model.predict(xs, batch_size=32) # print(pre.shape) pre = np.argmax(pre, axis=-1) # print(pre.shape) # result.append(pre)
def test_pdqn(args=get_args()): env = gym.make(args.task) args.state_shape = env.observation_space.shape or env.observation_space.n args.action_shape = env.action_space.shape or env.action_space.n # train_envs = gym.make(args.task) # you can also use tianshou.env.SubprocVectorEnv train_envs = VectorEnv( [lambda: gym.make(args.task) for _ in range(args.training_num)]) # test_envs = gym.make(args.task) test_envs = VectorEnv( [lambda: gym.make(args.task) for _ in range(args.test_num)]) # seed np.random.seed(args.seed) torch.manual_seed(args.seed) train_envs.seed(args.seed) test_envs.seed(args.seed) # model net = Net(args.layer_num, args.state_shape, args.action_shape, args.device) net = net.to(args.device) optim = torch.optim.Adam(net.parameters(), lr=args.lr) policy = DQNPolicy(net, optim, args.gamma, args.n_step, use_target_network=args.target_update_freq > 0, target_update_freq=args.target_update_freq) # collector if args.prioritized_replay > 0: buf = PrioritizedReplayBuffer(args.buffer_size, alpha=args.alpha, beta=args.alpha) else: buf = ReplayBuffer(args.buffer_size) train_collector = Collector(policy, train_envs, buf) test_collector = Collector(policy, test_envs) # policy.set_eps(1) train_collector.collect(n_step=args.batch_size) # log log_path = os.path.join(args.logdir, args.task, 'dqn') writer = SummaryWriter(log_path) def save_fn(policy): torch.save(policy.state_dict(), os.path.join(log_path, 'policy.pth')) def stop_fn(x): return x >= env.spec.reward_threshold def train_fn(x): policy.set_eps(args.eps_train) def test_fn(x): policy.set_eps(args.eps_test) # trainer result = offpolicy_trainer(policy, train_collector, test_collector, args.epoch, args.step_per_epoch, args.collect_per_step, args.test_num, args.batch_size, train_fn=train_fn, test_fn=test_fn, stop_fn=stop_fn, save_fn=save_fn, writer=writer) assert stop_fn(result['best_reward']) train_collector.close() test_collector.close() if __name__ == '__main__': pprint.pprint(result) # Let's watch its performance! env = gym.make(args.task) collector = Collector(policy, env) result = collector.collect(n_episode=1, render=args.render) print(f'Final reward: {result["rew"]}, length: {result["len"]}') collector.close()
success_place=True, player_observable="attacker", control="attacker", visited=False, ) places.update({"p2": p2}) def pick_first(list_of_enabled: List[Transition]): return list_of_enabled[0] n1 = Net( transitions=transitions, arcs=arcs, places=places, determine_transition_to_fire=pick_first, des_tracking=DesTracking(), ) enable_ts = n1.enabled_transitions() new_net = n1.run_with_net_list() print(len(new_net)) print(new_net[0].generate_list_of_places()) # new_net = new_net.step() # new_net_enabled_ts = new_net.enabled_transitions() # print(len(new_net_enabled_ts)) # print(len(new_net.marked_places())) # print(enable_ts[0].name) # print(len(n1.generate_list_of_places())) # print(len(enable_ts))
def train(args, n_spk): # load config config = get_config(args.conf_path) # logger logger = Logger(args.log_name, 'train', 'val', 'dataset', 'decoder') # training device device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # hyper-set_parameters pad_len = 2800 batch_len = 80 assert pad_len % batch_len == 0 # trainind settings and model net = Net(config.model, n_spk, n_cyc=2, device=device) net.to(device) iter_count = 0 optim = Optimizers(config.optim) optim.set_parameters(list(net.named_parameters())) criteria_before = 10000 past_model = '' # resume if args.resume is not None: dic = torch.load(args.resume) net.load_state_dict(dic['model']) iter_count = dic['iter_count'] optim = dic['optim'] criteria_before = dic['criteria'] past_model = dic['path'] # dataset datasets = { 'train': Dataset(args.train_dir, args.stats_dir, logger.dataset, pad_len=pad_len, batch_len=batch_len, device=device), 'val': Dataset(args.val_dir, args.stats_dir, logger.dataset, pad_len=pad_len, batch_len=batch_len, device=device) } data_loaders = { 'train': DataLoader(datasets['train'], batch_size=config.train.batch_size, shuffle=True), 'val': DataLoader(datasets['val'], batch_size=config.val.batch_size, shuffle=False) } # logging about training data logger.dataset.info('number of training samples: %d' % len(datasets['train'])) logger.dataset.info('number of validation samples: %d' % len(datasets['val'])) # loss function loss_fn = Loss(device) # log net logger.train.info(net) # training! logger.train.info('Start training from iteration %d' % iter_count) # Hypre-parameter required to compute loss scale_var = torch.Tensor( datasets['train'].scaler['mcep'].scale_).to(device) # train for e in range(config.train.epoch): net.train() losses = [] for batch in data_loaders['train']: # iter for batch iter_count += 1 # training data to device inputs = { 'feat': torch.cat((batch['uv'], batch['lcf0'], batch['codeap'], batch['mcep']), dim=-1).to(device), 'cv_stats': torch.cat((batch['uv'], batch['lcf0'], batch['codeap']), dim=-1).to(device), 'src_code': batch['src_code'].to(device), 'trg_code': batch['trg_code'].to(device), 'src_spk': batch['src_id'].to(device), 'trg_spk': batch['trg_id'].to(device), 'flen': batch['flen'].to(device) } # forward propagation out = net(inputs) # compute loss loss, loss_dic = loss_fn(out, inputs, scale_var) # backward loss.backward() optim.step() # log losses.append(loss.cpu().detach().numpy()) if iter_count % config.train.log_every == 0: logger.train.info('loss at iter %d : %s' % (iter_count, loss.item())) logger.train.figure('train', loss_dic, iter_count) # log logger.train.info('Loss for epoch %d : %.5f' % (e, np.mean(losses))) # Validation logger.val.info('Start validation at epoch %d' % e) net.eval() losses = [] criterias = [] with torch.no_grad(): for batch in data_loaders['val']: # to device inputs = { 'feat': torch.cat((batch['uv'], batch['lcf0'], batch['codeap'], batch['mcep']), dim=-1).to(device), 'cv_stats': torch.cat((batch['uv'], batch['lcf0'], batch['codeap']), dim=-1).to(device), 'src_code': batch['src_code'].to(device), 'trg_code': batch['trg_code'].to(device), 'src_spk': batch['src_id'].to(device), 'trg_spk': batch['trg_id'].to(device), 'flen': batch['flen'].to(device) } # forward propagation out = net(inputs) # compute loss loss, loss_dic = loss_fn(out, inputs, scale_var) criteria = loss_dic['mcd/1st'] # log losses.append(loss.cpu().detach().numpy()) criterias.append(criteria) # log criteria = np.mean(criterias) logger.val.info('Validation loss at epoch %d: %.5f' % (e, np.mean(losses))) logger.val.info('Validation criteria: %.5f' % criteria) logger.val.figure('val', loss_dic, iter_count) # save model with best criteria if criteria < criteria_before: logger.val.info('Passed criteria (%f < %f), saving best model...' \ % (criteria, criteria_before)) # remove the existing past model. if not past_model == '': os.remove(past_model) logger.val.info( 'Found existing model at %s. Removed this file.' % past_model) # build dict save_file = os.path.join( args.model_dir, '%s.%d.pt' % (args.model_name, iter_count)) save_dic = { 'model': net.state_dict(), 'iter_count': iter_count, 'optim': optim, 'criteria': criteria, 'path': save_file } torch.save(save_dic, save_file) criteria_before = criteria past_model = save_file # close SummaryWriter logger.close()