def get_train_mb(ds_train, ds_val, params={}):
timestamp = params.get('timestamp')
batchsize = params.get('batchsize', 64)
multi_loss = params.get('multi_loss', False)
augmentation = params.get('augmentation', False)
add_to_report('\n## Transformations', params)
# Initialize the preprocessing pipeline
print("Setting up preprocessing ...")
tform = get_normalization_transform(
means=ds_train.get_mean(per_channel=True),
stds=ds_train.get_stddev(per_channel=True),
augmentation=augmentation)
add_to_report(
" - %s [%s] (values: %s)" %
(tform.get_transformation(1).__class__.__name__, ds_train.split,
str(tform.get_transformation(1).values())), params)
add_to_report(
" - %s [%s] (values: %s)" %
(tform.get_transformation(2).__class__.__name__, ds_train.split,
str(tform.get_transformation(2).values())), params)
add_to_report('\n## Dataset', params)
# Initialize the MiniBatch generators
print("Initializing minibatch generators ...")
if multi_loss:
mb_train = MiniBatchMultiLossGenerator(ds_train, batchsize, tform)
mb_val = MiniBatchMultiLossGenerator(ds_val, batchsize, tform)
else:
mb_train = MiniBatchGenerator(ds_train, batchsize, tform)
mb_val = MiniBatchGenerator(ds_val, batchsize, tform)
print(" [%s] %i samples, %i minibatches of size %i" %
('train', mb_train.dataset.size(), mb_train.nbatches(),
mb_train.batchsize()))
print(
" [%s] %i samples, %i minibatches of size %i" %
('val', mb_val.dataset.size(), mb_val.nbatches(), mb_val.batchsize()))
add_to_report(
" - [%s] %i samples, %i minibatches of size %i" %
('train', mb_train.dataset.size(), mb_train.nbatches(),
mb_train.batchsize()), params)
add_to_report(
" - [%s] %i samples, %i minibatches of size %i" %
('val', mb_val.dataset.size(), mb_val.nbatches(), mb_val.batchsize()),
params)
return mb_train, mb_val, tform
print("Loading %s ..." % type(Dataset).__name__)
# Initialize the datasets
ds_train = Dataset(DATASET_DIR, 'train')
ds_test = Dataset(DATASET_DIR, 'test')
# Initialize the preprocessing pipeline
print("Setting up preprocessing ...")
tform = get_normalization_transform(
means=ds_train.get_mean(per_channel=True),
stds=ds_train.get_stddev(per_channel=True),
)
# Initialize the MiniBatch generators
print("Initializing minibatch generators ...")
mb_test = MiniBatchGenerator(ds_test, test_batchsize, tform)
print(" [%s] %i samples, %i minibatches of size %i" %
(ds_test.split, mb_test.dataset.size(), mb_test.nbatches(),
mb_test.batchsize()))
# Load latest model
latest_model = max(fs.find('*.h5', path=MODEL_DIR), key=fs.ctime)
# Test best model
print("Testing model %s on test set ..." % latest_model)
utils.test(load_model(latest_model), mb_test)
# Visualize model
# utils.visualise_with_quiver(load_model(latest_model), '/home/patrick', class_type='gender')
if "gender" in ds_test.__class__.__name__:
def main(params):
timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
params['timestamp'] = timestamp
add_to_report('# Training Report', params)
add_to_report('\n## Parameters', params)
add_to_report(params, params)
print("Loading Dataset ...")
# Initialize the datasets
ds_train = Dataset(DATASET_DIR, 'train')
ds_val = Dataset(DATASET_DIR, 'val')
# Get the class names for this dataset
class_names = ds_train.label_names
mb_train, mb_val, tform = get_train_mb(ds_train, ds_val, params=params)
if params.get('use_class_weights', False):
print("Using class weights")
class_weight = utils.get_class_weight(class_names, ds_train.classes())
for c, w in class_weight.items():
print(" [%s] %f" % (class_names[c], w))
else:
class_weight = None
# Initialize a softmax classifier
print("Initializing CNN and optimizer ...")
model = get_levinet(params)
add_model_to_report(model, params)
# SGD with Nesterov Momentum
learning_rate = params.get('learning_rate', 1e-2)
momentum = params.get('momentum', 0.9)
opt = SGD(lr=learning_rate, momentum=momentum, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
try:
print("Training for %i epochs ..." % params.get('n_epochs'))
train_loop(model, mb_train, mb_val, opt=opt, params=params)
except KeyboardInterrupt:
print("\n\n*** Stopping Training\n\n")
print("Testing best model on test set ...")
# Initialize test data
batchsize = params.get('batchsize', 64)
ds_test = Dataset(DATASET_DIR, 'test')
mb_test = MiniBatchGenerator(ds_test, batchsize, tform)
print(" [%s] %i samples, %i minibatches of size %i" %
(ds_test.split, mb_test.dataset.size(), mb_test.nbatches(),
mb_test.batchsize()))
# Load the global best model
model = load_model('results/%s/best_model.h5' % timestamp,
custom_objects={"LRN": LRN})
test_loop(model, mb_test, params=params)
newdataset = []
for sample_i, sample in enumerate(train_data):
newsample = transformation_seq.apply(sample)
newdataset.append(newsample)
train_data = np.array(newdataset)
train_hog.setDataset(train_data, train_labels, train_label_names)
newdataset = []
for sample_i, sample in enumerate(val_data):
newsample = transformation_seq.apply(sample)
newdataset.append(newsample)
val_data = np.array(newdataset)
val_hog.setDataset(val_data, val_labels, val_label_names)
#initializing minibatch
train_minibatchgen = MiniBatchGenerator(train_hog, MINI_BATCH_SIZE)
print("Initializing minibatch generators ...")
print(" [train] " + str(train_hog.size()) + " samples, " +
str(train_minibatchgen.nbatches()) + " minibatches of size " +
str(train_minibatchgen.getbs()) + "")
val_minibatchgen = MiniBatchGenerator(val_hog, 100)
print(" [val] " + str(val_hog.size()) + " samples, " +
str(val_minibatchgen.nbatches()) + " minibatches of size " +
str(val_minibatchgen.getbs()) + "")
#defining NN structure
x = tf.placeholder(tf.float32, [None, vectorsize])
W = tf.Variable(tf.zeros([vectorsize, nclasses]), name="weights")
b = tf.Variable(tf.zeros([nclasses]), name="biases")
y = tf.matmul(x, W) + b
perchannelsubtraction_trans = PerChannelSubtractionImageTransformation.from_dataset_mean(
test)
test_transformation_seq.add_transformation(perchannelsubtraction_trans)
print(" Adding PerChannelSubtractionImageTransformation [test] (value: " +
str(perchannelsubtraction_trans.values) + ")")
perchanneldevision_trans = PerChannelDivisionImageTransformation.from_dataset_stddev(
test)
test_transformation_seq.add_transformation(perchanneldevision_trans)
print(" Adding PerChannelDivisionImageTransformation [test] (value: " +
str(perchanneldevision_trans.values) + ")")
#initializing minibatch
print("Initializing minibatch generators ...")
train_minibatchgen = MiniBatchGenerator(train, MINI_BATCH_SIZE,
train_transformation_seq)
print(" [train] " + str(train.size()) + " samples, " +
str(train_minibatchgen.nbatches()) + " minibatches of size " +
str(train_minibatchgen.getbs()) + "")
val_minibatchgen = MiniBatchGenerator(val, 100, val_transformation_seq)
print(" [val] " + str(val.size()) + " samples, " +
str(val_minibatchgen.nbatches()) + " minibatches of size " +
str(val_minibatchgen.getbs()) + "")
#defining NN structure
print("Initializing CNN and optimizer ...")
def variable_with_weight_decay(name, shape):
#initial = tf.truncated_normal(shape, stddev=0.1)
for sample_i, sample in enumerate(val_data):
newsample=transformation_seq.apply(sample)
newdataset.append(newsample)
val_data=np.array(newdataset)
val_hog.setDataset(val_data, val_labels, val_label_names)
newdataset=[]
for sample_i, sample in enumerate(test_data):
newsample=transformation_seq.apply(sample)
newdataset.append(newsample)
test_data=np.array(newdataset)
test_hog.setDataset(test_data, test_labels, test_label_names)
#initializing minibatch
train_minibatchgen=MiniBatchGenerator(train_hog, MINI_BATCH_SIZE)
print("Initializing minibatch generators ...")
print(" [train] "+str(train_hog.size())+" samples, "+str(train_minibatchgen.nbatches())+" minibatches of size "+str(train_minibatchgen.getbs())+"")
val_minibatchgen=MiniBatchGenerator(val_hog, 100)
print(" [val] "+str(val_hog.size())+" samples, "+str(val_minibatchgen.nbatches())+" minibatches of size "+str(val_minibatchgen.getbs())+"")
best_model_accuracy = -1.0
best_network = None
best_learning_rate = None
best_weight_decay = None
for learning_rate in LEARNING_RATE_RANGE:
for weight_decay in WEIGHT_DECAY_RANGE:
network = MlpNN(learning_rate, MOMENTUM, weight_decay, nclasses, vectorsize, HIDDEN_LAYER_SIZE)
ds_train = Dataset(DATASET_DIR, 'train')
ds_val = Dataset(DATASET_DIR, 'val')
# Get the class names for this dataset
class_names = ds_train.label_names
# Initialize the preprocessing pipeline
print("Setting up preprocessing ...")
tform = get_normalization_transform(
means=ds_train.get_mean(per_channel=True),
stds=ds_train.get_stddev(per_channel=True)
)
# Initialize the MiniBatch generators
print("Initializing minibatch generators ...")
mb_train = MiniBatchGenerator(ds_train, batchsize, tform)
mb_val = MiniBatchGenerator(ds_val, batchsize, tform)
print(" [%s] %i samples, %i minibatches of size %i" % (
'train', mb_train.dataset.size(), mb_train.nbatches(), mb_train.batchsize()))
print(" [%s] %i samples, %i minibatches of size %i" % (
'val', mb_val.dataset.size(), mb_val.nbatches(), mb_val.batchsize()))
if use_class_weights:
print("Using class weights")
class_weight = utils.get_class_weight(class_names, ds_train.classes())
for c, w in class_weight.items():
print(" [%s] %f" % (class_names[c], w))
else:
class_weight = None
newdataset = []
for sample_i, sample in enumerate(val_data):
newsample = transformation_seq.apply(sample)
newdataset.append(newsample)
val_data = np.array(newdataset)
val_hog.setDataset(val_data, val_labels, val_label_names)
newdataset = []
for sample_i, sample in enumerate(test_data):
newsample = transformation_seq.apply(sample)
newdataset.append(newsample)
test_data = np.array(newdataset)
test_hog.setDataset(test_data, test_labels, test_label_names)
#initializing minibatch
train_minibatchgen = MiniBatchGenerator(train_hog, MINI_BATCH_SIZE)
print("Initializing minibatch generators ...")
print(" [train] " + str(train_hog.size()) + " samples, " +
str(train_minibatchgen.nbatches()) + " minibatches of size " +
str(train_minibatchgen.getbs()) + "")
val_minibatchgen = MiniBatchGenerator(val_hog, 100)
print(" [val] " + str(val_hog.size()) + " samples, " +
str(val_minibatchgen.nbatches()) + " minibatches of size " +
str(val_minibatchgen.getbs()) + "")
best_model_accuracy = -1.0
best_network = None
best_learning_rate = None
best_weight_decay = None
import io
import numpy as np
from TinyCifar10Dataset import TinyCifar10Dataset
from MiniBatchGenerator import MiniBatchGenerator
from ImageVectorizer import ImageVectorizer
import common
cifar10batchesdir=common.configs["cifar10batchesdir"]
bs=60
print ("=== Testing with TinyCifar10Dataset ===")
print ()
train = TinyCifar10Dataset(cifar10batchesdir, 'train')
minibatchgen=MiniBatchGenerator(train, 60)
print ("Dataset has "+str(train.size())+" samples")
print ("Batch generator has "+str(minibatchgen.nbatches())+" minibatches, minibatch size: "+str(bs))
print ()
data, labels, indexes=minibatchgen.batch(0)
print ("Minibatch #0 has "+str(len(data))+" samples")
print (" Data shape: "+str(data.shape))
print (" First 10 sample IDs: "+str(indexes[:10]).strip(']').strip('[').replace(' ',''))
data, labels, indexes=minibatchgen.batch(66)
print ("Minibatch #66 has "+str(len(data))+" samples")
print (" First 10 sample IDs: "+str(indexes[:10]).strip(']').strip('[').replace(' ',''))
print ()
print ("Shuffling samples")
print ()