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
