def wait_and_create_network(host, port, timeout=wait_to_create_timeout): ttl = 0 while ttl < timeout: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) s.close() break except socket.error: pass sleep(0.25) ttl += 0.25 if ttl == timeout: raise Exception("Sorry, cannot connect to jsbridge extension, port %s" % port) back_channel, bridge = create_network(host, port) sleep(0.5) while back_channel.registered is False: back_channel.close() bridge.close() asyncore.socket_map = {} sleep(1) back_channel, bridge = create_network(host, port) return back_channel, bridge
def wait_and_create_network(host, port, timeout=wait_to_create_timeout): ttl = 0 while ttl < timeout: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) s.close() break except socket.error: pass sleep(.25) ttl += .25 if ttl == timeout: raise Exception( "Sorry, cannot connect to jsbridge extension, port %s" % port) back_channel, bridge = create_network(host, port) sleep(.5) while back_channel.registered is False: back_channel.close() bridge.close() asyncore.socket_map = {} sleep(1) back_channel, bridge = create_network(host, port) return back_channel, bridge
def SNc_experiment(frac, theta, weight=1.5, outdeg=0.6, title=''): nest.ResetKernel() nest.SetKernelStatus({ 'resolution': dt, # set simulation resolution 'print_time': True # enable printing of simulation progress }) cell_params = nodes.cell_params cell_params['MSN_D1']['params']['theta'] = theta cell_params['MSN_D2']['params']['theta'] = theta pop = network.create_populations(cell_params, scale=1) network.create_network(pop) network.connect_SNc(pop, frac=frac, weight=weight, outdeg=0.6) #stim_times = [(1000,1010)] #network.add_stims(pop['SNc'], stim_times, amp = 500) spikes, voltages, thetameter = setup_recordings(pop) nest.Simulate(simtime) pl.figure() pl.title(title) rates = plot_raster(pop, spikes, simtime) pl.figure() pl.title(title) plot_theta(pop, thetameter) return rates
def wait_and_create_network(host, port, timeout=wait_to_create_timeout): deadline = datetime.utcnow() + timedelta(seconds=timeout) connected = False while datetime.utcnow() < deadline: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) s.close() connected = True break except socket.error: pass sleep(.25) if not connected: raise Exception("Cannot connect to jsbridge extension, port %s" % port) back_channel, bridge = create_network(host, port) sleep(.5) while back_channel.registered is False: back_channel.close() bridge.close() asyncore.socket_map = {} sleep(1) back_channel, bridge = create_network(host, port) return back_channel, bridge
def worker(i, ckpt_freq, load_ckpt_file, render): """ Set up a single worker. I'm still not 100% about how Distributed TensorFlow works, but as I understand it we do "between-graph replication": each worker has a separate graph, with the global set of parameters shared between all workers (pinned to worker 0). """ dirname = 'summaries/%d_worker%d' % (int(time.time()), i) os.makedirs(dirname) summary_writer = tf.summary.FileWriter(dirname, flush_secs=1) tf.reset_default_graph() server = tf.train.Server(cluster, job_name="worker", task_index=i) sess = tf.Session(server.target) with tf.device("/job:worker/task:0"): create_network('global') with tf.device("/job:worker/task:%d" % i): w = Worker(sess, i, 'PongNoFrameskip-v4', summary_writer) if render: w.render = True if i == 0: saver = tf.train.Saver() checkpoint_file = os.path.join('checkpoints', 'network.ckpt') print("Waiting for cluster cluster connection...") sess.run(tf.global_variables_initializer()) if load_ckpt_file is not None: print("Restoring from checkpoint '%s'..." % load_ckpt_file, end='', flush=True) saver.restore(sess, load_ckpt_file) print("done!") print("Cluster established!") step = 0 while True: print("Step %d" % step) done = w.run_step() if done: w.reset_env() step += 1 if (i == 0) and (step % ckpt_freq == 0): print("Saving checkpoint at step %d..." % step, end='', flush=True) saver.save(sess, checkpoint_file) print("done!")
def main(): parser = argparse.ArgumentParser() parser.add_argument( '--resume', '--resume', default='log/models/last.checkpoint', type=str, metavar='PATH', help='path to latest checkpoint (default:log/last.checkpoint)') parser.add_argument('-d', type=int, default=0, help='Which gpu to use') args = parser.parse_args() device = 'cuda' if torch.cuda.is_available() else 'cpu' torch.backends.cudnn.benchmark = True net = create_network() net.to(device) ds_val = create_test_dataset(512) attack_method = config.create_evaluation_attack_method(device) if os.path.isfile(args.resume): load_checkpoint(args.resume, net) print('Evaluating') clean_acc, adv_acc = eval_one_epoch(net, ds_val, device, attack_method) print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc))
def create_network(self): self.input_image = self.iterator.get_next() # self.input_image = tf.image.resize_images(self.input_image, [28, 28]) self.resulting_img, self.latent_space = network.create_network( self.input_image) self.l1_loss = losses_helper.reconstruction_loss_l1( self.resulting_img, self.input_image) # self.loss_kl_shared = losses_helper.KL_divergence_loss(z_mean, z_std) self.loss = tf.reduce_mean(self.l1_loss) self.opt = tf.train.AdamOptimizer(self.learning_rate, beta1=0.5, beta2=0.999) self.grads = self.opt.compute_gradients(self.loss) self.apply_gradient_op = self.opt.apply_gradients( self.grads, global_step=self.global_step) variable_averages = tf.train.ExponentialMovingAverage( 0.9999, self.global_step) self.variables_averages_op = variable_averages.apply( tf.trainable_variables()) self.train_op = tf.group(self.apply_gradient_op, self.variables_averages_op) self.create_tensorboard()
def get_network(ckpt_dir): sess = tf.Session() network = create_network(scope='worker_0') ckpt_file = tf.train.latest_checkpoint(ckpt_dir) saver = tf.train.Saver() saver.restore(sess, ckpt_file) return sess, network
def main(): model = create_network().to(device) optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=args.weight_decay) EvalAttack = config.create_evaluation_attack_method(device) now_train_time = 0 for epoch in range(1, args.epochs + 1): # adjust learning rate for SGD adjust_learning_rate(optimizer, epoch) s_time = time() descrip_str = 'Training epoch: {}/{}'.format(epoch, args.epochs) # adversarial training train(args, model, device, train_loader, optimizer, epoch, descrip_str) now_train_time += time() - s_time acc, advacc = eval_one_epoch(model, test_loader, device, EvalAttack) # save checkpoint if epoch % args.save_freq == 0: torch.save( model.state_dict(), os.path.join(config.model_dir, 'model-wideres-epoch{}.pt'.format(epoch)))
def process_single_epoch(): print('**************') parser = argparse.ArgumentParser() parser.add_argument('-d', type=int, default=0, help='Which gpu to use') args = parser.parse_args() DEVICE = torch.device('cuda:{}'.format(args.d)) torch.backends.cudnn.benchmark = True net = create_network() net.to(DEVICE) nat_val = load_test_dataset(10000, natural=True) adv_val = load_test_dataset(10000, natural=False) AttackMethod = config.create_evaluation_attack_method(DEVICE) filename = '../ckpts/6leaf-epoch29.checkpoint' print(filename) if os.path.isfile(filename): load_checkpoint(filename, net) print('Evaluating Natural Samples') clean_acc, adv_acc = my_eval_one_epoch(net, nat_val, DEVICE, AttackMethod) print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc)) print('Evaluating Adversarial Samples') clean_acc, adv_acc = my_eval_one_epoch(net, adv_val, DEVICE, AttackMethod) print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc))
def generate(): #load the notes used to train the model with open('data/notes', 'rb') as filepath: notes = pickle.load(filepath) # Get all pitch names pitchnames = sorted(set(item for item in notes)) # Get all pitch names n_vocab = len(set(notes)) network_input = network.get_inputSequences(notes, pitchnames, n_vocab) normalized_input = np.array(network_input) normalized_input = np.reshape(normalized_input, (len(network_input), 100, 1)) model = network.create_network(normalized_input, n_vocab) songs = glob('predict/*.mid') for file in songs: notes = [] # converting .mid file to stream object print('parsing file' + file) midi = converter.parse(file) notes_to_parse = [] try: # Given a single stream, partition into a part for each unique instrument parts = instrument.partitionByInstrument(midi) except: pass if parts: # if parts has instrument parts notes_to_parse = parts.parts[0].recurse() else: notes_to_parse = midi.flat.notes for element in notes_to_parse: mlen = element.duration.quarterLength if(mlen == 0): continue try: length,istrue = note.duration.quarterLengthToClosestType(mlen) except: continue #Standardize the notes to be 32/16/8/4/2/1 lengthstr = str((1/note.duration.convertTypeToNumber(length))*4) if(float(lengthstr) > 4): lengthstr = str(4) elif(float(lengthstr) < 0.25): lengthstr = str(0.25) lengthstr = 'L'+lengthstr if isinstance(element, note.Note): # If its a note wright the note notes.append(str(element.pitch)+lengthstr) if isinstance(element, note.Rest): # If its a rest wright it notes.append(str('R') + lengthstr) elif(isinstance(element, chord.Chord)): # If its a chord wright it notes.append('.'.join(str(n) for n in element.normalOrder) + lengthstr) seq = midi2net(notes,n_vocab) prediction_output = generate_notes(model, network_input, pitchnames, n_vocab,seq) create_midi(prediction_output,file + '.predicted')
def get_model_pred(model_file, dataset): # model creation model = create_network() model.load_params(model_file) model.initialize(dataset=dataset) # pred will have shape (num_clips, num_classes) and contain class probabilities pred = model.get_outputs(test_set) return pred
def create_one_network(config, states, scope='dueling', reuse=False): out = network.create_network(config, states, scope=scope, reuse=reuse) value, advantage = tf.split(out, [1, config.get('num_actions')], axis=1) adv_mean = tf.reduce_mean(advantage, axis=1) q_val = value + advantage - tf.expand_dims(adv_mean, axis=1) return q_val
def generate_music(file): notes = get_notes_from_file(file) vocab = load_vocabulary_from_training() vocab_size = len(vocab) network_input = prepare_sequence_for_prediction(notes, vocab) model = create_network(vocab_size, get_best_weights_filename()) prediction_output = generate_notes(model, network_input, vocab, vocab_size) save_midi_file(prediction_output)
def inference(self): if self.__network: return self # Building network... with tf.variable_scope('ResNet'): net = create_network(self.x, self.h, self.keep_prob, self.numClasses) self.__network = net return self
def wait_and_create_network(host, port, timeout=10): ttl = 0 while ttl < timeout: sleep(.25) try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) s.close() break except socket.error: pass return create_network(host, port)
def inference(self): if self.__network: return self # Building network... with tf.variable_scope('ResNet'): net, net_flatten, vol_feat, cls_act_map = create_network(self.x, args.n_cls, self.is_train) self.__network = net self.__features = net_flatten self.__vol_features = vol_feat self.__cls_act_map = cls_act_map # cls_act_map: [64, 14] return self
def train_network(): epochs = 50 notes = [] with open('data/notes', 'rb') as filepath: notes = pickle.load(filepath) vocablen = len(set(notes)) net_in, net_out = prepare_sequences(notes, vocablen) model = network.create_network(net_in, vocablen) train(model, net_in, net_out, epochs)
def main(): DEVICE = torch.device('cuda:{}'.format(args.d)) torch.backends.cudnn.benchmark = True net = create_network() net.to(DEVICE) criterion = config.create_loss_function().to(DEVICE) optimizer = config.create_optimizer(net.parameters()) lr_scheduler = config.create_lr_scheduler(optimizer) ds_train = create_train_dataset(args.batch_size) ds_val = create_test_dataset(args.batch_size) TrainAttack = config.create_attack_method(DEVICE) EvalAttack = config.create_evaluation_attack_method(DEVICE) now_epoch = 0 if args.auto_continue: args.resume = os.path.join(config.model_dir, 'last.checkpoint') if args.resume is not None and os.path.isfile(args.resume): now_epoch = load_checkpoint(args.resume, net, optimizer, lr_scheduler) while True: if now_epoch > config.num_epochs: break now_epoch = now_epoch + 1 descrip_str = 'Training epoch:{}/{} -- lr:{}'.format( now_epoch, config.num_epochs, lr_scheduler.get_lr()[0]) train_one_epoch(net, ds_train, optimizer, criterion, DEVICE, descrip_str, TrainAttack, adv_coef=args.adv_coef) if config.eval_interval > 0 and now_epoch % config.eval_interval == 0: eval_one_epoch(net, ds_val, DEVICE, EvalAttack) lr_scheduler.step() save_checkpoint(now_epoch, net, optimizer, lr_scheduler, file_name=os.path.join( config.model_dir, 'epoch-{}.checkpoint'.format(now_epoch)))
def main(): # get parameters from user args = sys.argv united_data_path = args[1] treshold_dir = args[2] multi_idx_df = load_df(united_data_path) calc_corr_dist_per_all_panels(multi_idx_df) pie_chart_neigbours_panel(multi_idx_df, is_pie=False, is_save=False) above_treshold_network = network.create_network(treshold_dir) graph = network.create_graph_from_network(above_treshold_network)
def wait_and_create_network(host, port, timeout=10): ttl = 0 while ttl < timeout: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) s.close() break except socket.error: pass sleep(.25) ttl += .25 back_channel, bridge = create_network(host, port) sleep(.5) while back_channel.registered is False: back_channel.close() bridge.close() asyncore.socket_map = {} sleep(1) back_channel, bridge = create_network(host, port) return back_channel, bridge
def generate(): with open('data/notes', 'rb') as filepath: notes = pickle.load(filepath) pitchnames = sorted(set(item for item in notes)) n_vocab = len(set(notes)) network_input = network.get_inputSequences(notes, pitchnames, n_vocab) normalized_input = np.array(network_input) normalized_input = np.reshape(normalized_input, (len(network_input), 100, 1)) model = network.create_network(normalized_input, n_vocab) prediction_output = generate_notes(model, network_input, pitchnames, n_vocab) create_midi(prediction_output)
def watch_doom_game(configuration): game, actions = init_watching_environment(configuration) load_file = load_file_simple(configuration) session = tf.compat.v1.Session() learn, get_q_values, get_best_action = create_network( session, len(actions)) saver = tf.compat.v1.train.Saver() saver.restore(session, load_file) session.run(tf.compat.v1.global_variables_initializer()) stacked_frames = deque([ np.zeros((state_size[0], state_size[1]), dtype=np.int) for i in range(stack_size) ], maxlen=4) run_episodes(game, get_best_action, actions, stacked_frames)
def caller_process(model_file, qin, qout): caller_network = create_network(model_file) tc = 0 with torch.no_grad(): while True: item = qin.get() if item == "wait": qout.put("wait") continue if item is None: qout.put(None) break signal = item[1] tc += 1 output = caller_network(torch.tensor(signal).cuda()) qout.put((item[0], output, item[2])) print("caller done", tc)
def __init__(self, sess, worker_n, env_name, summary_writer): self.sess = sess self.env = EnvWrapper(gym.make(env_name), prepro2=prepro2, frameskip=4) worker_scope = "worker_%d" % worker_n self.network = create_network(worker_scope) self.summary_writer = summary_writer self.scope = worker_scope self.reward = tf.Variable(0.0) self.reward_summary = tf.summary.scalar('reward', self.reward) policy_optimizer = tf.train.AdamOptimizer(learning_rate=0.0005) value_optimizer = tf.train.AdamOptimizer(learning_rate=0.0005) self.update_policy_gradients, self.apply_policy_gradients, self.zero_policy_gradients, self.grad_bufs_policy = \ create_train_ops(self.network.policy_loss, policy_optimizer, update_scope=worker_scope, apply_scope='global') self.update_value_gradients, self.apply_value_gradients, self.zero_value_gradients, self.grad_bufs_value = \ create_train_ops(self.network.value_loss, value_optimizer, update_scope=worker_scope, apply_scope='global') self.val_summ = tf.summary.scalar('value_loss', self.network.value_loss) self.init_copy_ops() self.frame_stack = deque(maxlen=N_FRAMES_STACKED) self.reset_env() self.t_max = 10000 self.steps = 0 self.episode_rewards = [] self.render = False self.episode_n = 1 self.value_log = deque(maxlen=100) self.fig = None
def train_network(): notes = get_notes_from_dataset() vocab = create_vocabulary_for_training(notes) vocab_size = len(vocab) training_sequence, validation_sequence = prepare_sequences_for_training( notes, vocab, vocab_size, BATCH_SIZE) latest_checkpoint = get_latest_checkpoint() if latest_checkpoint: print( f"*** Restoring from the lastest checkpoint: {latest_checkpoint} ***" ) model = load_model(latest_checkpoint) else: model = create_network(vocab_size) train(model, training_sequence, validation_sequence)
def main(): device = 'cuda' if torch.cuda.is_available() else 'cpu' torch.backends.cudnn.benchmark = True net = create_network() net.to(device) criterion = config.create_loss_function().to(device) optimizer = config.create_optimizer(net.parameters()) lr_scheduler = config.create_lr_scheduler(optimizer) ds_train = create_train_dataset(args.batch_size) ds_val = create_test_dataset(args.batch_size) train_attack = config.create_attack_method(device) eval_attack = config.create_evaluation_attack_method(device) now_epoch = 0 if args.auto_continue: args.resume = os.path.join(config.model_dir, 'last.checkpoint') if args.resume is not None and os.path.isfile(args.resume): now_epoch = load_checkpoint(args.resume, net, optimizer, lr_scheduler) for i in range(now_epoch, config.num_epochs): # if now_epoch > config.num_epochs: # break # now_epoch = now_epoch + 1 descrip_str = 'Training epoch:{}/{} -- lr:{}'.format(i, config.num_epochs, lr_scheduler.get_last_lr()[0]) train_one_epoch(net, ds_train, optimizer, criterion, device, descrip_str, train_attack, adv_coef=args.adv_coef) if config.eval_interval > 0 and i % config.eval_interval == 0: eval_one_epoch(net, ds_val, device, eval_attack) lr_scheduler.step() save_checkpoint(i, net, optimizer, lr_scheduler, file_name=os.path.join(config.model_dir, 'epoch-{}.checkpoint'.format(i)))
'prob': max_label_prob[i], 'bounded_box': bb }) return result def generate_random_color(): return (np.random.randint(0, 255), np.random.randint(0, 255), np.random.randint(0, 255)) model = 'model/deploy.prototxt' weights = 'model/bvlc_alexnet.caffemodel' batch_size = network.BATCH_SIZE map_id_word = read_label('model/label.txt') net = network.create_network(model, weights) if __name__ == '__main__': img = cv2.imread(sys.argv[1]) img = reshape_image(img, frame_size=(1024, 1024, 3), mode='fit') print 'creating eastimated possible bounded box' start_time = time.time() bounded_box_list = segment.get_bounded_box(img, 0.5, 500, 20) end_time = time.time() print end_time - start_time, 'time spent' bounded_box_list = filter_by_boundray_ratio( filter_by_size(bounded_box_list)) print "predicting labels for bounded box"
SIMULATION_HORIZON = 1500 # in ticks INITIAL_STEPS = 100 # the first argument is the algorithm: "random" "dijkstra" for now alg = sys.argv[1] if not alg in ['random', 'dijkstra', 'dijkstraBounded', 'lessCarAhead',\ 'dynamicRandom', 'decmcts', 'decmcts1Block', 'decmcts2Block',\ 'decmcts5Block']: print('Invalid Option!') sys.exit() # Fire up the model netlogo = fire_up(GRID_SIZE, False) # Create Networkx, representative of netlogo transportaiton network in python network = create_network(GRID_SIZE) # create cars and assign random routes, and finish the setup cars = create_cars(NUM_CARS, GRID_SIZE, netlogo) # initialize some critical measurements (indicators of mobility) mean_travel_times = [] average_mean_speed_so_far = [] last_step_time = None # Run the procedure try: for i in range(SIMULATION_HORIZON): if i % 500 == 0 or 'decmcts' in alg: print(i)
# ---------------------------------------------------------------------------- import os from neon import logger as neon_logger from neon.util.argparser import NeonArgparser from neon.optimizers import RMSProp from neon.transforms import Misclassification from neon.callbacks.callbacks import Callbacks from network import create_network from data import make_train_loader, make_val_loader eval_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'whale_eval.cfg') config_files = [eval_config] if os.path.exists(eval_config) else [] parser = NeonArgparser(__doc__, default_config_files=config_files) args = parser.parse_args() model, cost_obj = create_network() assert 'train' in args.manifest, "Missing train manifest" assert 'val' in args.manifest, "Missing val manifest" train = make_train_loader(args.manifest['train'], args.manifest_root, model.be, noise_file=args.manifest.get('noise')) neon_logger.display('Performing train and test in validation mode') val = make_val_loader(args.manifest['val'], args.manifest_root, model.be) metric = Misclassification() model.fit(dataset=train, cost=cost_obj, optimizer=RMSProp(learning_rate=1e-4), num_epochs=args.epochs,
train_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'train.cfg') config_files = [train_config] if os.path.exists(train_config) else [] parser = NeonArgparser(__doc__, default_config_files=config_files) parser.add_argument('--depth', type=int, default=2, help='depth of each stage (network depth will be 9n+2)') parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') args = parser.parse_args() random_seed = args.rng_seed if args.rng_seed else 0 # Check that the proper manifest sets have been supplied assert 'train' in args.manifest, "Missing train manifest" assert 'val' in args.manifest, "Missing validation manifest" model, cost = create_network(args.depth) # setup data provider train = make_train_loader(args.manifest['train'], args.manifest_root, model.be, args.subset_pct, random_seed) test = make_validation_loader(args.manifest['val'], args.manifest_root, model.be, args.subset_pct) # tune batch norm parameters on subset of train set with no augmentations tune_set = make_tuning_loader(args.manifest['train'], args.manifest_root, model.be) # configure callbacks callbacks = Callbacks(model, eval_set=test, metric=Misclassification(), **args.callback_args) callbacks.add_callback(BatchNormTuneCallback(tune_set), insert_pos=0) # begin training opt = GradientDescentMomentum(0.1, 0.9, wdecay=0.0001, schedule=Schedule([82, 124], 0.1))
Y_new = Y1 X_new = int(round(float(X2*Y_new)/float(Y2))) img = cv2.resize(img, (X_new, Y_new)) X_space_center = ((X1 - X_new)/2) Y_space_center = ((Y1 - Y_new)/2) image_frame[Y_space_center: Y_space_center+Y_new, X_space_center: X_space_center+X_new] = img return image_frame feature_size = network.FEATURE_SIZE batch_size = network.BATCH_SIZE net = network.create_network(model, weights) file_list = getFiles(sys.argv[1]) random.shuffle(file_list) number_of_iteration = get_num_batch(len(file_list), batch_size) batch_size_cluster = 10000 if len(sys.argv) != 4: images_feature = None epoch = 20 k = 90 clr = MiniBatchKMeans(n_clusters=k, init='k-means++', batch_size=batch_size_cluster, compute_labels=True, max_no_improvement=None, n_init=10) for e in xrange(epoch):
def run_net(config, word_index, x_train, y_train, x_val, y_val, x_test, y_test): model = network.create_network(config, word_index) res = evaluate_model(config, model, x_train, y_train, x_val, y_val, x_test, y_test) print(str(res) + "\n")
be = gen_backend(**extract_valid_args(args, gen_backend)) be.bsz = 32 # setup data provider shape = dict(channel_count=3, height=112, width=112, scale_min=128, scale_max=128) testParams = VideoParams(frame_params=ImageParams(center=True, flip=False, **shape), frames_per_clip=16) common = dict(target_size=1, nclasses=101, datum_dtype=np.uint8) videos = DataLoader(set_name='val', repo_dir=args.data_dir, media_params=testParams, shuffle=False, **common) # initialize model model = create_network() model.load_params(args.model_weights) model.initialize(dataset=videos) # read label index file into dictionary label_index = {} with open(args.class_ind_file) as label_index_file: for line in label_index_file: index, label = line.split() label_index[int(index) - 1] = label def print_label_on_image(frame, top_labels): labels = [(label_index[index], "{0:.2f}".format(prob)) for (index, prob) in top_labels] font = cv2.FONT_HERSHEY_COMPLEX_SMALL
import torch import json import numpy as np from tensorboardX import SummaryWriter import torch.nn as nn import torch.optim as optim import os import time DEVICE = torch.device('cuda:{}'.format(args.d)) torch.backends.cudnn.benchmark = True writer = SummaryWriter(log_dir=config.log_dir) net = create_network() net.to(DEVICE) criterion = CrossEntropyWithWeightPenlty(net.other_layers, DEVICE, config.weight_decay) #.to(DEVICE) optimizer = config.create_optimizer(net.other_layers.parameters()) lr_scheduler = config.create_lr_scheduler(optimizer) Hamiltonian_func = Hamiltonian(net.layer_one, config.weight_decay) layer_one_optimizer = optim.SGD(net.layer_one.parameters(), lr=lr_scheduler.get_lr()[0], momentum=0.9, weight_decay=5e-4) lyaer_one_optimizer_lr_scheduler = optim.lr_scheduler.MultiStepLR( layer_one_optimizer, milestones=[15, 19], gamma=0.1) LayerOneTrainer = FastGradientLayerOneTrainer(Hamiltonian_func, layer_one_optimizer,
from neon.util.argparser import NeonArgparser from data import make_train_loader, make_test_loader from network import create_network # parse the command line arguments train_config = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'train.cfg') config_files = [train_config] if os.path.exists(train_config) else [] parser = NeonArgparser(__doc__, default_config_files=config_files) parser.add_argument('--subset_pct', type=float, default=100, help='subset of training dataset to use (percentage)') args = parser.parse_args() random_seed = 0 if args.rng_seed is None else args.rng_seed model, cost = create_network() # setup data provider assert 'train' in args.manifest, "Missing train manifest" assert 'test' in args.manifest, "Missing validation manifest" train = make_train_loader(args.manifest['train'], args.manifest_root, model.be, args.subset_pct, random_seed) valid = make_test_loader(args.manifest['test'], args.manifest_root, model.be, args.subset_pct) # setup callbacks callbacks = Callbacks(model, eval_set=valid, **args.callback_args) # gradient descent with momentum, weight decay, and learning rate decay schedule learning_rate_sched = Schedule(list(range(6, args.epochs, 6)), 0.1) opt_gdm = GradientDescentMomentum(0.003, 0.9, wdecay=0.005, schedule=learning_rate_sched)