def img_size_run_cnn(size):
print('\n\n\nstart with size: ' + str(size))
folder_to_save = './out/alex_s' + str(size) + '_' + str(ITERATION)
folder_to_load = './out/alex_s' + str(size) + '_' + str(ITERATION-1) + '/model/alex_model'
x, y = image_preloader(TRAIN_DATA,
image_shape=(size, size),
mode='file',
files_extension=['.png'])
x_val, y_val = image_preloader(VAL_DATA,
image_shape=(size, size),
mode='file',
files_extension=['.png'])
model = get_alex_model(
filter_size=size,
folder_to_save=folder_to_save,
folder_to_load=folder_to_load,
image_size=size,
strides=4,
learning_rate=0.0003,
)
print('\nStart training ...')
model.fit(x,
y,
n_epoch=40,
validation_set=(x_val, y_val),
shuffle=True,
batch_size=128,
show_metric=True,
snapshot_epoch=True,
run_id='alex_TB5')
print('\nStart saving ...')
model.save(folder_to_save + '/model/model')
def get_data(data_dir, hdf5):
"""This function loads in the data, either by loading images on the fly or by creating and
loading from a hdf5 database.
Args:
data_dir: Root directory of the dataset.
hdf5: Boolean. If true, (create and) load data from a hdf5 database.
Returns:
X: training images.
Y: training labels.
X_test: validation images.
Y_test: validation labels."""
# Get the filenames of the lists containing image paths and labels.
train_file, val_file = build_dataset_index(data_dir)
# Check if (creating and) loading from hdf5 database is desired.
if hdf5:
# Create folder to store dataset.
if not os.path.exists('hdf5'):
os.makedirs('hdf5')
# Check if hdf5 databases already exist and create them if not.
if not os.path.exists('hdf5/tiny-imagenet_train.h5'):
from tflearn.data_utils import build_hdf5_image_dataset
print ' Creating hdf5 train dataset.'
build_hdf5_image_dataset(train_file, image_shape=(256, 256), mode='file',
output_path='hdf5/tiny-imagenet_train.h5', categorical_labels=True, normalize=True)
if not os.path.exists('hdf5/tiny-imagenet_val.h5'):
from tflearn.data_utils import build_hdf5_image_dataset
print ' Creating hdf5 val dataset.'
build_hdf5_image_dataset(val_file, image_shape=(256, 256), mode='file',
output_path='hdf5/tiny-imagenet_val.h5', categorical_labels=True, normalize=True)
# Load training data from hdf5 dataset.
h5f = h5py.File('hdf5/tiny-imagenet_train.h5', 'r')
X = h5f['X']
Y = h5f['Y']
# Load validation data.
h5f = h5py.File('hdf5/tiny-imagenet_val.h5', 'r')
X_test = h5f['X']
Y_test = h5f['Y']
# Load images directly from disk when they are required.
else:
from tflearn.data_utils import image_preloader
X, Y = image_preloader(train_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True,
filter_channel=True)
X_test, Y_test = image_preloader(val_file, image_shape=(64, 64), mode='file', categorical_labels=True,
normalize=True, filter_channel=True)
# Randomly shuffle the dataset.
# X, Y = shuffle(X, Y)
return X, Y, X_test, Y_test
def main(args):
experiment = 'dl-histograms'
channels = 1
width = 64
height = 64
num_class = 2
epochs = 15
folds = 5
architecturescount = 10
architectureid = args.architectureid
fold = args.fold
test_file = '../../images/sampling/lists/histograms/test-images.txt'
# for architectureid in range(1,architecturescount):
accuracies = []
#for fold in range(1,folds):
runid = '{}-architecture{}-fold{}'.format(experiment, architectureid, fold)
arch = architecture(architectureid, width, height, channels, num_class)
train_file = '../../images/sampling/lists/histograms/splits/train-cv-{}.txt'.format(
fold)
validate_file = '../../images/sampling/lists/histograms/splits/validate-cv-{}.txt'.format(
fold)
X, Y = image_preloader(train_file,
image_shape=(height, width),
mode='file',
categorical_labels=True,
normalize=True)
valX, valY = image_preloader(validate_file,
image_shape=(height, width),
mode='file',
categorical_labels=True,
normalize=True)
testX, testY = image_preloader(test_file,
image_shape=(height, width),
mode='file',
categorical_labels=True,
normalize=True)
arch.fit(X,
Y,
n_epoch=epochs,
validation_set=(valX, valY),
snapshot_step=10,
snapshot_epoch=False,
show_metric=True,
run_id=runid)
arch.save('arch-id{}-fold{}.tfl'.format(architectureid, fold))
# accuracies.append(arch.evaluate(testX, testY)[0])
# accuracies=np.asarray(accuracies)
accuracy = arch.evaluate(testX, testY)[0]
append(experiment, architectureid, fold, accuracy)
def filter_size_run_cnn(filter_size):
image_size = 128
strides = 4
batch_size = 2
if filter_size < 9:
strides = 2
print('\n\n\nstart with filter size: ' + str(filter_size) + '; and strides: ' + str(strides))
folder_to_save = './out_grey/alex_f' + str(filter_size) + '_' + str(ITERATION)
# folder_to_load = './out/alex_f' + str(filter_size) + '_' + str(ITERATION-1) + '/model/model'
folder_to_load = ''
x, y = image_preloader(TRAIN_DATA,
image_shape=(image_size, image_size),
# grayscale=True,
filter_channel=False,
mode='file',
files_extension=['.png'])
x_val, y_val = image_preloader(VAL_DATA,
image_shape=(image_size, image_size),
# grayscale=True,
filter_channel=False,
mode='file',
files_extension=['.png'])
print('loaded_data')
x = np.reshape(x, (len(x), 128, 128, 5))
x_val = np.reshape(x_val, (len(x_val), 128, 128, 5))
model = get_alex_model(
filter_size=filter_size,
folder_to_save=folder_to_save,
folder_to_load=folder_to_load,
image_size=image_size,
strides=strides,
learning_rate=0.0003,
depth=5,
)
print('\nStart training ...')
model.fit(x,
y,
n_epoch=50,
validation_set=(x_val, y_val),
shuffle=True,
batch_size=batch_size,
show_metric=True,
snapshot_epoch=True,
run_id='alex_TB5')
print('\nStart saving ...')
model.save(folder_to_save + '/model/model')
def get_data(data_dir, hdf5):
train_file, val_file = build_dataset_index(data_dir)
if hdf5:
if not os.path.exists('hdf5'):
os.makedirs('hdf5')
if not os.path.exists('hdf5/tiny-imagenet_train.h5'):
from tflearn.data_utils import build_hdf5_image_dataset
build_hdf5_image_dataset(train_file,
image_shape=(64, 64),
mode='file',
output_path='hdf5/tiny-imagenet_train.h5',
categorical_labels=True,
normalize=True)
if not os.path.exists('hdf5/tiny-imagenet_val.h5'):
from tflearn.data_utils import build_hdf5_image_dataset
build_hdf5_image_dataset(val_file,
image_shape=(64, 64),
mode='file',
output_path='hdf5/tiny-imagenet_val.h5',
categorical_labels=True,
normalize=True)
h5f = h5py.File('hdf5/tiny-imagenet_train.h5', 'r')
X = h5f['X']
Y = h5f['Y']
h5f = h5py.File('hdf5/tiny-imagenet_val.h5', 'r')
X_test = h5f['X']
Y_test = h5f['Y']
else:
from tflearn.data_utils import image_preloader
X, Y = image_preloader(train_file,
image_shape=(64, 64),
mode='file',
categorical_labels=True,
normalize=True,
filter_channel=True)
X_test, Y_test = image_preloader(val_file,
image_shape=(64, 64),
mode='file',
categorical_labels=True,
normalize=True,
filter_channel=True)
# Randomly shuffle the dataset.
X, Y = shuffle(X, Y)
return X, Y, X_test, Y_test
def make_prediction(MODEL_ARCHITECTURE, MODEL_WEIGHTS, PATH_FACES, N_PLOT):
# Load model
m = importlib.import_module(MODEL_ARCHITECTURE)
# Load neural net architecture
model = tflearn.DNN(
tflearn.regression(m.network(),
optimizer=m.optimizer(),
loss='mean_square'))
# Load neural net weights
model.load(MODEL_WEIGHTS, weights_only=True)
# Load images
X, y = image_preloader(PATH_FACES,
image_shape=(96, 96),
mode='folder',
normalize=True)
X = np.reshape(X, (-1, 96, 96, 1)) # Add 1 color channel
# Predict keypoints
Y = np.array(model.predict(X))
# Plot scatter points and save to .png
plot_samples(X, Y, N_PLOT, PATH_FACES)
# Write results to .csv
write_prediction(Y, PATH_FACES)
def transfer(prjname, basenet, numclasses, dims):
# load data
tf.reset_default_graph()
X1, Y1 = image_preloader(".\\data\\train\\classes",
image_shape=tuple(dims)[0:2],
mode="folder",
categorical_labels=True,
normalize=True,
files_extension=[".jpg", ".png"],
filter_channel=True)
# retrain basenet on new dataset
img_prep = ImagePreprocessing()
# 2FIX: normalization should be done per class and per channel
img_prep.add_featurewise_zero_center()
#img_prep.add_featurewise_stdnorm()
x1 = tflearn.input_data(shape=np.insert(np.asarray(dims, dtype=object), 0,
None).tolist(),
data_preprocessing=img_prep,
name="input")
mt1 = templates.fetch("vgg16")
numepochs = 2
validpct = 0.1
batchsize = 3
model1 = nets.train(mt1, x1, X1, Y1, numclasses, numepochs, validpct,
batchsize, "vgg16" + prjname)
model1.save(".\\logs\\ckp\\" + "vgg16goteborg\\" + "vgg16" + prjname +
".ckpt")
def getXY():
X, Y = image_preloader(train,
image_shape=(80, 80),
mode='folder',
categorical_labels='True',
normalize=True)
return X, Y
def load_data():
logging.info('preparing data, can take a while')
return image_preloader(TRAINING_DATA_FILE,
image_shape=IMAGE_INPUT_SIZE,
mode='file',
filter_channel=True,
normalize=True)
def alexnet_rocauc(
image_size=128,
strides=4,
filter_size=11,
folder_to_load='./out/alex_s128_2/model/model',
title='alex net 160 11',
):
x_val, y_val = image_preloader(VAL_DATA,
image_shape=(image_size, image_size),
mode='file',
files_extension=['.png'])
print('loaded_data')
x_val = np.reshape(x_val, (len(x_val), 128, 128, 1))
model = get_alex_model(
filter_size=filter_size,
folder_to_save='not_meter',
folder_to_load=folder_to_load,
image_size=image_size,
strides=strides,
learning_rate=0.0003,
depth=1,
)
arr_pred, arr_val = predict_all(model, x_val, y_val)
calculate_and_print_roc(arr_val, arr_pred, title=title)
def zfnet_rocauc(
image_size=128,
strides=2,
folder_to_load='./out_grey/zfnet_2/checkpoints-296040',
title='ZF Net',
):
x_val, y_val = image_preloader(VAL_DATA,
image_shape=(image_size, image_size),
mode='file',
files_extension=['.png'])
print('loaded_data')
x_val = np.reshape(x_val, (len(x_val), 128, 128, 1))
model = get_zf_model(
filter_size=7,
folder_to_save='not_meter',
folder_to_load=folder_to_load,
image_size=image_size,
strides=strides,
learning_rate=0.0003,
channels=1,
)
arr_pred, arr_val = predict_all(model, x_val, y_val, step=200)
calculate_and_print_roc(arr_val, arr_pred, title=title)
def filter_size_run_cnn():
image_size = 128
strides = 2
batch_size = 16
print('\n\n\nstart with filter size: ')
# folder_to_save = './out/zfnet_' + str(ITERATION)
# folder_to_load = './out/zfnet_1/checkpoints-96226'
folder_to_save = './out_grey/zfnet_' + str(ITERATION)
# folder_to_load = './out_grey/zfnet_' + str(ITERATION-1) + '/model/model'
folder_to_load = ''
x, y = image_preloader(TRAIN_DATA,
grayscale=True,
image_shape=(image_size, image_size),
mode='file',
files_extension=['.png'])
x_val, y_val = image_preloader(VAL_DATA,
grayscale=True,
image_shape=(image_size, image_size),
mode='file',
files_extension=['.png'])
x = np.reshape(x, (len(x), 128, 128, 1))
x_val = np.reshape(x_val, (len(x_val), 128, 128, 1))
model = get_zf_model(
filter_size=7,
folder_to_save=folder_to_save,
folder_to_load=folder_to_load,
image_size=image_size,
strides=strides,
learning_rate=0.0003,
channels=1,
)
print('\nStart training ...')
model.fit(x,
y,
n_epoch=50,
validation_set=(x_val, y_val),
shuffle=True,
batch_size=batch_size,
show_metric=True,
snapshot_epoch=True,
run_id='alex_TB5')
print('\nStart saving ...')
model.save(folder_to_save + '/model/model')
def get_data(data_dir):
train_file, val_file, conf_file = build_dataset_index(data_dir)
print(conf_file)
from tflearn.data_utils import image_preloader
# X_test, Y_test = image_preloader(val_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True, filter_channel=True)
X_conf, Y_conf = image_preloader(conf_file, image_shape=(64, 64), mode='file', categorical_labels=True, normalize=True, filter_channel=True)
# return X_test, Y_test, X_conf, Y_conf
return X_conf, Y_conf
def get_data_preloader():
X, Y = image_preloader(DATASET_FILE,
image_shape=(input_width, input_width),
mode='file',
categorical_labels=True,
normalize=True,
grayscale=False)
return X, Y
def predict(prjname,basenet,predictclass,perclass,numclasses,dims,withtransfer):
# load data
tf.reset_default_graph()
X1, Y1 = image_preloader(".\\data\\test\\classes",
image_shape=tuple(dims)[0:2],
mode="folder",
categorical_labels=True,
normalize=True,
files_extension=[".jpg",".png"],
filter_channel=True)
# retrain vgg16 on goteborg
img_prep = ImagePreprocessing()
# 2FIX: normalization should be done per channel
img_prep.add_featurewise_zero_center()
#img_prep.add_featurewise_stdnorm()
x1 = tflearn.input_data(shape=np.insert(np.asarray(dims, dtype=object),0,None).tolist(),
data_preprocessing=img_prep,
name="input")
if withtransfer:
checkpoint = "vgg16goteborg"
else:
checkpoint = "vgg16"
mt1 = templates.fetch(checkpoint)
#numclasses = 5
model1, _, codelist = nets.getcodes(mt1, x1, numclasses)
# prepare input for second stage
# 2DO: should X2 be normalized? is ReLUing sufficient?
pixclasses = numclasses + 1
X2 = codes.formatcodes(codelist,model1,x1,X1)
Y2 = utils.OHpixlabels(predictclass, perclass, pixclasses, dims[0], "test")
# use second net on codes
tf.reset_default_graph()
x2 = tflearn.input_data(shape=np.insert(np.asarray(list(X2.shape)[1:], dtype=object),0,None).tolist(),
name='mlp_input')
mt2 = templates.fetch("pixelnet2.2")
model2, _, _ = nets.getcodes(mt2, x2, pixclasses)
model2.load(".\\logs\\ckp\\" + "pixelnetgoteborg\\" + "pixelnet" + prjname + ".ckpt",weights_only=True)
outv = model2.predict(X2)
outv = np.asarray(outv)
pixclass = np.argmax(outv[0,:,:,:], axis=2)
preddir = ".\\data\\test\\preds"
os.makedirs(preddir, exist_ok=True)
np.save( preddir + "\\" "pred_0.npy",pixclass )
print("bien!")
def predict_type(self,bookdir):
# Import dataset
X, Y = image_preloader(bookdir, image_shape=(128, 128), mode='file',
categorical_labels=False, normalize=False)
Y = to_categorical(Y, 3)
print("-- Runbook Import Complete.")
# Predict label
prediction = self.model.predict(X)
return prediction
def read_image(self):
x, y = image_preloader(self.files_txt,
image_shape=(224, 224),
mode='file',
categorical_labels=True,
normalize=False,
files_extension=['.jpg', '.png'],
filter_channel=True)
self.x_matrix = np.array(x)
self.y_one_hot = np.array(y)
return self.x_matrix, self.y_one_hot
def prediction(img):
dataset = "rgb_faces.txt"
images, labels = image_preloader(dataset,
image_shape=(128, 128),
mode='file',
categorical_labels=True,
normalize=True)
preProc = tflearn.DataPreprocessing()
preProc.add_custom_preprocessing(resizeimg)
acc = tflearn.metrics.Accuracy()
network = input_data(shape=[None, 128, 128, 3])
'''data_preprocessing=preProc'''
''', data_preprocessing=img_prep,
data_augmentation=img_aug'''
network = conv_2d(network, 64, 3, activation='relu')
network = conv_2d(network, 64, 3, activation='relu')
network = max_pool_2d(network, 2, strides=2, name='maxpool')
network = conv_2d(network, 128, 3, activation='relu')
network = conv_2d(network, 128, 3, activation='relu')
network = max_pool_2d(network, 2, strides=2, name='maxpool')
network = conv_2d(network, 256, 3, activation='relu')
network = conv_2d(network, 256, 3, activation='relu')
network = conv_2d(network, 256, 3, activation='relu')
network = max_pool_2d(network, 2, strides=2, name='maxpool')
network = conv_2d(network, 512, 3, activation='relu')
network = conv_2d(network, 512, 3, activation='relu')
network = conv_2d(network, 512, 3, activation='relu')
network = max_pool_2d(network, 2, strides=2, name='maxpool')
network = fully_connected(network, 1024, activation='relu')
network = dropout(network, 0.5)
network = fully_connected(network, 512, activation='relu')
network = dropout(network, 0.5)
network = fully_connected(network, 5, activation='softmax')
network = regression(network,
optimizer='sgd',
loss='categorical_crossentropy')
model = tflearn.DNN(network, tensorboard_verbose=0)
model.load('./rgb_faces.tflearn')
return model.predict(img)
def vgg_rocauc(
folder_to_load='./out_grey/vgg_i1/checkpoints-185050',
title='VGG Net',
):
x_val, y_val = image_preloader(VAL_DATA,
image_shape=(128, 128),
mode='file',
files_extension=['.png'])
print('loaded_data')
x_val = np.reshape(x_val, (len(x_val), 128, 128, 1))
model = get_vgg_model(foler_to_save='not_meter', folder_to_load=folder_to_load, depth=1)
arr_pred, arr_val = predict_all(model, x_val, y_val, step=200)
calculate_and_print_roc(arr_val, arr_pred, title=title)
def train():
model_path = '.'
file_list = './train_fvgg_emo.txt'
X, Y = image_preloader(file_list, image_shape=(224,224), mode='file', categorical_labels=True,
normalize=False, files_extension=['.jpg', '.png'], filter_channel=True)
classes = 7
img_prep = ImagePreprocessing()
img_prep.add_featurewise_zero_center(mean=MEAN_VALUE, per_channel=True)
x = tflearn.input_data(shape=[None, 224, 224, 3], name='input', data_preprocessing=img_prep)
softmax = vgg16(x, classes)
# default optimizer='adam', loss='categorical_crossentropy'
regression = tflearn.regression(softmax, learning_rate=0.0001, restore=False)
# tensorboard_verbose=3: Loss, Accuracy, Gradients, Weights, Activations, Sparsity.(Best visualization)
model = tflearn.DNN(regression, checkpoint_path='./logs/vgg-finetuning/checkpoints/', max_checkpoints=3, tensorboard_verbose=2, tensorboard_dir='./logs/vgg-finetuning/summaries/')
model_file = os.path.join(model_path, 'vgg16.tflearn')
model.load(model_file, weights_only=True)
# start finetuning
model.fit(X, Y, n_epoch=20, validation_set=0.1, shuffle=True, show_metric=True, batch_size=64, snapshot_epoch=False, snapshot_step=200, run_id='vgg-finetuning')
model.save('./logs/vgg-finetuning/vgg_finetune_emo.tfmodel')
x = tflearn.fully_connected(x, num_class, activation='softmax', scope='fc8',
restore=False)
return x
data_dir = "/path/to/your/data"
model_path = "/path/to/your/vgg_model"
# the file gen by generated by gen_files_list.py
files_list = "/path/to/your/file/with/images"
from tflearn.data_utils import image_preloader
X, Y = image_preloader(files_list, image_shape=(224, 224), mode='file',
categorical_labels=True, normalize=False,
files_extension=['.jpg', '.png'], filter_channel=True)
# or use the mode 'floder'
# X, Y = image_preloader(data_dir, image_shape=(224, 224), mode='folder',
# categorical_labels=True, normalize=True,
# files_extension=['.jpg', '.png'], filter_channel=True)
num_classes = 10 # num of your dataset
# VGG preprocessing
img_prep = ImagePreprocessing()
img_prep.add_featurewise_zero_center(mean=[123.68, 116.779, 103.939],
per_channel=True)
# VGG Network
x = tflearn.input_data(shape=[None, 224, 224, 3], name='input',
data_preprocessing=img_prep)
restore=False)
return x
data_dir = "/path/to/your/data"
model_path = "/path/to/your/vgg_model"
# the file gen by generated by gen_files_list.py
files_list = "/path/to/your/file/with/images"
from tflearn.data_utils import image_preloader
X, Y = image_preloader(files_list,
image_shape=(224, 224),
mode='file',
categorical_labels=True,
normalize=True,
files_extension=['.jpg', '.png'],
filter_channel=True)
# or use the mode 'floder'
# X, Y = image_preloader(data_dir, image_shape=(224, 224), mode='folder', categorical_labels=True, normalize=True,
# files_extension=['.jpg', '.png'], filter_channel=True)
num_classes = 10 # num of your dataset
softmax = vgg16(num_classes)
regression = regression(softmax,
optimizer='adam',
loss='categorical_crossentropy',
learning_rate=0.001,
restore=False)
network = regression(network, optimizer='adam',
loss='categorical_crossentropy',
learning_rate=0.01)
# Define model
## To Do
## Define model and assign network. Same as training.
model = tflearn.DNN(network, tensorboard_verbose=0)
# Load Model into model object
## To Do.
## Use the model.load() function
model.load('a2.tfl')
# load test images
from tflearn.data_utils import image_preloader
import numpy as np
# Load path/class_id image file:
dataset_file = 'my_dataset.txt'
X_test, Y_test = image_preloader(dataset_file, image_shape=(32, 32), mode='file',
categorical_labels=True, normalize=True,
files_extension=['.jpg', '.png'], filter_channel=True)
X_test = np.array(X_test)
Y_test = np.array(Y_test)
# predict test images label
y_pred = model.predict(X_test)
# Compute accuracy of trained model on test images
print ("Accuracy: ",np.sum(np.argmax(y_pred, axis=1) == np.argmax(Y_test, axis=1))*100/Y_test.shape[0],"%")
from tflearn.data_utils import image_preloader
import tensorflow as tf
import sys
from pathlib import Path
import numpy as np
from PIL import Image
from tflearn.data_utils import resize_image
tf.reset_default_graph()
#Load Datasets
X, Y = image_preloader('C:\\Users\\lukas\\Documents\\Uni\\KI\\kat\\ROOT',
image_shape=(100, 125),
mode='folder',
categorical_labels=True,
normalize=True)
#Convolutional Neural Network
network = input_data(shape=[None, 125, 100, 4])
network = conv_2d(network, 100, 10, activation='relu')
network = max_pool_2d(network, 2)
network = conv_2d(network, 64, 3, activation='relu')
network = conv_2d(network, 64, 3, activation='relu')
network = max_pool_2d(network, 2)
network = fully_connected(network, 512, activation='relu')
network = dropout(network, 0.5)
network = fully_connected(network, 2, activation='softmax')
network = regression(network,
optimizer='adam',
NUM_PERSON = 1000
NUM_CLASS = 3755
NUM_TEST = int((NUM_CLASS * NUM_PERSON) * TEST_RATIO)
NUM_TRAIN = NUM_CLASS * NUM_PERSON - NUM_TEST
BATCH_SIZE = 128
TRAIN_DIR = '/data0/jiahao/hcl/train'
TEST_DIR = '/data0/jiahao/hcl/test'
EPOCH = 1
DROPOUT_PROB = 0.6
from tflearn.data_preprocessing import ImagePreprocessing
from tflearn.data_utils import image_preloader
train_data, train_labels = image_preloader(TRAIN_DIR,
image_shape=IMG_SIZE,
mode='folder',
normalize=True,
grayscale=True,
categorical_labels=True,
files_extension=None,
filter_channel=False)
test_data, test_labels = tflearn.data_utils.image_preloader(
TEST_DIR,
image_shape=IMG_SIZE,
mode='folder',
normalize=True,
grayscale=True,
categorical_labels=True,
files_extension=None,
filter_channel=False)
img_prep = ImagePreprocessing()
img_prep.add_featurewise_zero_center(mean=0)
tower_mixed = merge([tower_conv,tower_conv1_2], mode='concat', axis=3)
tower_out = relu(batch_normalization(conv_2d(tower_mixed, net.get_shape()[3], 1, bias=False, activation=None, name='Conv2d_1x1')))
net += scale * tower_out
if activation:
if isinstance(activation, str):
net = activations.get(activation)(net)
elif hasattr(activation, '__call__'):
net = activation(net)
else:
raise ValueError("Invalid Activation.")
return net
if __name__ == '__main__':
generate_dataset_path('dataset.txt', True)
X, Y = image_preloader(os.path.join(USER_ROOT, 'dataset.txt'), image_shape=(150, 150),
mode='file', categorical_labels=True, normalize=False)
X, Y = shuffle(X, Y)
X = 2 * (X / 255) - 1
# X_train, y_train, X_test, y_test = split_training_testing(X, Y)
# del X, Y
num_classes = 3
dropout_keep_prob = 0.8
network = input_data(shape=[None, 150, 150, 3])
conv1a_3_3 = relu(batch_normalization(conv_2d(network, 32, 3, strides=2, bias=False, padding='VALID', activation=None, name='Conv2d_1a_3x3')))
del network
conv2a_3_3 = relu(batch_normalization(conv_2d(conv1a_3_3, 32, 3, bias=False, padding='VALID', activation=None, name='Conv2d_2a_3x3')))
del conv1a_3_3
conv2b_3_3 = relu(batch_normalization(conv_2d(conv2a_3_3, 64, 3, bias=False, activation=None, name='Conv2d_2b_3x3')))
videCapture.release()
cv.destroyAllWindows()
def ResizeImg(arr):
arr = np.reshape(arr, (-1, 128, 128, 3))
return arr
dataset = "rgb_faces.txt"
images, labels = image_preloader(dataset, image_shape=(128, 128, 3), mode='file', categorical_labels=True, normalize=True)
'''
test_img = np.reshape(test_img, (-1, 128, 128, 1))
test_img_2 = np.reshape(test_img, (-1, 128, 128, 1))
test_img_3 = np.reshape(test_img, (-1, 128, 128, 1))
'''
preProc = tflearn.DataPreprocessing()
preProc.add_custom_preprocessing(ResizeImg)
#images = np.reshape(images, (-1, 128, 128, 1))
#labels = np.reshape(labels, (-1, 2))
'''
img_prep = ImagePreprocessing()
img_prep.add_featurewise_zero_center()
from tflearn.layers.core import input_data, dropout, fully_connected
from tflearn.layers.conv import conv_2d, max_pool_2d
from tflearn.layers.normalization import local_response_normalization, batch_normalization
from tflearn.layers.estimator import regression
from tflearn.data_utils import image_preloader
train_file = '../../images/sampling/train.txt'
test_file = '../../images/sampling/test.txt'
channels = 1
width = 64
height = 50
X, Y = image_preloader(train_file,
image_shape=(height, width),
mode='file',
categorical_labels=True,
normalize=True)
testX, testY = image_preloader(test_file,
image_shape=(height, width),
mode='file',
categorical_labels=True,
normalize=True)
network = input_data(shape=[None, width, height], name='input')
network = tflearn.layers.core.reshape(network, [-1, width, height, 1],
name='Reshape')
network = conv_2d(network, 64, 1, activation='relu', regularizer="L2")
network = batch_normalization(network)
network = conv_2d(network, 64, 1, activation='relu', regularizer="L2")
import deepneuralnet as net
import numpy as np
from tflearn.data_utils import image_preloader
model = net.model
path_to_model = './ZtrainedNet/final-model.tfl'
model.load(path_to_model)
X, Y = image_preloader(target_path='./validate', image_shape=(100,100), mode='folder',
grayscale=False, categorical_labels=True, normalize=True)
X = np.reshape(X, (-1, 100, 100, 3))
for i in range(0, len(X)):
iimage = X[i]
icateg = Y[i]
result = model.predict([iimage])[0]
prediction = result.tolist().index(max(result))
reality = icateg.tolist().index(max(icateg))
if prediction == reality:
print("image %d CORRECT " % i + "\n", end='')
else:
print("image %d WRONG " % i + "\n", end='')
print(result)
# Data loading
if(os.path.exists('mean.pkl')):
#load mean from pickle file
pkl_file = open('Inceptionmean.pkl', 'rb')
mean = pickle.load(pkl_file)
pkl_file.close()
print('mean pickle is here!')
else:
# Load mean from original image files:
dataset_file = 'trainfilelist.txt'
# Build the preloader array, resize images to sample size
from tflearn.data_utils import image_preloader
X, Y = image_preloader(dataset_file, image_shape=(FLAGS.sample_size, FLAGS.sample_size),
mode='file', categorical_labels=True,
normalize=True)
#Reshape X
X = np.array(X)
X = X.reshape([-1, FLAGS.sample_size, FLAGS.sample_size, 1])
X, mean = du.featurewise_zero_center(X)
#write to pickle file
pkl_file = open('Inceptionmean.pkl', 'wb')
pickle.dump(mean, pkl_file)
pkl_file.close()
#load resnet model
network = create_Inception(3)
model = tflearn.DNN(network)
from tflearn.layers.core import input_data, dropout, fully_connected
from tflearn.layers.conv import conv_2d, max_pool_2d
from tflearn.layers.normalization import local_response_normalization
from tflearn.layers.estimator import regression
from tflearn.data_utils import image_preloader
# import tflearn.datasets.oxflower17 as oxflower17
# X, Y = oxflower17.load_data(one_hot=True, resize_pics=(227, 227)
import win_unicode_console
win_unicode_console.enable()
X, Y = image_preloader(
target_path=r'C:/Users/Administrator/Desktop/all_test/lungall',
image_shape=(227, 227),
mode='folder',
normalize=True,
grayscale=False,
categorical_labels=True)
def my_func(x):
x_list_to_array = np.array(x)
x_s = x_list_to_array.reshape((-1, 227, 227, 1))
#one channel to 3 channel
a = x_s[:, :, :, 0]
a = a.reshape((-1, 227, 227, 1))
x = np.concatenate((x_s, a), axis=3)
x = np.concatenate((x, a), axis=3)
return x
'''
Coding Just for Fun
Created by burness on 16/9/10.
'''
from __future__ import division, print_function, absolute_import
import tflearn
from tflearn.data_utils import image_preloader
# Residual blocks
# 32 layers: n=5, 56 layers: n=9, 110 layers: n=18
n = 5
# Data loading
X,Y = image_preloader('files_list', image_shape = (224,224),mode='file',categorical_labels=True,normalize=True,files_extension=['.jpg', '.png'])
# Building Residual Network
net = tflearn.input_data(shape=[None, 224, 224, 3], name='input',)
net = tflearn.conv_2d(net, 64, 7,strides=2, regularizer='L2', weight_decay=0.0001)
net = tflearn.residual_block(net, n, 16)
net = tflearn.residual_block(net, 1, 32, downsample=True)
net = tflearn.residual_block(net, n-1, 32)
net = tflearn.residual_block(net, 1, 64, downsample=True)
net = tflearn.residual_block(net, n-1, 64)
net = tflearn.batch_normalization(net)
net = tflearn.activation(net, 'relu')
net = tflearn.global_avg_pool(net)
# Regression
net = tflearn.fully_connected(net, 10, activation='softmax')
