if __name__ == '__main__':
# Example to fine-tune on 3000 samples from Cifar10
classes = ['One', 'Two', 'Three', 'Four', 'Five']
num_classes = len(classes)
# 20% of the data will automatically be used for validation
validation_size = 0.8
img_size = 224
num_channels = 3
train_path = 'training_data1'
# We shall load all the training and validation images and labels into memory using openCV and use that during training
train_images, train_labels, validation_images, validation_labels = dataset.read_train_sets(
train_path, img_size, classes, validation_size=validation_size)
X_train, Y_train, X_valid, Y_valid = train_images, train_labels, validation_images, validation_labels
img_rows, img_cols = 224, 224 # Resolution of inputs
channel = 3
num_classes = 5
batch_size = 16
nb_epoch = 10
# Load Cifar10 data. Please implement your own load_data() module for your own dataset
# X_train, Y_train, X_valid, Y_valid = load_cifar10_data(img_rows, img_cols)
# Load our model
model = resnet50_model(img_rows, img_cols, channel, num_classes)
# Start Fine-tuning
#
def shuffle_in_unison(a, b):
assert len(a) == len(b)
shuffled_a = np.empty(a.shape, dtype=a.dtype)
shuffled_b = np.empty(b.shape, dtype=b.dtype)
permutation = np.random.permutation(len(a))
for old_index, new_index in enumerate(permutation):
shuffled_a[new_index] = a[old_index]
shuffled_b[new_index] = b[old_index]
return shuffled_a, shuffled_b
data = dataset.read_train_sets("D:\\Amaury\\Ian\\datasetTest",
220, ["w1", "w2"],
validation_size=.4)
# trainData, trainLabels, trainID, trainCLS = dataset.load_train("D:\\Amaury\\Ian\\Data\\train\\Temp Wood", 220, ["w1", "w2"])
# valData, valLabels, valID, valCLS = dataset.load_train("D:\\Amaury\\Ian\\Data\\validation\\Temp Wood", 220, ["w1", "w2"])
trainData = data.train.images
trainLabels = data.train.labels
valData = data.valid.images
valLabels = data.valid.labels
print("start")
print(trainData.shape)
print(trainLabels.shape)
print(valData.shape)
print(valLabels.shape)
return K.sum(K.log(x0) - K.log(x1))
#Prepare input data
train_path='training_data'
classes = ['video_frames']
print(classes)
num_classes = len(classes)
# 10% of the data will automatically be used for validation
validation_size = 0.1
img = cv2.imread('C:\\Users\\darsh\\PycharmProjects\\final\\training_data\\video_frames\\video_frames 0001.jpg')
img_size_w,img_size_h,_ = img.shape
num_channels = 3
sample_size = 1926
data = dataset.read_train_sets(train_path, 400, ['video_frames'], validation_size=validation_size, sample_size=sample_size)
print("Complete reading input data. Will Now print a snippet of it")
print("Number of files in Training-set:\t\t{}".format(len(data.train.labels)))
print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))
total_pixels = img_size_w * img_size_h * 3
translator_factor = 2
translator_layer_size = 500
middle_factor = 2
middle_layer_size = 250
batch_size = 32
num_classes = 10
epochs = 100
x_train, _, _, _ = data.train.next_batch(1776)
x_test, _, _, _ = data.valid.next_batch(150)
image_list = []
# Build the dataset
classnames = ['C1H','C2H','C1L','C2L','C1M','S1L','URML','URMM','W1','W2']
for i in classnames:
dir_list = os.listdir(os.path.join(base_dir,i))
print("class " + str(i) + " has " + str(len((dir_list))) + " images")
image_list.extend(dir_list)
print("total images: " + str(len(image_list)))
# build the model
data = dataset.read_train_sets(base_dir,220,["C1H","C2H","C1L","C2L"],validation_size=.4)
trainData = data.train.images
trainLabels = data.train.labels
valData = data.valid.images
valLabels = data.valid.labels
print(trainData.shape)
print(trainLabels.shape)
print(valData.shape)
print(valLabels.shape)
conv_base = keras.applications.vgg16.VGG16(weights = 'imagenet',include_top = False, input_shape = (220,220,3),classes = 10)
conv_base.trainable = False
def load_test_dataset():
return dataset.read_train_sets(test_path, img_size, classes, validation_size=validation_size)
import math
import random
import numpy as np
from numpy.random import seed
seed(10)
tf.set_random_seed(20)
# tf.random.set_seed(20)
batch_size = 500
classes = ['cat', 'dog']
num_classes = len(classes)
test_size = 0.2
img_size = 64
num_channels = 3
train_path = 'data/train'
data = dataset.read_train_sets(train_path, img_size, classes, test_size=test_size)
print("数据读取完毕")
print("训练集的数量为：{}".format(len(data.train._images)))
print("测试集的数量为：{}".format(len(data.test._images)))
session = tf.Session() # 2.0版本没有Session模块
# tf.compat.v1.disable_eager_execution()
x = tf.placeholder(tf.float32, shape=[None, img_size, img_size, num_channels], name='x')
# labels
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
y_true_cls = tf.argmax(y_true, 1)
filter_size_conv1 = 3
num_filters_conv1 = 32
def test():
data = dataset.read_train_sets(train_path,
image_size,
classes,
validation_size=0.9)
evaluate(data.valid, batch_size=batch_size)
classes = ['dogs', 'cats']
num_classes = len(classes)
# We've modified this so it pulls from training and testing_data respectively
validation_size = 0
img_size = 32
num_channels = 3
# If train_path set to generated_data, we are not training on the original data, we are training
# on generated fake data.
train_path = "train"
val_path = "test"
# We shall load all the training and validation images and labels into memory using openCV and use that during training
data = dataset.read_train_sets(train_path, val_path, img_size, classes)
print("Complete reading input data. Will Now print a snippet of it")
print("Number of files in Training-set:\t\t{}".format(len(data.train.labels)))
print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))
session = tf.Session()
x = tf.placeholder(tf.float32,
shape=[None, img_size, img_size, num_channels],
name='x')
## labels
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
y_true_cls = tf.argmax(y_true, dimension=1)
##Network graph params
for dir_name in dirs:
if dir_name != '.' and dir_name != '..':
classes.append(dir_name)
num_classes = len(classes)
if num_classes == 0:
print "[!!] Directorio del dataset de entrenamiento vacio"
exit()
print "[i] Leyendo imagenes del dataset, puede tomar varios segundos"
# Lectura y preparacion de el set de datos
data = dataset.read_train_sets(dataset_train,
img_size,
classes,
validation_size=(FLAGS.validation_size / 100.0))
print "[i] Lectura del dataset completada"
print "[i] Dataset de entrenamiento: %s" % (dataset_train)
print "[i] %s clases: (%s)" % (num_classes, classes)
print "[i] %s%% de datos para validacion" % (FLAGS.validation_size)
print "[i] Batch: %s" % (FLAGS.batch)
print "[i] Precision deseada: %s%%" % (FLAGS.accuracy_target)
print("[i] Numero de elementos de entrenamiento:\t\t{}".format(
len(data.train.labels)))
print("[i] Numero de elementos de validacion:\t{}".format(
len(data.valid.labels)))
raw_input("[i] Presione cualquier tecla para comenzar el entrenamiento...")
#Adding Seed so that random initialization is consistent
seed(1)
set_random_seed(2)
#Prepare input data
classes = [0, 1]
num_classes = len(classes)
img_size = 128
num_channels = 3
# We shall load all the training and validation images and labels into memory
# using openCV and use that during training
#data = dataset.read_train_sets(args.labelsfile, args.imagedir, img_size, classes, validation_size=VALIDATION_SIZE)
data = dataset.read_train_sets(args.imagedir,
img_size,
classes,
validation_size=VALIDATION_SIZE)
# Shapes of training set
print("Training set (images) shape: {shape}".format(
shape=data.train.images.shape))
print("Training set (labels) shape: {shape}".format(
shape=data.train.labels.shape))
# Shapes of test set
print("Test set (images) shape: {shape}".format(
shape=data.valid.images.shape))
print("Test set (labels) shape: {shape}".format(
shape=data.valid.labels.shape))
print("Complete reading input data. ")
print("Number of files in Training-set:\t\t{}".format(
img_size = mdata["train"]["img_size"]
num_channels = mdata["train"]["channel"]
#Copy training data to the 'training_data' folder under running directory
trn_dat_dir = run_dir + "/" + "training_data"
if not os.path.exists(trn_dat_dir):
os.makedirs(trn_dat_dir)
for cls in classes:
if os.path.exists(trn_dat_dir + "/" + cls):
os.system("rm -rf " + trn_dat_dir + "/" + cls)
cmd = "cp -R " + mdata["classes"][cls] + " " + trn_dat_dir + "/" + cls
os.system(cmd)
# Load all the training and validation images and labels into memory using openCV and use that during training
data = dataset.read_train_sets(trn_dat_dir,
img_size,
classes,
validation_size=validation_size)
logger.info("Complete processing input data:")
logger.info("Number of files in Training-set:\t{}".format(
len(data.train.labels)))
logger.info("Number of files in Validation-set:\t{}".format(
len(data.valid.labels)))
# Declare placeholders
x = tf.placeholder(tf.float32,
shape=[None, img_size, img_size, num_channels],
name='x')
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
y_true_cls = tf.argmax(y_true, dimension=1)
# Create neural networks according to the json file
#Prepare input data
classes = range(0, 36)
num_classes = len(classes)
# 20% of the data will automatically be used for validation
validation_size = 0.2
test_size = 0.2
img_size = 56
num_channels = 1
train_path = ''
# We shall load all the training and validation images and labels into memory and use that during training
data = dataset.read_train_sets(train_path,
img_size,
num_channels,
classes,
validation_size=validation_size,
test_size=test_size)
print("Complete reading input data. Will Now print a snippet of it")
print("Number of files in Training-set:\t\t{}".format(len(data.train.labels)))
print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))
print("Number of files in Test-set:\t{}".format(len(data.test.labels)))
session = tf.Session()
x = tf.placeholder(tf.float32,
shape=[None, img_size, img_size, num_channels],
name='x')
## labels
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
# class info
num_classes = 2
# batch size
batch_size = 1
# validation split
validation_size = .1
# how long to wait after validation loss stops improving before terminating training
early_stopping = None # use None if you don't want to implement early stopping
checkpoint_dir = 'model/'
# Load data
data = dataset.read_train_sets(batch_size=batch_size,
validation_size=validation_size)
print("Size of:")
print("- Training-set:\t\t{}".format(len(data.train.output)))
print("- Validation-set:\t{}".format(len(data.valid.output)))
D = len(data.train.input[1])
VD = len(data.valid.input[1])
for i in range(len(data.valid.output)):
pass
print('i = ', i, 'item = ', data.valid.output[i])
print('Input dimension', data.valid.input) # (5394, 2655)
print('Input valid dimension', data.valid.output) # (5394,)
# validation split
validation_size = .16
# how long to wait after validation loss stops improving before terminating training
early_stopping = None # use None if you don't want to implement early stoping
train_path = 'data/train/'
test_path = 'data/test1/dogs/'
checkpoint_dir = "models/"
#data = dataset.read_train_sets(train_path, img_size, classes, validation_size=validation_size)
test_images, test_ids = dataset.read_test_set(test_path, img_size)
data = dataset.read_train_sets(train_path,
img_size,
classes,
validation_size=validation_size)
print("Size of:")
print("- Training-set:\t\t{}".format(len(data.train.labels)))
print("- Test-set:\t\t{}".format(len(test_images)))
print("- Validation-set:\t{}".format(len(data.valid.labels)))
def plot_images(images, cls_true, cls_pred=None):
assert len(images) == len(cls_true) == 9
if len(images) == 0:
print("no images to show")
return
# else:
def trainer(eval_type, dataset_type, input_type, validation_size, nfolds,
batch_size, num_iter, classes, data_path):
# Add seed for consistent random initialization
from numpy.random import seed
seed(1)
from tensorflow import set_random_seed
set_random_seed(2)
# Define data for k-fold cross-validation
#nfolds = 10
total_true_labels = []
total_predict_labels = []
# Define data for subject-based validation
#nfolds = 21 # number of subjects (people) # TT: 7
#batch_size = 32
# Prepare input data
#classes = ['enthusiastic','neutral','concerned']
num_classes = len(classes)
# Define the percentage of the data that will automatically be used for validation
#validation_size = 0.1
img_size = 90
num_channels = 1
#train_path='data/classes/'
train_path = data_path + 'classes/'
if eval_type == dataset.VALID_METHOD_KFOLD:
# Load training and validation images, dividing them in folds for cross-validation
data = dataset.read_train_sets(train_path,
img_size,
classes,
validation_size=validation_size,
nfolds=nfolds,
input_type=input_type)
elif eval_type == dataset.VALID_METHOD_SUBJECT:
# Load training and validation images, dividing them in subject-based folds for cross-validation
# (each of the folds has all the data corresponding to the same subject -person-)
data = dataset.read_train_sets_persubject(
train_path,
img_size,
classes,
validation_size=validation_size,
nsubjects=nfolds,
input_type=input_type,
dataset_type=dataset_type)
else:
print 'WARNING: the validation method is not a valid method or does not exist'
# Define parameters of neural network model
own_filter_size_conv1 = 7
own_num_filters_conv1 = 32
own_filter_size_conv2 = 1
own_num_filters_conv2 = 64
own_filter_size_conv3 = 3
own_num_filters_conv3 = 96
own_filter_size_conv4 = 5
own_num_filters_conv4 = 256
own_fc_layer_size = 256
own_fc_layer_size2 = 90
def create_weights(shape):
return tf.Variable(tf.truncated_normal(shape, stddev=0.05))
def create_biases(size):
return tf.Variable(tf.constant(0.05, shape=[size]))
def create_convolutional_layer(input, num_input_channels, conv_filter_size,
num_filters, conv_stride, pool_filter_size,
pool_stride):
# Initialize the weights and biases (taking the values from a normal distribution) to be trained
weights = create_weights(shape=[
conv_filter_size, conv_filter_size, num_input_channels, num_filters
])
biases = create_biases(num_filters)
## Create the convolutional layer
layer = tf.nn.conv2d(input=input,
filter=weights,
strides=[1, conv_stride, conv_stride, 1],
padding='SAME')
layer += biases
## Implement max-pooling
layer = tf.nn.max_pool(
value=layer,
ksize=[1, pool_filter_size, pool_filter_size, 1],
strides=[1, pool_stride, pool_stride, 1],
padding='SAME')
## Feed the output of the max pooling to a ReLu activation function
layer = tf.nn.relu(layer)
return layer
def create_flatten_layer(layer):
# Get shape of previous layer
layer_shape = layer.get_shape()
## Calculate number of features
num_features = layer_shape[1:4].num_elements()
## Flatten the layer (length = number of features)
layer = tf.reshape(layer, [-1, num_features])
return layer
def create_fc_layer(input, num_inputs, num_outputs, use_relu=True):
# Define trainable weights and biases
weights = create_weights(shape=[num_inputs, num_outputs])
biases = create_biases(num_outputs)
# Generate output (wx+b, where x is the input, w the weights and b the biases)
layer = tf.matmul(input, weights) + biases
if use_relu:
layer = tf.nn.relu(layer)
return layer
# Start cross-validation
for j in range(nfolds):
session = tf.Session()
if input_type == dataset.INPUT_FULLFACE:
# (Note that 'None' allows the loading of any number of images)
x = tf.placeholder(tf.float32,
shape=[None, img_size, img_size, num_channels],
name='x') # normal version (non-cropped)
elif input_type == dataset.INPUT_EYES:
x = tf.placeholder(
tf.float32,
shape=[None, img_size / 3, img_size, num_channels],
name='x')
## Create variable for ground truth labels
y_true = tf.placeholder(tf.float32,
shape=[None, num_classes],
name='y_true')
y_true_cls = tf.argmax(y_true, axis=1)
# Create CNN
layer_conv1 = create_convolutional_layer(
input=x,
num_input_channels=num_channels,
conv_filter_size=own_filter_size_conv1,
num_filters=own_num_filters_conv1,
conv_stride=1,
pool_filter_size=2,
pool_stride=2)
layer_conv2 = create_convolutional_layer(
input=layer_conv1,
num_input_channels=own_num_filters_conv1,
conv_filter_size=own_filter_size_conv2,
num_filters=own_num_filters_conv2,
conv_stride=2,
pool_filter_size=2,
pool_stride=2)
layer_conv3 = create_convolutional_layer(
input=layer_conv2,
num_input_channels=own_num_filters_conv2,
conv_filter_size=own_filter_size_conv3,
num_filters=own_num_filters_conv3,
conv_stride=1,
pool_filter_size=2,
pool_stride=2)
layer_conv4 = create_convolutional_layer(
input=layer_conv3,
num_input_channels=own_num_filters_conv3,
conv_filter_size=own_filter_size_conv4,
num_filters=own_num_filters_conv4,
conv_stride=1,
pool_filter_size=2,
pool_stride=2)
layer_flat = create_flatten_layer(layer_conv4)
layer_fc1 = create_fc_layer(
input=layer_flat,
num_inputs=layer_flat.get_shape()[1:4].num_elements(),
num_outputs=own_fc_layer_size,
use_relu=True)
layer_fc1_do = tf.nn.dropout(layer_fc1, keep_prob=0.5)
layer_fc2 = create_fc_layer(input=layer_fc1_do,
num_inputs=own_fc_layer_size,
num_outputs=own_fc_layer_size2,
use_relu=True)
layer_fc3 = create_fc_layer(input=layer_fc2,
num_inputs=own_fc_layer_size2,
num_outputs=num_classes,
use_relu=False)
# Create variable for predicted labels
y_pred = tf.nn.softmax(layer_fc3, name='y_pred')
y_pred_cls = tf.argmax(y_pred, axis=1)
session.run(tf.global_variables_initializer())
cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(
logits=layer_fc3, labels=y_true)
cost = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(cost)
correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
session.run(tf.global_variables_initializer())
print 'Current training data:'
data.train.setCurrentDataset(nfolds, j)
print 'Current validation data:'
data.valid.setCurrentDataset(nfolds, j)
'''print 'Current labels in training folds:'
print data.train.cls
print 'Current labels in validation folds:'
print data.valid.cls'''
def show_progress(epoch, feed_dict_train, feed_dict_validate,
val_loss):
acc = session.run(accuracy, feed_dict=feed_dict_train)
val_acc = session.run(accuracy, feed_dict=feed_dict_validate)
msg = "Training Epoch {0} --- Training accuracy: {1:>6.1%}, validation accuracy: {2:>6.1%}, validation loss: {3:.3f}"
print msg.format(epoch + 1, acc, val_acc, val_loss)
global total_iterations
total_iterations = 0
saver = tf.train.Saver()
def train(num_iteration):
global total_iterations
for i in range(total_iterations, total_iterations + num_iteration):
x_batch, y_true_batch, _, cls_batch = data.train.next_batch(
batch_size, j)
x_valid_batch, y_valid_batch, _, valid_cls_batch = data.valid.next_batch(
batch_size, j)
feed_dict_tr = {x: x_batch, y_true: y_true_batch}
feed_dict_val = {x: x_valid_batch, y_true: y_valid_batch}
session.run(optimizer, feed_dict=feed_dict_tr)
if i % int(data.train.num_examples[j] / batch_size) == 0:
val_loss = session.run(cost, feed_dict=feed_dict_val)
epoch = int(i /
int(data.train.num_examples[j] / batch_size))
show_progress(epoch, feed_dict_tr, feed_dict_val, val_loss)
saver.save(session,
data_path + 'models/face-exp-model{}'.format(j))
total_iterations += num_iteration
print "STARTING NEW TRAINING --- TEST FOLD: {} OUT OF {}".format(
j + 1, nfolds)
train(num_iteration=num_iter)
print "Finished training for test fold", format(j)
# Store the current test dataset (the fold not used during training)
test_data = []
test_data.extend(data.train.images[j])
test_data.extend(data.valid.images[j])
test_labels = []
test_labels.extend(data.train.cls[j])
test_labels.extend(data.valid.cls[j])
# Test the trained CNN with the test data fold
if input_type == dataset.INPUT_FULLFACE:
predicted_labels = cnn_testing.testCNN(
test_data, test_labels, j, img_size, img_size, data_path,
classes) # normal version (non-cropped)
elif input_type == dataset.INPUT_EYES:
predicted_labels = cnn_testing.testCNN(test_data, test_labels, j,
img_size / 3, img_size,
data_path, classes)
else:
print 'WARNING: type of input content is not valid!'
total_true_labels.extend(test_labels)
total_predict_labels.extend(predicted_labels)
# Reset the graph for the new CNN model
tf.reset_default_graph()
# Print final performance measurements after the cross-validation
confMat = sklearn.metrics.confusion_matrix(total_true_labels,
total_predict_labels)
print "Confusion matrix: (elements are C_ij, where i is the true class and j the predicted class)"
print classes
print confMat
print sklearn.metrics.classification_report(total_true_labels,
total_predict_labels,
target_names=classes)
def main():
#Prepare input data
train_path = sys.argv[1]
classes = os.listdir(train_path)
num_classes = len(classes)
# We shall load all the training and validation images and labels into memory using openCV
# and use that during training
data = dataset.read_train_sets(train_path,
img_size,
classes,
validation_size=validation_size)
print("Complete reading input data. Will Now print a snippet of it")
print("Number of files in Training-set:\t\t{}".format(
len(data.train.labels)))
print("Number of files in Validation-set:\t{}".format(
len(data.valid.labels)))
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.InteractiveSession(config=config)
# TF variables
x = tf.placeholder(tf.float32,
shape=[None, img_size, img_size, num_channels],
name='x')
# labels
y_true = tf.placeholder(tf.float32,
shape=[None, num_classes],
name='y_true')
y_true_cls = tf.argmax(y_true, dimension=1)
# CNN Archiecture
layer_conv1 = create_convolutional_layer(
input=x,
num_input_channels=num_channels,
conv_filter_size=filter_size_conv1,
num_filters=num_filters_conv1)
layer_conv2 = create_convolutional_layer(
input=layer_conv1,
num_input_channels=num_filters_conv1,
conv_filter_size=filter_size_conv2,
num_filters=num_filters_conv2)
layer_conv3 = create_convolutional_layer(
input=layer_conv2,
num_input_channels=num_filters_conv2,
conv_filter_size=filter_size_conv3,
num_filters=num_filters_conv3)
layer_conv4 = create_convolutional_layer(
input=layer_conv3,
num_input_channels=num_filters_conv3,
conv_filter_size=filter_size_conv4,
num_filters=num_filters_conv4)
layer_conv5 = create_convolutional_layer(
input=layer_conv4,
num_input_channels=num_filters_conv4,
conv_filter_size=filter_size_conv5,
num_filters=num_filters_conv5)
layer_conv6 = create_convolutional_layer(
input=layer_conv5,
num_input_channels=num_filters_conv5,
conv_filter_size=filter_size_conv6,
num_filters=num_filters_conv6)
layer_conv7 = create_convolutional_layer(
input=layer_conv6,
num_input_channels=num_filters_conv6,
conv_filter_size=filter_size_conv7,
num_filters=num_filters_conv7)
layer_conv8 = create_convolutional_layer(
input=layer_conv7,
num_input_channels=num_filters_conv7,
conv_filter_size=filter_size_conv8,
num_filters=num_filters_conv8)
layer_flat = create_flatten_layer(layer_conv8)
layer_fc1 = create_fc_layer(
input=layer_flat,
num_inputs=layer_flat.get_shape()[1:4].num_elements(),
num_outputs=fc_layer_size,
use_relu=True)
layer_fc2 = create_fc_layer(input=layer_fc1,
num_inputs=fc_layer_size,
num_outputs=num_classes,
use_relu=False)
y_pred = tf.nn.softmax(layer_fc2, name='y_pred')
y_pred_cls = tf.argmax(y_pred, dimension=1)
# Hyperparameters
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=layer_fc2,
labels=y_true)
cost = tf.reduce_mean(cross_entropy)
optimiser = tf.train.GradientDescentOptimizer(learningRate).minimize(cost)
correct_prediction = tf.equal(y_pred_cls, y_true_cls)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
val_accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# TF Summary Variables
tf.summary.scalar('accuracy', accuracy)
tf.summary.scalar('val_accuracy', val_accuracy)
tf.summary.scalar('cost', cost)
merged = tf.summary.merge_all()
# Tensorboard summary file writers
train_writer = tf.summary.FileWriter('summary/train_arch_12',
session.graph)
test_writer = tf.summary.FileWriter('summary/test_arch_12')
session.run(tf.global_variables_initializer())
saver = tf.train.Saver()
# Train model
train(session,
data,
x,
y_true,
cost,
optimiser,
accuracy,
merged,
val_accuracy,
train_writer,
test_writer,
saver,
num_iteration=2000)
# Save a model checkpoint
saver.save(session, './arch_12')
help="path to the output loss/accuracy plot")
ap.add_argument("-m",
"--model",
required=True,
help="path to save train model")
args = vars(ap.parse_args())
print("[INFO] loading dataset")
validation_size = 0.2
img_size = 48
num_channels = 2
train_path = '/media/data2/mhy/data/0911'
labelNames = ['r1', 'r2']
data = dataset.read_train_sets(train_path, img_size, labelNames,
validation_size)
print("Complete reading input data.Will Now print a snippet of it")
trainX = data.train.images
trainY = data.train.labels
testX = data.valid.images
testY = data.vaild.labels
# ((trainX, trainY), (testX, testY)) = cifar10.load_data()
# trainX = trainX.astype("float") / 255.0
# testX = testX.astype("float") / 255.0
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)
print("[INFO] compiling model...")
#20% of the data will automatically be used for validation
validation_size = 0.2
img_size = 128
num_channels = 3
train_path=r'C:\Users\T01144\Desktop\T01144\IDLE Scripts\Image Classification\Using Tensorflow\data\train'
#Prepare input data
if not os.path.exists(train_path):
print("No such directory")
raise Exception
classes = os.listdir(train_path)
num_classes = len(classes)
# We shall load all the training and validation images and labels into memory using openCV and use that during training
data = dataset.read_train_sets(train_path, img_size, classes, validation_size=validation_size)
# Display the stats
print("Complete reading input data. Will Now print a snippet of it")
print("Number of files in Training-set:\t\t{}".format(len(data.train.labels)))
print("Number of files in Validation-set:\t{}".format(len(data.valid.labels)))
session = tf.Session()
x = tf.placeholder(tf.float32, shape=[None, img_size,img_size,num_channels], name='x')
## labels
y_true = tf.placeholder(tf.float32, shape=[None, num_classes], name='y_true')
y_true_cls = tf.argmax(y_true, dimension=1)
##Network graph params
filter_size_conv1 = 3
import tflearn
from tflearn.layers.conv import conv_2d, max_pool_2d
from tflearn.layers.core import input_data, dropout, fully_connected
from tflearn.layers.estimator import regression
IMG_SIZE = 50 #resolution to which images are resized
ALPHA = .0001 #learning rate
trainDirectory = "./training_data"
testDirectory = "./testing_data"
#define name for the model, change if # of convolutional layers is changed
modelName = "corgiClass-{}--{}".format(ALPHA, '4_conv_layers_final')
#define training dataset, 20% are for validation
dSet = dataset.read_train_sets("./data/training_data", IMG_SIZE, ['pembroke', 'cardigan'], .2)
#define test dataset, since its the test, 0 are for validation
testSet = dataset.read_train_sets("./data/training_data", IMG_SIZE, ['pembroke', 'cardigan'], 0)
# Building convolutional neural net
#input layer
convnet = input_data(shape=[None, IMG_SIZE, IMG_SIZE, 3], name='input')
#convolutional layers
convnet = conv_2d(convnet, 32, 2, activation='relu')
convnet = max_pool_2d(convnet, 2)
convnet = conv_2d(convnet, 64, 2, activation='relu')
convnet = max_pool_2d(convnet, 2)