def get_new_batches(net, batch_size, train_batches, train_data, train_labels, M): scores = get_scores(net, train_batches) scores[0:50000] = 10 train_data2, train_labels2 = get_easy_data_balanced(train_data, train_labels, scores, M) order = range(M) np.random.shuffle(order) train_data2 = train_data2[:,order] train_labels2 = train_labels2[order] train_batches2 = data_loader.prepare_batches(train_data2, train_labels2, batch_size) print '# train:', train_data2.shape[1], 'samples', len(train_batches2), 'batches' return train_batches2
def get_new_batches(net, batch_size, train_batches, train_data, train_labels,
M):
scores = get_scores(net, train_batches)
#scores[0:20000] = 10
train_data2, train_labels2 = get_easy_data_balanced(
train_data, train_labels, scores, M)
order = range(M)
np.random.shuffle(order)
train_data2 = train_data2[:, order]
train_labels2 = train_labels2[order]
train_batches2 = data_loader.prepare_batches(train_data2, train_labels2,
batch_size)
print '# train:', train_data2.shape[1], 'samples', len(
train_batches2), 'batches'
return train_batches2
train_data = np.concatenate(
(train_data[:, 0:pure_sz], noisy_data[:, 0:noise_sz],
back_data[:, 0:back_sz]),
axis=1)
train_labels = np.concatenate(
(train_labels[0:pure_sz], noisy_labels[0:noise_sz],
back_labels[0:back_sz]))
# shuffle data
order = range(pure_sz + back_sz + noise_sz)
np.random.shuffle(order)
train_data = train_data[:, order]
train_labels = train_labels[order]
train_batches = data_loader.prepare_batches(train_data, train_labels,
batch_size)
test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size)
print '# train:', train_data.shape[1], 'samples', len(train_batches), 'batches'
print '# test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
s = np.zeros((22, 11))
s[:11, :11] = np.eye(11)
s[11:, :11] = np.eye(11)
net.layers[-2].weight = data_loader.copy_to_gpu(s)
w = np.eye(22)
w[11:21, 11:21] = 0.5 * np.eye(10) + (np.ones(
(10, 10)) - np.eye(10)) * 0.5 / 9.0
net.W_denoise = data_loader.copy_to_gpu(w)
net.label_tmp = data_loader.copy_to_gpu(np.zeros((22, 128)))
pure_sz = int(sys.argv[1])
# setting
batch_size = 128
param_file = '/home/sainbar/fastnet-confussion-layer/config/cifar-10-18pct-confussion10.cfg'
learning_rate = 1
image_color = 3
image_size = 32
image_shape = (image_color, image_size, image_size, batch_size)
init_model = parser.parse_config_file(param_file)
net = fastnet.net.FastNet(learning_rate, image_shape, init_model)
net.layers[-2].weight = data_loader.copy_to_gpu(np.eye(10))
# prepare data
train_data, train_labels, test_data, test_labels = data_loader.load_cifar10()
data_mean = train_data.mean(axis=1,keepdims=True)
train_data = train_data - data_mean
test_data = test_data - data_mean
# add noise to label
W = np.load('mixing-matrix-' + sys.argv[2] + '.npy')
train_labels_noisy = confusion_matrix.mix_labels(W, train_labels)
train_batches = data_loader.prepare_batches(train_data[:,:pure_sz], train_labels_noisy[:pure_sz], batch_size)
train_batches2 = data_loader.prepare_batches(train_data[:,:pure_sz], train_labels[:pure_sz], batch_size)
test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size)
print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches'
print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
pure_sz2 = pure_sz + int(1. * val_sz * pure_sz/(pure_sz + noisy_sz + back_sz)) noisy_sz2 = noisy_sz + int(1. * val_sz * noisy_sz/(pure_sz + noisy_sz + back_sz)) back_sz2 = back_sz + int(1. * val_sz * back_sz/(pure_sz + noisy_sz + back_sz)) assert pure_sz2 <= clean_data.shape[1] assert noisy_sz2 <= noisy_data.shape[1] assert back_sz2 <= back_data.shape[1] val_data = np.concatenate((clean_data[:,pure_sz:pure_sz2], noisy_data[:,noisy_sz:noisy_sz2], back_data[:,back_sz:back_sz2]), axis=1) val_labels = np.concatenate((clean_labels[pure_sz:pure_sz2], noisy_labels[noisy_sz:noisy_sz2], back_labels[back_sz:back_sz2])) # shuffle data order = range(train_data.shape[1]) np.random.shuffle(order) train_data = train_data[:,order] train_labels = train_labels[order] train_batches = data_loader.prepare_batches(train_data, train_labels, batch_size) val_batches = data_loader.prepare_batches(val_data, val_labels, batch_size) test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size) print '# train:', train_data.shape[1], 'samples', len(train_batches), 'batches' print '# val:', val_data.shape[1], 'samples', len(val_batches), 'batches' print '# test:', test_data.shape[1], 'samples', len(test_batches), 'batches' # confussion matrix w = np.eye(10) * alpha + (1 - alpha) / 10.0 net.layers[-2].weight = data_loader.copy_to_gpu(w) if net_checkpoint.try_load(net) == False: # net.adjust_learning_rate(2) # net.adjust_learning_rate(1. + (1-alpha)/alpha/10) # net_trainer.train(net, 300, train_batches, val_batches, test_batches)
back_labels[0:40000] = np.random.randint(0, 10, [40000]) noisy_data = np.concatenate((train_data[:,10000:20000], back_data[:,0:50000]), axis=1) noisy_labels = np.concatenate((train_labels[10000:20000], back_labels[0:50000])) w = np.zeros([11, 14]) w[:10,:10] = np.eye(10) / 6.0 w[:10,:10] += 4.0 / 60.0 w[10,:10] = 1.0 / 6.0 w[:10,10:] = 4.0 / 50.0 w[10,10:] = 1.0 / 5.0 net.layers[-2].weight = data_loader.copy_to_gpu(w) # shuffle data order = range(10000) np.random.shuffle(order) train_data = train_data[:,order] train_labels = train_labels[order] order = range(60000) np.random.shuffle(order) noisy_data = noisy_data[:,order] noisy_labels = noisy_labels[order] train_batches = data_loader.prepare_batches(train_data, train_labels, batch_size) noisy_batches = data_loader.prepare_batches(noisy_data, noisy_labels, batch_size) test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size) print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches' print 'noisy:', noisy_data.shape[1], 'samples', len(noisy_batches), 'batches' print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
# background noise back_data = data_loader.load_noise() back_data = back_data - data_mean back_labels = np.ones(back_data.shape[1]) * 10 # confussion matrix w = np.eye(11) net.layers[-2].weight = data_loader.copy_to_gpu(w) # shuffle data order = range(pure_sz) np.random.shuffle(order) train_data = train_data[:,order] train_labels = train_labels[order] order = range(back_sz) np.random.shuffle(order) back_data2 = back_data[:,back_sz:back_sz+10000] back_labels2 = back_labels[back_sz:back_sz+10000] back_data = back_data[:,order] back_labels = back_labels[order] train_batches = data_loader.prepare_batches(train_data, train_labels, batch_size) back_batches = data_loader.prepare_batches(back_data, back_labels, batch_size) back_batches2 = data_loader.prepare_batches(back_data2, back_labels2, batch_size) test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size) print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches' print 'back:', back_data.shape[1], 'samples', len(back_batches), 'batches' print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
pure_sz = int(sys.argv[1])
# setting
batch_size = 128
param_file = '/home/sainbar/fastnet-confussion-layer/config/svhn.cfg'
learning_rate = 1
image_color = 3
image_size = 32
image_shape = (image_color, image_size, image_size, batch_size)
init_model = parser.parse_config_file(param_file)
net = fastnet.net.FastNet(learning_rate, image_shape, init_model)
net.layers[-2].weight = data_loader.copy_to_gpu(np.eye(10))
# prepare data
train_data, train_labels, test_data, test_labels = data_loader.load_svhn100k()
train_data = train_data * 100
test_data = test_data * 100
data_mean = train_data.mean(axis=1, keepdims=True)
train_data = train_data - data_mean
test_data = test_data - data_mean
train_batches = data_loader.prepare_batches(train_data[:, :pure_sz],
train_labels[:pure_sz], batch_size)
test_batches = data_loader.prepare_batches(test_data[:, :10000],
test_labels[:10000], batch_size)
# test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size)
print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches'
print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
image_color = 3
image_size = 32
image_shape = (image_color, image_size, image_size, batch_size)
init_model = parser.parse_config_file(param_file)
net = fastnet.net.FastNet(learning_rate, image_shape, init_model)
net.layers[-2].weight = data_loader.copy_to_gpu(np.eye(10))
# prepare data
train_data, train_labels, test_data, test_labels = data_loader.load_svhn100k()
train_data = train_data * 100
test_data = test_data * 100
data_mean = train_data.mean(axis=1,keepdims=True)
train_data = train_data - data_mean
test_data = test_data - data_mean
# add noise to label
W = np.load('mixing-matrix-' + sys.argv[2] + '.npy')
train_labels_noisy = confusion_matrix.mix_labels(W, train_labels)
train_batches = data_loader.prepare_batches(train_data[:,:pure_sz], train_labels_noisy[:pure_sz], batch_size)
test_batches = data_loader.prepare_batches(test_data[:,:10000], test_labels[:10000], batch_size)
# test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size)
print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches'
print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
net_trainer_noisy.train_mixed(net, 5, train_batches, test_batches)
net.layers[-2].epsW = 0.001
net.layers[-2].wc = float(sys.argv[3])
net_trainer_noisy.train_mixed(net, 100, train_batches, test_batches)
# prepare data
train_data, train_labels, test_data, test_labels = data_loader.load_cifar10()
data_mean = train_data.mean(axis=1,keepdims=True)
train_data = train_data - data_mean
test_data = test_data - data_mean
# background noise
back_data = data_loader.load_noise()
back_data = back_data - data_mean
back_labels = np.ones(back_data.shape[1]) * 10
train_data = np.concatenate((train_data[:,0:pure_sz], back_data[:,0:back_sz]), axis=1)
train_labels = np.concatenate((train_labels[0:pure_sz], back_labels[0:back_sz]))
test_data = np.concatenate((test_data, back_data[:,back_sz:back_sz+1000]), axis=1)
test_labels = np.concatenate((test_labels, back_labels[back_sz:back_sz+1000]))
order = range(pure_sz + back_sz)
np.random.shuffle(order)
train_data = train_data[:,order]
train_labels = train_labels[order]
# add noise to label
W = np.load('mixing-matrix-back-' + sys.argv[3] + '.npy')
train_labels_noisy = confusion_matrix.mix_labels(W, train_labels)
train_batches = data_loader.prepare_batches(train_data, train_labels_noisy, batch_size)
train_batches2 = data_loader.prepare_batches(train_data, train_labels, batch_size)
test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size)
print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches'
print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
back_data = data_loader.load_noise()
back_data = back_data - data_mean
back_labels = np.ones(back_data.shape[1]) * 10
# confussion matrix
w = np.eye(11)
net.layers[-2].weight = data_loader.copy_to_gpu(w)
# shuffle data
order = range(pure_sz)
np.random.shuffle(order)
train_data = train_data[:, order]
train_labels = train_labels[order]
order = range(back_sz)
np.random.shuffle(order)
back_data2 = back_data[:, back_sz:back_sz + 10000]
back_labels2 = back_labels[back_sz:back_sz + 10000]
back_data = back_data[:, order]
back_labels = back_labels[order]
train_batches = data_loader.prepare_batches(train_data, train_labels,
batch_size)
back_batches = data_loader.prepare_batches(back_data, back_labels, batch_size)
back_batches2 = data_loader.prepare_batches(back_data2, back_labels2,
batch_size)
test_batches = data_loader.prepare_batches(test_data, test_labels, batch_size)
print 'train:', train_data.shape[1], 'samples', len(train_batches), 'batches'
print 'back:', back_data.shape[1], 'samples', len(back_batches), 'batches'
print 'test:', test_data.shape[1], 'samples', len(test_batches), 'batches'
