def plot_Barycenter(dataset_name, feat, unfeat, repo): if dataset_name==MNIST: _, _, test=get_data(dataset_name, repo, labels=True) xtest1,_,_, labels,_=test else: _, _, test=get_data(dataset_name, repo, labels=False) xtest1,_,_ =test labels=np.zeros((len(xtest1),)) # get labels def bary_wdl2(index): return _bary_wdl2(index, xtest1, feat, unfeat) n=xtest1.shape[-1] num_class = (int)(max(labels)+1) barys=[bary_wdl2(np.where(labels==i)) for i in range(num_class)] pl.figure(1, (num_class, 1)) for i in range(num_class): pl.subplot(1,10,1+i) pl.imshow(barys[i][0,0,:,:],cmap='Blues',interpolation='nearest') pl.xticks(()) pl.yticks(()) if i==0: pl.ylabel('DWE Bary.') if num_class >1: pl.title('{}'.format(i)) pl.tight_layout(pad=0,h_pad=-2,w_pad=-2) pl.savefig("imgs/{}_dwe_bary.pdf".format(dataset_name))
def plot_Barycenter(dataset_name, feat, unfeat, repo): if dataset_name == MNIST: _, _, test = get_data(dataset_name, repo, labels=True) xtest1, _, _, labels, _ = test else: _, _, test = get_data(dataset_name, repo, labels=False) xtest1, _, _ = test labels = np.zeros((len(xtest1), )) # get labels def bary_wdl2(index): return _bary_wdl2(index, xtest1, feat, unfeat) n = xtest1.shape[-1] num_class = (int)(max(labels) + 1) barys = [bary_wdl2(np.where(labels == i)) for i in range(num_class)] pl.figure(1, (num_class, 1)) for i in range(num_class): pl.subplot(1, 10, 1 + i) pl.imshow(barys[i][0, 0, :, :], cmap='Blues', interpolation='nearest') pl.xticks(()) pl.yticks(()) if i == 0: pl.ylabel('DWE Bary.') if num_class > 1: pl.title('{}'.format(i)) pl.tight_layout(pad=0, h_pad=-2, w_pad=-2) pl.savefig("imgs/{}_dwe_bary.pdf".format(dataset_name))
def get_PCA(dataset_name, feat, unfeat, repo, n_components=4, n_directions=3): if dataset_name == MNIST: _, _, test = get_data(dataset_name, repo, labels=True) xtest1, _, _, labels, _ = test else: _, _, test = get_data(dataset_name, repo, labels=False) xtest1, _, _ = test labels = np.zeros((len(xtest1), )) def bary_wdl2(index): return _bary_wdl2(index, xtest1, feat, unfeat) num_class = (int)(min(max(labels) + 1, n_components)) barys = [bary_wdl2(np.where(labels == i)) for i in range(num_class)] def medoid(index): embeddings = feat.predict(xtest1[np.where(labels == index)]) return np.argmin( [np.sum((embeddings - feat.predict(barys[index]))**2)]) # compute the medoids width = 1.5 nbv = 5 xv = np.linspace(-width, width, nbv) medoids = [medoid(i) for i in range(num_class)] xtemp = feat.predict(xtest1) x0 = np.mean(xtemp, 0) xtemp0 = xtemp - x0.reshape((1, -1)) C = np.cov(xtemp0.T) w, V = np.linalg.eig(C) #Ii=[[[0 for j in range(nbkeep)]for i in range(nbv) ] for c in num_class] pca_list = [[[] for i in range(nbv)] for c in range(num_class)] for j in range(n_directions): v1 = V[:, j].real s = np.sqrt(w[j].real) # compute principal directions and distort the medoid given those directions for i in range(nbv): for c in range(num_class): embedding_medoid = xtemp[medoids[c]] embedding_medoid = embedding_medoid.ravel() var = unfeat.predict((embedding_medoid + s * xv[i] * v1)[None]) pca_list[c][i].append(var[0, 0]) pl.figure(2, (nbv, n_directions * nbv + 1)) pl.clf() for i in range(5): for j in range(n_directions): #print((n_directions,n_directions+n_directions*i)) #pl.subplot(nbv,n_directions,1+n_directions+n_directions*i) #print(n_directions, nbv+1, 1+nbv+n_directions*i) pl.subplot(nbv, n_directions, 1 + j + n_directions * i) pl.imshow(pca_list[0][i][j], cmap='Blues', interpolation='nearest') pl.xticks(()) pl.yticks(()) if i == 0: pl.title('{} {}'.format('DWE', j + 1)) pl.tight_layout()
def train(): hvd.init() config = tf.ConfigProto() config.gpu_options.visible_device_list = str(hvd.local_rank()) # config.gpu_options.per_process_gpu_memory_fraction = 0.9 # 程序最多只能占用指定gpu50%的显存 # config.gpu_options.allow_growth = True #程序按需申请内存 x_train, y_train = dataset.get_data(args.train_file, min=20) x_test, y_test = dataset.get_data(args.test_file, min=20) x = tf.placeholder(tf.float32, shape=[args.batch_size, 300, 300, 3]) y_ = tf.placeholder(tf.float32, shape=[args.batch_size, 1]) y = model.vgg16(x, name='SRResnet') loss = model.loss(y, y_) opt = tf.train.AdamOptimizer(args.learning_rate * hvd.size()) opt = hvd.DistributedOptimizer(opt) hooks = [hvd.BroadcastGlobalVariablesHook(0)] train_op = opt.minimize(loss) checkpoint_dir = './libSaveNet/savenet/' if hvd.rank() == 0 else None with tf.train.MonitoredTrainingSession(checkpoint_dir=checkpoint_dir, config=config, hooks=hooks) as mon_sess: while not mon_sess.should_stop(): count, m = 0, 0 for ep in range(args.epoch): batch_idxs = len(x_train) // args.batch_size * hvd.size() for idx in range(batch_idxs): # batch_input = x_train[idx * args.batch_size: (idx + 1) * args.batch_size] # batch_labels = y_train[idx * args.batch_size: (idx + 1) * args.batch_size] batch_input, batch_labels = dataset.random_batch( x_train, y_train, args.batch_size) mon_sess.run(train_op, feed_dict={ x: batch_input, y_: batch_labels }) count += 1 # print(count) if count % 100 == 0 and hvd.rank() == 0: m += 1 batch_input_test, batch_labels_test = dataset.random_batch( x_test, y_test, args.batch_size) # batch_input_test = x_test[0: args.batch_size] # batch_labels_test = y_test[0: args.batch_size] loss1 = mon_sess.run(loss, feed_dict={ x: batch_input, y_: batch_labels }) loss2 = mon_sess.run(loss, feed_dict={ x: batch_input_test, y_: batch_labels_test }) print("Epoch: [%2d], step: [%2d], train_loss: [%.8f]" \ % ((ep + 1), count, loss1), "\t", 'test_loss:[%.8f]' % (loss2))
def get_PCA(dataset_name, feat, unfeat, repo, n_components=4, n_directions=3): if dataset_name==MNIST: _, _, test=get_data(dataset_name, repo, labels=True) xtest1,_,_, labels,_=test else: _, _, test=get_data(dataset_name, repo, labels=False) xtest1,_,_ =test labels=np.zeros((len(xtest1),)) def bary_wdl2(index): return _bary_wdl2(index, xtest1, feat, unfeat) num_class = (int)(min(max(labels)+1, n_components)) barys=[bary_wdl2(np.where(labels==i)) for i in range(num_class)] def medoid(index): embeddings = feat.predict(xtest1[np.where(labels==index)]) return np.argmin([np.sum(( embeddings- feat.predict(barys[index]))**2)]) # compute the medoids width=1.5 nbv=5 xv=np.linspace(-width,width,nbv) medoids=[medoid(i) for i in range(num_class)] xtemp = feat.predict(xtest1) x0=np.mean(xtemp,0) xtemp0=xtemp-x0.reshape((1,-1)) C=np.cov(xtemp0.T) w,V=np.linalg.eig(C) #Ii=[[[0 for j in range(nbkeep)]for i in range(nbv) ] for c in num_class] pca_list=[[[] for i in range(nbv)] for c in range(num_class)] for j in range(n_directions): v1 = V[:,j].real s=np.sqrt(w[j].real) # compute principal directions and distort the medoid given those directions for i in range(nbv): for c in range(num_class): embedding_medoid = xtemp[medoids[c]] embedding_medoid = embedding_medoid.ravel() var=unfeat.predict((embedding_medoid+s*xv[i]*v1)[None]) pca_list[c][i].append(var[0,0]) pl.figure(2,(nbv, n_directions*nbv+1)) pl.clf() for i in range(5): for j in range(n_directions): #print((n_directions,n_directions+n_directions*i)) #pl.subplot(nbv,n_directions,1+n_directions+n_directions*i) #print(n_directions, nbv+1, 1+nbv+n_directions*i) pl.subplot(nbv, n_directions, 1+j+n_directions*i) pl.imshow(pca_list[0][i][j], cmap='Blues',interpolation='nearest') pl.xticks(()) pl.yticks(()) if i==0: pl.title('{} {}'.format('DWE',j+1)) pl.tight_layout()
def train(): print('load data......') Tokens = tokenization.Tokenization() trainData = dataset.get_data(BATCH_SIZE, 'train', Tokens) validData = dataset.get_data(BATCH_SIZE, 'valid', Tokens) testData = dataset.get_data(BATCH_SIZE, 'test', Tokens) print('load finish') initializer = tf.random_uniform_initializer(-0.05, 0.05) with tf.variable_scope('SeCNN', reuse=None, initializer=initializer): model = Model.SeCNN() # return saver = tf.train.Saver() gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.753) with tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess: tf.global_variables_initializer().run() ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH) if ckpt and ckpt.model_checkpoint_path: saver.restore(sess, ckpt.model_checkpoint_path) maxBleu = 0 nowBleu = 0 while True: index = list(range(len(trainData[0]))) random.shuffle(index) for j in index: gstep, rate, cost, _ = sess.run([model.add_global, model.learning_rate, model.cost, model.train_op], feed_dict={ model.sbt_input: trainData[0][j], model.sbt_pos: trainData[1][j], model.sbt_size: trainData[2][j], model.code_input: trainData[3][j], model.code_size: trainData[4][j], model.nl_input: trainData[5][j], model.nl_output: trainData[6][j], model.nl_size: trainData[7][j], model.mask_size: trainData[8][j], }) if gstep % 2000 == 0: nowBLEU = val(sess, model, validData, Tokens) if nowBLEU > maxBleu: maxBleu = nowBLEU saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=gstep) if gstep % 100 == 0: s = 'After %d steps, cost is %.5f, nowBleu: %.5f, maxBlue: %.5f. ' % ( gstep, cost, nowBleu, maxBleu) print(s) if gstep >= 300000: BLEU = val(sess, model, testData, Tokens) s = 'After 30000 steps, BLEU in test: %.5f ' % (BLEU) print(s) return
def prep_noisylabels(dataset, folders, noise_type, noise_ratio, verbose, alpha, temperature, is_dropout): # prepare required models first prep_teacher_model(dataset, verbose) prep_student(dataset, verbose, alpha, temperature) # generate and save corrupted labels for each noise type for given noise ratio _dataset = get_data(dataset) # copy xy model as none for baseline path = str(Path(folders['logdir']).parent) if not os.path.isdir(path + '/none/'): shutil.copytree('{}/models/teacher'.format(dataset), path + '/none/') # generate noisy labels y_train_noisy, y_test_noisy, probs = get_noisy_labels( _dataset, noise_type, noise_ratio) if PLOT_NOISE: y_train_clean, y_test_clean = _dataset.y_train_int( ), _dataset.y_test_int() create_folders(folders['noisedir']) if not isfile(folders['noisedir'] + 'cmtest.png'): print('Noise for {} doesnt exist, creating it...'.format( folders['noisedir'])) # plot confused samples if probs is not None: create_folders(folders['noisedir'] + '/plots') np.save(folders['noisedir'] + 'probs.npy', probs) _dataset_noisy = get_data(dataset, y_noisy=y_train_noisy, y_noisy_test=y_test_noisy) plot_confused_samples(probs, _dataset_noisy, path=folders['noisedir'] + 'plots/') plot_confused_samples2(probs, _dataset_noisy, path=folders['noisedir'] + 'plots/') # save confusion matrix cm = confusion_matrix(y_train_clean, y_train_noisy) plot_matrix(cm, _dataset.class_names, title='Noise ratio: {}'.format(noise_ratio)) plt.savefig(folders['noisedir'] + 'cmtrain.png') cm = confusion_matrix(y_test_clean, y_test_noisy) plot_matrix(cm, _dataset.class_names, title='Noise ratio: {}'.format(noise_ratio)) plt.savefig(folders['noisedir'] + 'cmtest.png') return y_train_noisy, y_test_noisy
def main(): args = get_args() cwd = Path.cwd() # Create the device args.device = torch.device('cuda') if ( not args.cpu and torch.cuda.is_available()) else torch.device('cpu') print(f'Oven: {args.device}') # Load the train-dataloader and validation-dataloader train_dl, val_dl = get_data(args.img_size, args.batch_size) # Load the model, define the loss & optim model, optimizer = get_model(args) criterion = nn.BCELoss() # Create checkpoint directory to store the state cp_dir = cwd / 'checkpoint' cp_dir.mkdir(exist_ok=True) if args.scratch: print('Fresh Bake! Training the network from scratch.') else: path = cp_dir / args.cp_file args.epoch_start, args.best_acc, args.loss = load_checkpoint( model, optimizer, path, args) print(f'Warming Up! Loading the network from: {path}') print(f'Start Epoch: {args.epoch_start}, Accuracy: {args.best_acc}') # Call model fit fit(model, criterion, optimizer, train_dl, val_dl, args)
def main(_): train_images, train_labels, val_images, val_labels, test_images, test_labels = dataset_tools.get_data( ) graph = tf.Graph() with graph.as_default(): model = SemisupModel(architectures.dataset_model, NUM_LABELS, IMAGE_SHAPE) saver = tf.train.Saver() with tf.Session(graph=graph) as sess: ckpt = '/harddisk/hdd_c/camelyon/code1/new-2015-test/IDC-new/model/model-all-3000/model-11000' # ckpt = '/harddisk/hdd_c/camelyon/code1/new-2015-test/IDC-new/model/model-30000-3000/model-17000' # ckpt = '/harddisk/hdd_c/camelyon/code1/new-2015-test/IDC-new/model/model-2000-3000/model-18000' # ckpt = '/harddisk/hdd_c/camelyon/code1/new-2015-test/IDC-new/model/model-100-1000/model-9500' saver.restore(sess, ckpt) val_pred = model.classify(val_images).argmax(-1) conf_mtx = confusion_matrix(val_labels, val_pred, NUM_LABELS) val_err = (val_labels != val_pred).mean() * 100 print(conf_mtx) print('Validation error: %.2f %%' % val_err) print() # test test_pred = model.classify(test_images).argmax(-1) output = model.classify(test_images) conf_mtx = confusion_matrix(test_labels, test_pred, NUM_LABELS) test_err = (test_labels != test_pred).mean() * 100 print(conf_mtx) print('Test error: %.2f %%' % test_err) print()
def visualize_data(): data_dict = dataset.get_data() build_data = BuildDataset() train_ds, test_ds = build_data.get_dataset(data_dict['train_data'], data_dict['test_data']) train_iter, test_iter = build_data.create_vocalb(train_ds, test_ds) st.subheader( 'How the data looks after creating vocalb from the dataset . . ') st.text(vars(test_ds[20])) print(vars(test_ds[20])) # create the model model = LSTMNet(config.vocalb_size, config.embedding_dim, input_dim=len(build_data.TEXT.vocab), hidden_dim=config.hidden_dim, output_dim=config.out_dim, n_layers=config.n_layers, dropout=config.dropout, pad=build_data.TEXT.vocab.stoi[build_data.TEXT.pad_token]) # Load pre-trained embedding weights pretrained_embeddings = build_data.TEXT.vocab.vectors print(pretrained_embeddings.shape) # model.embedding_layer.weight.data.copy_(pretrained_embeddings) #initialize to zeros model.embedding_layer.weight.data[model.pad_idx] = torch.zeros( config.embedding_dim) model_trained = trainer.train_net(model, train_iter, test_iter, epochs=1)
def bilinear_interpolation(dataset_name, feat, unfeat, repo, nbt=3): tlist=np.linspace(0,1,nbt) _, _, test=get_data(dataset_name, repo) xtest1, _, _ = test n = xtest1.shape[-1] N = len(xtest1) tuple_index=np.random.permutation(N)[:4] embeddings = feat.predict(xtest1[tuple_index]) interp_array = np.zeros((nbt, nbt, n, n)) for i in range(nbt): for j in range(nbt): x = (tlist[i]*embeddings[0] + (1-tlist[0])*embeddings[1]) y = (tlist[i]*embeddings[2] + (1-tlist[0])*embeddings[3]) x_interp = unfeat.predict(((tlist[j]*x + (1-tlist[j])*y))[None]) interp_array[i,j]=x_interp[0,0] pl.figure(1) for i in range(nbt): for j in range(nbt): nb=i*nbt +j+1 pl.subplot(nbt*100+(nbt)*10 +nb) pl.imshow(interp_array[i,j], cmap='Blues',interpolation='nearest')
def prep_student(dataset, verbose, alpha, temperature): # if student is not saved beforehand, train and save it model_path = '{}/models/student/'.format(dataset) if not isfile(model_path + 'model/model.h5') or not isfile(model_path + 'model/model.json'): print('Student model doesnt exist, training it...') # load dataset and logits _dataset = get_data(dataset) x_train, y_train, x_test, y_test = _dataset.get_data() train_features = np.load( '{}/models/teacher/npy/train_logits.npy'.format(dataset)) test_features = np.load( '{}/models/teacher/npy/test_logits.npy'.format(dataset)) # normalized output with temperature shape=(num_samples,num_classes) y_train_soft = softmax(train_features / temperature) y_test_soft = softmax(test_features / temperature) # concatenated output labels=(num_samples,2*num_classes) y_train_new = np.concatenate([y_train, y_train_soft], axis=1) y_test_new = np.concatenate([y_test, y_test_soft], axis=1) # build student model student = get_model(_dataset, 'distillation', is_dropout=True) # remove softmax student.layers.pop() # get features logits = student.layers[-1].output # normal softmax output probs = Activation('softmax')(logits) # softmax output with temperature logits_T = Lambda(lambda x: x / temperature)(logits) probs_T = Activation('softmax')(logits_T) # concatanete output = concatenate([probs, probs_T]) # This is our new student model student = Model(student.input, output) compile_model(student, loss=distillation_loss(_dataset.num_classes, alpha), metrics=[acc_distillation(_dataset.num_classes)]) # create a new dataset with generated data dataset_s = DatasetCls(x_train, y_train_new, x_test, y_test_new, dataset_name=dataset) # train student student = train(dataset_s, student, PARAMS[dataset]['epochs'] * 2, PARAMS[dataset]['batch_size'], log_dir=model_path, callbacks=[ early_stop(patience=PARAMS[dataset]['patience'], monitor='val_loss', verbose=verbose) ], verbose=verbose) # save output files save_model_outputs(student, _dataset, model_path) K.clear_session()
def __main__(): (words, notes, del_t, vocab, song_data) = dataset.get_data() song = song_data[-1] notes = [s[1] for s in song] dur = [s[2] for s in song] play(words, notes, dur, tutorial=False) # tutorial=True still not supported!
def bilinear_interpolation(dataset_name, feat, unfeat, repo, nbt=3): tlist = np.linspace(0, 1, nbt) _, _, test = get_data(dataset_name, repo) xtest1, _, _ = test n = xtest1.shape[-1] N = len(xtest1) tuple_index = np.random.permutation(N)[:4] embeddings = feat.predict(xtest1[tuple_index]) interp_array = np.zeros((nbt, nbt, n, n)) for i in range(nbt): for j in range(nbt): x = (tlist[i] * embeddings[0] + (1 - tlist[0]) * embeddings[1]) y = (tlist[i] * embeddings[2] + (1 - tlist[0]) * embeddings[3]) x_interp = unfeat.predict( ((tlist[j] * x + (1 - tlist[j]) * y))[None]) interp_array[i, j] = x_interp[0, 0] pl.figure(1) for i in range(nbt): for j in range(nbt): nb = i * nbt + j + 1 pl.subplot(nbt * 100 + (nbt) * 10 + nb) pl.imshow(interp_array[i, j], cmap='Blues', interpolation='nearest')
def train(): ''' general structure for training ''' inputs, labels = get_data(DATASET) model = Denoise() optimizer = tf.keras.optimizers.Adam(LEARNING_RATE) #saver = tf.train.Saver() s = 'images/original_cornell_box.png' imwrite(s, inputs) inputs = tf.reshape(inputs, (1, 512, 512, 3))/255 labels = tf.reshape(labels, (1, 512, 512, 3))/255 for epoch in range(NUM_EPOCH): for i in range(0, len(inputs) - BATCH_SIZE, BATCH_SIZE): for j in range(0, inputs.shape[1] - PATCH_SIZE, PATCH_SIZE): for k in range(0, inputs.shape[2] - PATCH_SIZE, PATCH_SIZE): with tf.GradientTape() as tape: batch_patch_inputs = inputs[i:i+BATCH_SIZE][j:j+PATCH_SIZE][k:k+PATCH_SIZE] batch_patch_labels = labels[i:i+BATCH_SIZE][j:j+PATCH_SIZE][k:k+PATCH_SIZE] diffuse, specular = model.call(batch_patch_inputs, batch_patch_labels) predictions = EPSILON * diffuse + tf.exp(specular) - 1 loss = model.loss(predictions, batch_patch_labels) gradients = tape.gradient(loss, model.trainable_variables) optimizer.apply_gradients(zip(gradients, model.trainable_variables)) print("LOSS", epoch, ":", loss) # dont quite remember how to save, need sessions? # save_path = saver.save(, os.path.join(LOG_DIR, "model.ckpt")) # print("Model saved in file: %s" % save_path) write_prediction(inputs, model)
def main(): args = get_arguments() os.environ["CUDA_VISIBLE_DEVICES"] = args.gpus logger = Logger(args) model = Effnet(num_classes=5, width_coeffficient=1.2, depth_coefficient=1.4, drop_out=0.3) model = load_pretrained_weights(model, 'efficientnet-b3') optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=1e-4, nesterov=True) criterion = nn.CrossEntropyLoss() train_loader, val_loader, test_loader = get_data() scheduler = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1) # scheduler = lr_scheduler.CosineAnnealingLr(optimizer,len(train_loader),eta_min=1e-6) model.cuda() model = torch.nn.DataParallel(model, [0, 1, 2, 3]) best_val_acc = 0.0 for epoch in range(1, args.epochs + 1): train(args, model, train_loader, optimizer, criterion, epoch, scheduler, logger) val_acc = val(args, model, val_loader, optimizer, criterion, epoch, logger) if val_acc > best_val_acc: best_val_acc = val_acc save_checkpoint(args, model.state_dict(), filename='epoch_{}_best_{}.pth'.format( epoch, val_acc))
def test_model(args): # create model model = dla.__dict__[args.arch](pretrained=args.pretrained, pool_size=args.crop_size // 32) model = torch.nn.DataParallel(model) # optionally resume from a checkpoint if args.resume: if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) checkpoint = torch.load(args.resume) args.start_epoch = checkpoint['epoch'] best_prec1 = checkpoint['best_prec1'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {} prec {:.03f}) " .format(args.resume, checkpoint['epoch'], best_prec1)) else: print("=> no checkpoint found at '{}'".format(args.resume)) cudnn.benchmark = True data = dataset.get_data(args.data_name) if data is None: data = dataset.load_dataset_info(args.data, data_name=args.data_name) if data is None: raise ValueError('{} is not pre-defined in dataset.py and info.json ' 'does not exist in {}', args.data_name, args.data) # Data loading code valdir = os.path.join(args.data, 'val') normalize = transforms.Normalize(mean=data.mean, std=data.std) if args.crop_10: t = transforms.Compose([ transforms.Resize(args.scale_size), transforms.ToTensor(), normalize]) else: t = transforms.Compose([ transforms.Resize(args.scale_size), transforms.CenterCrop(args.crop_size), transforms.ToTensor(), normalize]) val_loader = torch.utils.data.DataLoader( ImageFolder(valdir, t, out_name=args.crop_10), batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) # define loss function (criterion) and pptimizer criterion = nn.CrossEntropyLoss() if args.cuda: model = model.cuda() criterion = criterion.cuda() if args.crop_10: validate_10(args, val_loader, model, '{}_i_{}_c_10.txt'.format(args.arch, args.start_epoch)) else: validate(args, val_loader, model, criterion)
def train_eval(synapses): error_sum = 0 for i in xrange(len(data)): inputs, expected = dataset.get_data(i) result = execute_net(inputs, synapses) error_sum += sum(abs(expected - result)) return get_fitness(error_sum/(2*len(data)))
def train_DWE(dataset_name=MNIST, repo=REPO, embedding_size=50, image_shape=(28,28),\ batch_size=100, epochs=100): train, valid, test = get_data(dataset_name, repo) dict_models = build_model(image_shape, embedding_size) if not os.path.exists('models'): os.makedirs('models') model = dict_models['dwe'] n_train = len(train[0]) steps_per_epoch = int(n_train / batch_size) earlystop = EarlyStopping(monitor='val_loss', patience=3, verbose=1, mode='auto') tb_callback = TensorBoard(log_dir='.logs', histogram_freq=1, batch_size=batch_size, write_graph=True, write_grads=False, write_images=True, embeddings_freq=0, embeddings_layer_names=True, embeddings_metadata=None, embeddings_data=None, update_freq='epoch') model_path = os.path.join(MODEL, dataset_name + "_autoencoder.hd5") saveweights = ModelCheckpoint(model_path, monitor='val_loss', verbose=0, save_best_only=True, mode='auto') validation_data = ([valid[0], valid[1]], [valid[2], valid[0], valid[1], valid[0], valid[1]]) test_data = ([test[0], test[1]], [test[2], test[0], test[1], test[0], test[1]]) def myGenerator(): #loading data while 1: for i in range(steps_per_epoch): index = range(i * batch_size, (i + 1) * batch_size) x1, x2, y = (train[0][index], train[1][index], train[2][index]) yield [x1, x2], [y, x1, x2, x1, x2] model.fit_generator(myGenerator(), steps_per_epoch, epochs, validation_data=validation_data, callbacks=[earlystop, saveweights, tb_callback]) model.evaluate(test_data[0], test_data[1]) for key in dict_models: dict_models[key].save('{}/{}_{}.hd5'.format(MODEL, dataset_name, key))
def train_nets(): global err, test_err, deltas, synapses, prv_update, curr_update error = 0 for epoch in xrange(iter_no): #update based on each data point error_sum = 0 test_error_sum = 0 for i in xrange(len(data)): inputs, expected = dataset.get_data(i) execute_net(inputs) error = expected - receptors[ depth - 1] #error vector corresponding to each output #print error error_sum += sum(abs(error)) #backpropagation using dynamic programming deltas[depth - 1] = activate(receptors[depth - 1], True) * error for index in xrange(depth - 2, -1, -1): deltas[index] = activate(receptors[index], True) * synapses[ index + 1].transpose().dot(deltas[index + 1]) #update all the weights for index in xrange(depth - 1, 0, -1): curr_update[index] = deltas[index].reshape( topology[index + 1], 1) * receptors[index - 1] synapses[index] += learning_rate * curr_update[ index] + momentum * prv_update[index] bias[index] += learning_rate * deltas[index] curr_update[0] = deltas[0].reshape(topology[1], 1) * inputs synapses[ 0] += learning_rate * curr_update[0] + momentum * prv_update[0] bias[0] += learning_rate * deltas[0] prv_update = curr_update for i in xrange(len(test)): inputs, expected = dataset.get_test(i) execute_net(inputs) tt = np.zeros(nodes_output) pos = np.argmax(receptors[depth - 1]) tt[pos] = 1 test_error_sum += sum(abs(expected - tt)) #test_error_sum += sum(abs(expected - receptors[depth-1])) err[epoch] = error_sum / len(data) test_err[epoch] = test_error_sum / ( 2 * len(test) ) #single misclassification creates an error sum of 2. if epoch % 1 == 0: print "Iteration no: ", epoch, " error: ", err[ epoch], " test error: ", test_err[epoch]
def main(_): # Save default params and set scope saved_params = FLAGS.__flags # !!!Not pass the parameters on the Colab when pasting the codes if saved_params['ensemble']: # uni + bi + tri model_name = 'ensemble' elif saved_params['ngram'] == 1: model_name = 'unigram' elif saved_params['ngram'] == 2: model_name = 'bigram' elif saved_params['ngram'] == 3: model_name = 'trigram' else: assert True, 'Not supported ngram %d' % saved_params['ngram'] model_name += '_embedding' if saved_params['embed'] else '_no_embedding' saved_params['model_name'] = '%s' % model_name saved_params['checkpoint_dir'] += model_name pprint.PrettyPrinter().pprint(saved_params) saved_dataset = get_data( saved_params ) # Input the passing parameters; Return train_set, valid_set, test_set, dictionary == [idx2unigram, unigram2idx, idx2country, country2ethnicity, idx2bigram, idx2trigram] validation_writer = open(saved_params['valid_result_path'], 'a') # Write in a new file if not existing validation_writer.write(model_name + "\n") validation_writer.write( "[dim_hidden, dim_rnn_cell, learning_rate, lstm_dropout, lstm_layer, hidden_dropout, dim_embed]\n" ) validation_writer.write("combination\ttop1\ttop5\tepoch\n") # Run the model for _ in range(saved_params['valid_iteration']): # Sample parameter sets params, combination = sample_parameters( saved_params.copy() ) # If not default parameters, then update with initialization; return input dictionary and a combination LIST dataset = saved_dataset[:] # Copy the content into dataset; if not, we would link the two variable that can be a problem # Initialize embeddings uni_init = get_char2vec(dataset[0][0][:], params['dim_embed_unigram'], dataset[3][0]) # Return initializer bi_init = get_char2vec( dataset[0][1][:], params['dim_embed_bigram'], dataset[3][4] ) # The first [] is the outermost dimension == train_set or dictionary; [3][i] gives the outermost dimension in dictionary tri_init = get_char2vec( dataset[0][2][:], params['dim_embed_trigram'], dataset[3][5]) # Easy to understand with get_data() print(model_name, 'Parameter sets: ', end='') pprint.PrettyPrinter().pprint(combination) rnn_model = RNN(params, [uni_init, bi_init, tri_init]) top1, top5, ep = experiment(rnn_model, dataset, params) validation_writer.write(str(combination) + '\t') validation_writer.write( str(top1) + '\t' + str(top5) + '\tEp:' + str(ep) + '\n') validation_writer.close()
def main(): start_time = time() print('\nGetting data...') data = get_data() X_train = np.asarray(data['X_train']) X_train_feats = np.asarray(data['X_train_feats']) y_train = np.asarray(data['y_train']) tag_index = data['tag_index'] tag_size = len(tag_index) beta = 0.6 predictions = '' # prediction format # word gold_label label1 prob1 label2 prob2 ... for i, (x_train, x_train_feats, y_train, x_test, x_test_feats, y_test) \ in enumerate(generate_ten_fold(X_train, X_train_feats, y_train)): # for each fold print('\nLoading models for fold {}...'.format(i)) model = load_model(os.path.join(MODEL_DIR, MODEL_FILE.format(i)), custom_objects={'true_accuracy': true_accuracy}) print('\nPredicting...') progbar = generic_utils.Progbar(target=len(x_test)) for j, (X, y) in enumerate( data_generator(x_test, x_test_feats, y_test, tag_size, shuffle=False)): # for each sentence prob = model.predict_on_batch(X) prob = prob[0, :, :] # len(sentence), 428 maxes = prob.max(axis=1, keepdims=True) # len(sentence), 1 remains = prob > maxes * beta # len(sentence), none s = '' for k, word in enumerate(remains): s += str(word) + ' ' + y[k] candidates = '' for idx, tag in enumerate(word): if tag: candidates += ' ' + idx + ' ' + prob[k][idx] s += candidates + '\n' # res = list(itertools.product(*tags)) # list of tuples predictions += s progbar.update(j) if j == len(x_test) - 1: break # save prediction result to pickle file try: pickle.dump(predictions, open(os.path.join(CACHE_DIR, PREDICTIONS_FILE), 'wb'), pickle.HIGHEST_PROTOCOL) except Exception, e: raise e
def main(learner): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") train_data, test_data = get_data(learner.batch_size) learner = learner.to(device) cudnn.benchmark = True optimizer = optim.SGD( \ learner.parameters(), \ lr = learner.lr, \ momentum = learner.momentum, \ weight_decay = learner.weight_decay, \ nesterov = True \ ) loss_func = nn.CrossEntropyLoss().cuda() milestones = learner.lr_step scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=learner.lr_decay) rsl_keys = [ "lr", "epoch", "TrainAcc", "TrainLoss", "TestAcc", "TestLoss", "Time" ] rsl = [] y_out = 1.0e+8 print_result(rsl_keys) for epoch in range(learner.epochs): lr = optimizer.param_groups[0]["lr"] train_acc, train_loss = train(device, optimizer, learner, train_data, loss_func) learner.eval( ) # switch to test mode( make model not save the record of calculation) with torch.no_grad(): test_acc, test_loss = test(device, optimizer, learner, test_data, loss_func) time_now = str(datetime.datetime.today()) rsl.append({ k: v for k, v in zip(rsl_keys, [ lr, epoch + 1, train_acc, train_loss, test_acc, test_loss, time_now ]) }) y_out = min(y_out, test_loss) print_result(rsl[-1].values()) scheduler.step()
def build_data_and_model(): x, y = get_data() x = torch.FloatTensor(x).to(CUDA_DEVICE) y = torch.FloatTensor(y).to(CUDA_DEVICE) network = Net() network.to(CUDA_DEVICE) optimizer = optim.Adam(network.parameters(), lr=0.001) network.train() return network, optimizer, (x, y)
def train(): emotion_num = 62 data_path = 'data/data.json' feature_path = 'data/id2feature.json' ckpt_path = 'ckpt/emotion' epochs = 10 grad_accumulation_steps = 5 tokenizer = BertTokenizer.from_pretrained('./ckpt/cdial-gpt', do_lower_case=True) model = MMdialog.from_pretrained('ckpt/cdial-gpt') tokenizer.add_special_tokens(SPECIAL_TOKENS_DICT) model.resize_token_embeddings(len(tokenizer)) model = model.to(device) optimizer = AdamW(model.parameters(), lr=1e-4) # 数据集读取 dialog_list, id2feature = get_data(tokenizer, data_path, feature_path) dialog_list = refine_dialog_list(dialog_list) # print(dialog_list[0]) dataset = MMDataset(dialog_list, id2feature, tokenizer, 'emotion') model.train() for epoch in range(epochs): iteration = 1 for instance in dataset: history_txt, history_img, token_type_ids, labels = instance if token_type_ids.size(0) > 500: continue history_txt, history_img, token_type_ids, labels = history_txt.to(device), history_img.to(device), token_type_ids.to(device), labels.to(device) history_txt_embs = model.transformer.wte(history_txt) history_img_embs = model.image_off(history_img).squeeze(1) input_embs, img_features = input_construct(history_txt_embs, history_img_embs, token_type_ids, tokenizer) input_embs, img_features = input_embs[:-1, :].to(device), img_features.to(device) input_embs = torch.cat([input_embs, img_features], dim=0).to(device) # print(input_embs.size(), img_features.size(), token_type_ids.size()) loss = model(input_embs, token_type_ids, labels, img_features, 'emotion') loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) if iteration % grad_accumulation_steps == 0: optimizer.step() optimizer.zero_grad() print(loss.item()) break iteration += 1 torch.save({'model':model.state_dict(), 'optimizer': optimizer.state_dict()},\ '%s/epoch_%d'%(ckpt_path, epoch)) model.config.to_json_file(os.path.join(ckpt_path, 'config.json')) break
def show_predictions(dataset=None, num=1, model=None): if dataset: for image, mask in dataset.take(num): pred_mask = model.predict(image) display([image[0], mask[0], create_mask(pred_mask)]) else: sample_train, sample_test = get_data(training=False) sample_image, sample_mask = next(iter(sample_test)) display([ sample_image, sample_mask, create_mask(model.predict(sample_image[tf.newaxis, ...])) ])
def main(): start_time = time() print('\nGetting data...') data = get_data() X_test = data['X_test'] X_test_feats = data['X_test_feats'] y_test = data['y_test'] tag_index = data['tag_index'] tag_size = len(tag_index) word_index = data['word_index'] index_word = {} for word, index in word_index.items(): index_word[index] = word index_tag = {} for tag, index in tag_index.items(): index_tag[index] = tag print('\nLoading model...') model = load_model(os.path.join(MODEL_DIR, MODEL_FILE), custom_objects={'true_accuracy': true_accuracy}) print('\nPredicting...') samples = 1 # only 1 work for now prob = model.predict_generator(data_generator(X_test, X_test_feats, y_test, tag_size, shuffle=False), val_samples=samples) predict = prob.argmax(axis=-1) for i in range(samples): words = token2word(X_test[i], word_index) gold_tags = token2word(y_test[i], tag_index) tags = token2word(predict[i], tag_index) print('\n--------- Sample {}----------'.format(i)) print('len(words): {} '.format(len(words), )) assert len(words) == len(gold_tags) and len(words) == len(tags) print('Sentence:') print(words) print('Gold labeling:') print(gold_tags) print('Model labeling:') print(tags) seconds = time() - start_time minutes = seconds / 60 print('[Finished in {} seconds ({} minutes)]'.format( str(round(seconds, 1)), str(round(minutes, 1))))
def main(_): # Save default params and set scope saved_params = FLAGS.__flags if saved_params['ensemble']: model_name = 'ensemble' elif saved_params['ngram'] == 1: model_name = 'unigram' elif saved_params['ngram'] == 2: model_name = 'bigram' elif saved_params['ngram'] == 3: model_name = 'trigram' else: assert True, 'Not supported ngram %d' % saved_params['ngram'] model_name += '_embedding' if saved_params['embed'] else '_no_embedding' saved_params['model_name'] = '%s' % model_name saved_params['checkpoint_dir'] += model_name pprint.PrettyPrinter().pprint(saved_params) saved_dataset = get_data(saved_params) validation_writer = open(saved_params['valid_result_path'], 'a') validation_writer.write(model_name + "\n") validation_writer.write( "[dim_hidden, dim_rnn_cell, learning_rate, lstm_dropout, lstm_layer, hidden_dropout, dim_embed]\n" ) validation_writer.write("combination\ttop1\ttop5\tepoch\n") # Run the model for _ in range(saved_params['valid_iteration']): # Sample parameter sets params, combination = sample_parameters(saved_params.copy()) dataset = saved_dataset[:] # Initialize embeddings uni_init = get_char2vec(dataset[0][0][:], params['dim_embed_unigram'], dataset[3][0]) bi_init = get_char2vec(dataset[0][1][:], params['dim_embed_bigram'], dataset[3][4]) tri_init = get_char2vec(dataset[0][2][:], params['dim_embed_trigram'], dataset[3][5]) print(model_name, 'Parameter sets: ', end='') pprint.PrettyPrinter().pprint(combination) rnn_model = RNN(params, [uni_init, bi_init, tri_init]) top1, top5, ep = experiment(rnn_model, dataset, params) validation_writer.write(str(combination) + '\t') validation_writer.write( str(top1) + '\t' + str(top5) + '\tEp:' + str(ep) + '\n') # first project test validation_writer.close()
def execute_one_round(): args = {'data_name' : config.data_name, 'train_size' : config.train_size, 'valid_size' : config.validation_size, 'test_size' : config.test_size} if args['data_name'] == 'grid': args['width'] = config.width args['height'] = config.height elif args['data_name'] == 'Boltzmann': args['n'] = config.n_boltzmann args['m'] = config.m_boltzmann elif args['data_name'] == 'k_sparse': args['n'] = config.n_of_k_sparse args['sparsity_degree'] = config.sparsity_degree elif args['data_name'] == 'BayesNet': args['n'] = config.n_of_BayesNet args['par_num'] = config.par_num_of_BayesNet elif args['data_name'].startswith('mnist'): args['digit'] = config.digit data = get_data(args) print('data loaded') # if config.generate_samples: # n = len(data['train_data']) # for i in range(n): # im = Image.fromarray(255*data['train_data'][i,:].reshape([config.height, config.width])) # im.convert('RGB').save(config.generated_samples_dir+'train_' + str(i)+'.png') model = MADE() print('model initiated') model.fit(data['train_data'], data['valid_data']) pred = model.predict(data['test_data']) res = dict() res['NLL'], res['KL'] = evaluate(pred, data['test_data_probs']) print('KL: ' + str(res['KL']), file=sys.stderr) print('NLL: ' + str(res['NLL']), file=sys.stderr) sys.stderr.flush() res['train_end_epochs'] = model.train_end_epochs res['num_of_connections'] = model.num_of_connections() if config.generate_samples: n = config.num_of_generated_samples_each_execution generated_samples = model.generate(n).reshape(n, config.height, config.width) for i in range(n): im = Image.fromarray(255*generated_samples[i,:,:]) im.convert('RGB').save(config.generated_samples_dir+str(i)+'.png') return res
def train_nets(): global err, test_err, deltas, synapses, prv_update, curr_update error = 0 for epoch in xrange(iter_no): #update based on each data point error_sum = 0 test_error_sum = 0 for i in xrange(len(data)): inputs, expected = dataset.get_data(i) execute_net(inputs) error = expected - receptors[depth-1] #error vector corresponding to each output #print error error_sum += sum(abs(error)) #backpropagation using dynamic programming deltas[depth-1] = activate(receptors[depth-1],True)*error for index in xrange(depth-2, -1, -1): deltas[index] = activate(receptors[index],True)*synapses[index+1].transpose().dot(deltas[index+1]) #update all the weights for index in xrange(depth-1, 0, -1): curr_update[index] = deltas[index].reshape(topology[index+1],1)*receptors[index-1] synapses[index] += learning_rate*curr_update[index] + momentum*prv_update[index] bias[index] += learning_rate*deltas[index] curr_update[0] = deltas[0].reshape(topology[1],1)*inputs synapses[0] += learning_rate*curr_update[0] + momentum*prv_update[0] bias[0] += learning_rate*deltas[0] prv_update = curr_update for i in xrange(len(test)): inputs, expected = dataset.get_test(i) execute_net(inputs) tt = np.zeros(nodes_output) pos = np.argmax(receptors[depth-1]) tt[pos] = 1 test_error_sum += sum(abs(expected - tt)) #test_error_sum += sum(abs(expected - receptors[depth-1])) err[epoch] = error_sum/len(data) test_err[epoch] = test_error_sum/(2*len(test)) #single misclassification creates an error sum of 2. if epoch%1 == 0: print "Iteration no: ", epoch, " error: ", err[epoch], " test error: ", test_err[epoch]
def _setup(self, config): args = config.pop("args", parser.parse_args([])) vars(args).update(config) args.cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) self.train_loader,self.eval_loader,self.test_loader=get_data() self.model = model if args.cuda: self.model.cuda() self.optimizer = optim.SGD(self.model.parameters(), lr=args.lr, momentum=args.momentum) self.args = args
def train_nets(): global err, test_err, deltas, synapses, prv_update, curr_update error = 0 for epoch in xrange(iter_no): #update based on each data point error_sum = 0 test_error_sum = 0 for i in xrange(len(data)): #Train and learn the parameters on the training data inputs, expected = dataset.get_data(i) #get next training data and label execute_net(inputs) #fwd pass of the inputs in the net error = expected - receptors[depth] #error vector corresponding to each output error_sum += sum(abs(error)) #Absolute sum of error across all the classes #backpropagation using dynamic programming deltas[depth] = act.activate(receptors[depth],True, act_fn[depth])*error for index in xrange(depth-1, -1, -1): deltas[index] = act.activate(receptors[index],True, act_fn[index])*synapses[index].transpose().dot(deltas[index+1]) #update all the weights for index in xrange(depth-1, -1, -1): curr_update[index] = deltas[index+1].reshape(topology[index+1],1)*receptors[index] synapses[index] += learning_rate*curr_update[index] + momentum*prv_update[index] bias[index+1] += learning_rate*deltas[index+1] prv_update = curr_update #cur_updates become the prv_updates for next data for i in xrange(len(test)): #Evaluate the quality of net on validation test set inputs, expected = dataset.get_test(i) #Get the next validation set data and label execute_net(inputs) #fwd pass of the inputs in the net tt = np.zeros(nodes_output) pos = np.argmax(receptors[depth]) tt[pos] = 1 #determine the output class based on highest score test_error_sum += sum(abs(expected - tt))#calculate total misclassification err[epoch] = error_sum/len(data) test_err[epoch] = test_error_sum/(2*len(test)) #single misclassification creates an error sum of 2. if epoch%1 == 0: print "Iteration no: ", epoch, " error: ", err[epoch], " test error: ", test_err[epoch] if np.argmin(err[:epoch+1]) == epoch: #should be argmin of test_err actually save() #Save the values if it's better than all the previous ones
def run_network(n_batch): x_train, x_test, y_train, y_test = get_data(argv[1], 5000) net = Network(120, n_batch) net.train_network(x_train, y_train) val = net.pred_network(x_test, y_test) #get predictions from network y_guesses = [el['classes'] for el in val] plot_f1_scores(y_test, y_guesses, n_batch) mat = confusion_matrix(y_test, y_guesses).T plot_confusion_matrix(mat, n_batch)
def run(callbacks: list): callbacks.append(DisplayCallback()) train_data, test_data, info = get_data(training=True) model = mobile_net_x_unet() steps_per_epoch = info.splits["train"].num_examples // CONFIG.BATCH_SIZE validation_steps = info.splits["test"].num_examples // CONFIG.BATCH_SIZE model.fit(train_data, epochs=CONFIG.EPOCHS, steps_per_epoch=steps_per_epoch, validation_data=test_data, validation_steps=validation_steps, callbacks=callbacks) model.save("models/mobile_net_x_unet.h5") display.show_predictions(test_data, model=model)
def train_DWE(dataset_name=MNIST, repo=REPO, embedding_size=50, image_shape=(28,28),\ batch_size=100, epochs=100): train, valid, test = get_data(dataset_name, repo) dict_models = build_model(image_shape, embedding_size) model = dict_models['dwe'] n_train = len(train[0]) steps_per_epoch = int(n_train / batch_size) earlystop = EarlyStopping(monitor='val_loss', patience=3, verbose=1, mode='auto') saveweights = ModelCheckpoint('{}/{}_autoencoder'.format( MODEL, dataset_name), monitor='val_loss', verbose=0, save_best_only=True, mode='auto') validation_data = ([valid[0], valid[1]], [valid[2], valid[0], valid[1], valid[0], valid[1]]) test_data = ([test[0], test[1]], [test[2], test[0], test[1], test[0], test[1]]) def myGenerator(): #loading data while 1: for i in range(steps_per_epoch): index = range(i * batch_size, (i + 1) * batch_size) x1, x2, y = (train[0][index], train[1][index], train[2][index]) yield [x1, x2], [y, x1, x2, x1, x2] model.fit_generator(myGenerator(), steps_per_epoch, epochs, validation_data=validation_data, callbacks=[earlystop, saveweights]) model.evaluate(test_data[0], test_data[1]) for key in dict_models: dict_models[key].save('{}/{}_{}.hd5'.format(MODEL, dataset_name, key))
def main(): accumulator = 0.0 with open('figs/info.csv', 'w') as f: f.write("iteration,num_correct,num_incorrect,percent_accuracy,percent_inaccuracy,cumulative_inaccuracy\n") for index in range(TEST_ITERATIONS): plt.clf() train_data, train_labels, test_data, test_labels = dataset.get_data() som, interference, no_interference = get_som_labels(train_data, train_labels) _markers = visualize(som, interference, no_interference) correct = 0 markers = [_markers[0], _markers[1], mpatches.Patch(color='lawngreen', label='Correct no interference'), mpatches.Patch(color='orangered', label='Incorrect interference'), mpatches.Patch(color='lawngreen', label='Incorrect no interference'), mpatches.Patch(color='orangered', label='Correct interference')] for i, x in enumerate(test_data): winner = som.winner(x) label, guess = test_labels[i], classify(winner, interference, no_interference) if label == 0.0 and guess == 0: print(Fore.GREEN + '[%d] [%d/%d] Correctly guessed no interference' % (index, i + 1, len(test_data))) markers[2] = plt.plot(winner[0], winner[1], 's', markersize=12, color = 'lawngreen', label='Correct no interference')[0] correct += 1 elif label > 0.0 and guess == 0: print(Fore.RED + '[%d] [%d/%d] Failed to detect interference %f' % (index, i + 1, len(test_data), label), winner) markers[3] = plt.plot(winner[0], winner[1], '<', markersize=12, color = 'orangered', label='Incorrect interference')[0] pass elif label == 0.0 and guess == 1: print(Fore.RED + '[%d] [%d/%d] Failed to detect no_interference' % (index, i + 1, len(test_data)), winner) markers[4] = plt.plot(winner[0], winner[1], '>', markersize=12, color = 'lawngreen', label='Incorrect no interference')[0] pass elif label > 0.0 and guess == 1: print(Fore.GREEN + '[%d] [%d/%d] Correctly guessed interference %f' % (index, i + 1, len(test_data), label)) markers[5] = plt.plot(winner[0], winner[1], 's', markersize=12, color = 'orangered', label='Correct interference')[0] correct += 1 plt.legend(handles = markers, bbox_to_anchor=(0.5, -0.05), fancybox = True, shadow = True, ncol = 6, loc = 'center') incorrect = len(test_data) - correct accuracy = float(correct) / float(len(test_data)) * 100.0 inaccuracy = float(incorrect) / float(len(test_data)) * 100.0 accumulator += inaccuracy with open('figs/info.csv', 'a') as f: f.write('%d,%d,%d,%.2f,%.2f,%.2f\n' % (index, correct, incorrect, accuracy, inaccuracy, accumulator / (float(index) + 1))) print(Fore.MAGENTA + '[%d] Classifier trained with a %.2f%% accuracy and %.2f%% inaccuracy. Average inaccuracy: %.2f' % (index, accuracy, inaccuracy, accumulator / (float(index) + 1))) plt.savefig('figs/%d_%f.png' % (index, accuracy))
def train_DWE(dataset_name=MNIST, repo=REPO, embedding_size=50, image_shape=(28,28),\ batch_size=100, epochs=100): #每个是一个tuble:(dataA, dataB, W-dis) train, valid, test=get_data(dataset_name, repo) dict_models=build_model(image_shape, embedding_size) model = dict_models['dwe'] #n = 训练数据个数 n_train=len(train[0]) steps_per_epoch=int(n_train/batch_size) #??存储策略? earlystop=EarlyStopping(monitor='val_loss', patience=3, verbose=1, mode='auto') saveweights=ModelCheckpoint('{}/{}_autoencoder'.format(MODEL,dataset_name), monitor='val_loss', verbose=0, save_best_only=True, mode='auto') #根据model划分,详见model输入输出 validation_data=([valid[0],valid[1]],[valid[2], valid[0], valid[1], valid[0], valid[1]]) test_data=([test[0],test[1]],[test[2], test[0], test[1], test[0], test[1]]) #使用生成器,需要时再返回index,节约内存 def myGenerator(): #loading data while 1: for i in range(steps_per_epoch): index=range(i*batch_size, (i+1)*batch_size) #每次是一个batch的数据 # y是w-dis x1,x2,y=(train[0][index], train[1][index], train[2][index]) yield [x1,x2],[y, x1,x2, x1, x2] model.fit_generator(myGenerator(),steps_per_epoch, epochs,validation_data=validation_data, callbacks=[earlystop, saveweights]) model.evaluate(test_data[0], test_data[1]) for key in dict_models: dict_models[key].save('{}/{}_{}.hd5'.format(MODEL, dataset_name, key))
def train_nets(): for epoch in xrange(net.iter_no): #update based on each data sample error_sum = 0 for i in xrange(net.len_data): inputs, expected = dataset.get_data(i) print net.learn_rate_conv execute_net(inputs) error = expected - net.receptors[net.depth] #error vector corresponding to each output error_sum += sum(abs(error)) learn(inputs, error) #check if learning algorithm is working properly #if i%200 == 0: # gradient_check(inputs, expected) evaluate(net.receptors, net.test_err, epoch) net.err[epoch] = error_sum/net.len_data if epoch%10 == 0: print "Iteration no: ", epoch, " error: ", net.err[epoch], " test error: ", net.test_err[epoch]
def plot_performnace_ngram(self, limit=6): accuracies = [] fscores = [] for ngram in range(1, limit + 1): self.feature_set = dataset.get_data( number_of_sentences=100, n_gram=ngram ) random.shuffle(self.feature_set) curr_size = int(len(self.feature_set) * 0.8) self.train_set = self.feature_set[:curr_size] self.test_set = self.feature_set[curr_size:] self.train() accuracy, fscore = self.test() accuracies.append(accuracy) fscores.append(fscore) plt.plot(range(1, limit + 1), accuracies, label='Accuracy', linewidth=2) plt.plot(range(1, limit + 1), fscores, label='F1-score', linewidth=2) plt.xlabel('n-gram') plt.legend(loc='lower right') plt.show()
def plot_performance(self, num_of_authors=10): accuracies = [] fscores = [] for authors_ctr in range(3, num_of_authors+1): self.feature_set = dataset.get_data( number_of_sentences=100, number_of_authors=authors_ctr, n_gram=4 ) random.shuffle(self.feature_set) curr_size = int(len(self.feature_set) * 0.8) self.train_set = self.feature_set[:curr_size] self.test_set = self.feature_set[curr_size:] self.train() accuracy, fscore = self.test() accuracies.append(accuracy) fscores.append(fscore) plt.plot(range(3, num_of_authors + 1), accuracies, label='Accuracy', linewidth=2) plt.plot(range(3, num_of_authors + 1), fscores, label='F1-score', linewidth=2) plt.xlabel('number of authors') plt.legend(loc='lower right') plt.show()
def get_MSE(dataset_name, emd, repo): _, _, test=get_data(dataset_name, repo) xtest1, xtest2, ytest = test ot.tic() ytest_pred=emd.predict([xtest1,xtest2]) t_est=ot.toc() err=np.mean(np.square(ytest_pred.ravel()-ytest.ravel())) errr=np.mean(np.square(ytest_pred.ravel()-ytest.ravel()))/np.mean(np.square(ytest.ravel())) r=np.corrcoef(ytest.ravel(),ytest_pred.ravel())[0,1] # compute quantiles nbin=30 yp_mean=np.zeros((nbin,)) yp_10=np.zeros((nbin,)) yp_90=np.zeros((nbin,)) yp_plot=np.zeros((nbin,)) hst,bins=np.histogram(ytest[:],nbin) yp_plot[:]=np.array([.5*bins[k]+.5*bins[k+1] for k in range(nbin)]) for j in range(nbin): idx=np.where((ytest[:]>bins[j]) * (ytest[:]<bins[j+1]) ) ytemp=ytest_pred[idx] if ytemp.any(): yp_mean[j]=ytemp.mean() yp_10[j]=np.percentile(ytemp,10) yp_90[j]=np.percentile(ytemp,90) else: yp_mean[j]=np.nan yp_10[j]=np.nan yp_90[j]=np.nan print('MSE={}\nRel MSE={}\nr={}\nEMD/s={}'.format(err,errr,r,ytest_pred.shape[0]/t_est)) pl.figure(1,(8,3)) pl.clf() pl.plot([0,45],[0,45],'k') xl=pl.axis() pl.plot(ytest,ytest_pred,'+') pl.plot([0,45],[0,45],'k') pl.axis(xl) pl.xlim([0,45]) pl.ylim([0,45]) pl.xlabel('True Wass. distance') pl.ylabel('Predicted Wass. distance') pl.title('True and predicted Wass. distance') pl.legend(('Exact prediction','Model prediction')) pl.savefig('imgs/{}_emd_pred_true.png'.format(dataset_name),dpi=300) pl.savefig('imgs/{}_emd_pred_true.pdf'.format(dataset_name)) pl.subplot(1,2,2) pl.plot([ytest[:].min() ,ytest[:].max() ],[ytest[:].min() ,ytest[:].max() ],'k') pl.plot(yp_plot[:],yp_mean[:],'r+-') pl.plot(yp_plot[:],yp_10[:],'g+-') pl.plot(yp_plot[:],yp_90[:],'b+-') pl.xlim([0,45]) pl.ylim([0,45]) pl.legend(('Exact prediction','Mean pred','10th percentile','90th precentile',)) pl.title('{} MSE:{:3.2f}, RelMSE:{:3.3f}, Corr:{:3.3f}'.format('',err,errr,r)) pl.grid() pl.xlabel('True Wass. distance') pl.ylabel('Predicted Wass. distance') pl.savefig('imgs/{}_emd_pred_true_quantile.png'.format(dataset_name),dpi=300) pl.savefig('imgs/{}_perf.png'.format(dataset_name),dpi=300,bbox_inches='tight') pl.savefig('imgs/{}_perf.pdf'.format(dataset_name),dpi=300,bbox_inches='tight')
def plot_performnace_ngram(self, limit=6): accuracies = [] fscores = [] for ngram in range(1, limit + 1): self.feature_set = dataset.get_data( number_of_sentences=100, n_gram=ngram ) random.shuffle(self.feature_set) curr_size = int(len(self.feature_set) * 0.8) self.train_set = self.feature_set[:curr_size] self.test_set = self.feature_set[curr_size:] self.train() accuracy, fscore = self.test() accuracies.append(accuracy) fscores.append(fscore) plt.plot(range(1, limit + 1), accuracies, label='Accuracy', linewidth=2) plt.plot(range(1, limit + 1), fscores, label='F1-score', linewidth=2) plt.xlabel('n-gram') plt.legend(loc='lower right') plt.show() feature_set = dataset.get_data(number_of_sentences=100, n_gram=4) c = SklearnClassifier(Pipeline([('clf', LinearSVC(C=0.8))])) author_classifier = Classifier(c, feature_set) author_classifier.train(cross_val=True)
movie = tf.nn.relu(tf.layers.dense(movie_placeholder, 1024)) movie = tf.nn.relu(tf.layers.dense(movie, 256)) movie = tf.nn.relu(tf.layers.dense(movie, 1)) output = tf.concat([person, movie], 1) pred = tf.nn.relu(tf.layers.dense(output, 1)) cost = tf.reduce_mean(tf.square(pred - duration_placeholder)) train_op = tf.train.AdamOptimizer(learning_rate=0.01).minimize(cost) saver = tf.train.Saver() sess = tf.InteractiveSession() tf.global_variables_initializer().run() persons, movies, durations = get_data('sample.csv') batch_size = 10 pbar = tqdm(range(100)) for epoch in pbar: total_loss = 0 cnt = 0 for i in range(len(persons) // batch_size): person_data = get_batch(persons, i, batch_size) movie_data = get_batch(movies, i, batch_size) durations_data = get_batch(durations, i, batch_size) _, loss = sess.run([train_op, cost], feed_dict={ person_placeholder: person_data, movie_placeholder: movie_data,
test = theano.function( [sequences, h0, reset,lr], [cost, encoder_outputs], updates=updates, on_unused_input='warn' ) print "Training!" total_iters = 0 for epoch in xrange(NB_EPOCH): h0 = np.zeros((BATCH_SIZE, N_GRUS, DIM)).astype(theano.config.floatX) costs = [] times = [] data = dataset.get_data(DATA_PATH, N_FILES, BATCH_SIZE, SEQ_LEN+FRAME_SIZE, 0, Q_LEVELS, Q_ZERO) for seqs, reset in data: start_time = time.time() cost, h0 = train_fn(seqs, h0, reset, 0.001) total_time = time.time() - start_time times.append(total_time) total_iters += 1 print "Batch ",total_iters costs.append(cost) print "\tBatch Cost: ",cost print "\t Mean Cost: ",np.mean(costs) print "\tTime: ",np.mean(times) #if total_iters%10000==0: # generate_and_save_samples('iterno_%d'%total_iters) break