def test_load_definition(self):
K.set_image_dim_ordering("th")
kmodel, input_data, output_data = TestModels.kmodel_seq_lenet_mnist()
keras_model_json_path, keras_model_hdf5_path = dump_keras(kmodel, dump_weights=True)
bmodel = DefinitionLoader.from_json_path(keras_model_json_path)
WeightLoader.load_weights_from_kmodel(bmodel, kmodel)
self.assert_allclose(bmodel.forward(input_data), kmodel.predict(input_data))
def test_load_api_with_hdf5(self):
K.set_image_dim_ordering("th")
kmodel, input_data, output_data = TestModels.kmodel_graph_1_layer()
keras_model_json_path, keras_model_hdf5_path = dump_keras(kmodel, dump_weights=True)
bmodel = BLayer.Model.load_keras(json_path=keras_model_json_path,
hdf5_path=keras_model_hdf5_path)
self.assert_allclose(kmodel.predict(input_data),
bmodel.forward(input_data))
def test_load_weights(self):
K.set_image_dim_ordering("th")
kmodel, input_data, output_data = TestModels.kmodel_graph_1_layer()
keras_model_json_path, keras_model_hdf5_path = dump_keras(kmodel, dump_weights=True)
bmodel = DefinitionLoader.from_json_path(keras_model_json_path)
kmodel.set_weights([kmodel.get_weights()[0] + 100, kmodel.get_weights()[1]])
WeightLoader.load_weights_from_hdf5(bmodel, kmodel, filepath=keras_model_hdf5_path)
self.assert_allclose(bmodel.forward(input_data), kmodel.predict(input_data))
def set_img_format():
try:
if K.backend() == 'theano':
K.set_image_data_format('channels_first')
else:
K.set_image_data_format('channels_last')
except AttributeError:
if K._BACKEND == 'theano':
K.set_image_dim_ordering('th')
else:
K.set_image_dim_ordering('tf')
def setup_method(self, method):
"""
Setup any state tied to the execution of the given method in a class.
It is invoked for every test method of a class.
"""
K.set_image_dim_ordering("th")
sparkConf = create_spark_conf().setMaster("local[4]").setAppName("zoo test case")
self.sc = get_spark_context(sparkConf)
self.sc.setLogLevel("ERROR")
self.sqlContext = SQLContext(self.sc)
init_engine()
def cifar(): #maybe change border mode, idk; also maybe add BatchNormalization(axis=1)
# Determine proper input shape
K.set_image_dim_ordering('th')
input_shape = (1, 256, 192)
img_input = Input(shape=input_shape)
x = Convolution2D(64, 3, 3, activation='relu', border_mode='same', name='conv1_1')(img_input)
x = Convolution2D(64, 3, 3, activation='relu', border_mode='same', name='conv1_2')(x)
x = Convolution2D(64, 3, 3, activation='relu', border_mode='same', name='conv1_3')(x)
x = Convolution2D(64, 3, 3, activation='relu', border_mode='same', name='conv1_4')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(x)
x = Dropout(0.25)(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_1')(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_2')(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_3')(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_4')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(x)
x = Dropout(0.25)(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_1')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_2')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_3')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_4')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_5')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool3')(x)
x = Dropout(0.25)(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_1')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_2')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_3')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_4')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_5')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_6')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool4')(x)
x = Dropout(0.25)(x)
x = Flatten(name='flatten')(x)
x = Dense(1000, activation='relu', name='fc1')(x)
x = Dropout(0.5)(x)
x = Dense(1000, activation='relu', name='fc2')(x)
x = Dropout(0.5)(x)
x = Dense(2, activation='softmax', name='pred')(x)
# Create model.
model = Model(img_input, x)
#weights=''
#model.load_weights(weights)
return model
def __init__(self, *args, **kwargs):
from keras.layers.core import Dense, Flatten
from keras.layers.convolutional import Convolution2D
from keras import backend as K
if K.backend() == 'theano':
K.set_image_dim_ordering('tf')
self.Dense = Dense
self.Flatten = Flatten
self.Convolution2D = Convolution2D
self.kernel = 4
self.stride = (2, 2)
super(ConvDQN, self).__init__(*args, **kwargs)
def test_batchnormalization(self):
K.set_image_dim_ordering("th")
input_data = np.random.random_sample([2, 5, 32, 32])
blayer = BLayer.BatchNormalization(axis=1, input_shape=(5, 32, 32))
klayer = KLayer.BatchNormalization(axis=1, input_shape=(5, 32, 32))
self.compare_newapi(klayer, blayer, input_data,
WeightsConverter.convert_batchnormalization)
K.set_image_dim_ordering("tf")
input_data2 = np.random.random_sample([2, 32, 32, 4])
blayer = BLayer.BatchNormalization(axis=-1, dim_ordering="tf", input_shape=(32, 32, 4))
klayer = KLayer.BatchNormalization(axis=-1, input_shape=(32, 32, 4))
self.compare_newapi(klayer, blayer, input_data2,
WeightsConverter.convert_batchnormalization)
def foo():
# Determine proper input shape
if keras.__version__ > '1.0.3':
K.set_image_dim_ordering('th')
input_shape = (1, 224, 224)
#img_input = Input(shape=input_shape)
model = Sequential()
model.add(Convolution2D(32, 8, 8,
input_shape=input_shape,init=weight_init, name='conv1_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(32, 6, 6,init=weight_init, name='conv1_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(32, 4, 4,init=weight_init, name='conv1_3'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(32, 2, 2,init=weight_init, name='conv1_4'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2))) # in 208, out 104
model.add(Dropout(dropout))
model.add(Convolution2D(64, 8, 8,init=weight_init, name='conv2_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 6, 6,init=weight_init, name='conv2_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 4, 4,init=weight_init, name='conv2_3'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 2, 2,init=weight_init, name='conv2_4'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2))) # in is 88, out is 44
model.add(Dropout(dropout))
model.add(Flatten())
model.add(Dense(220, init=weight_init))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dense(2))
model.add(Activation('sigmoid'))
return model
def EVALUATE_IMAGE_seg_and_classify(h, w, file_i=1):
#load test data
read_path = '../Test_Images/testpkg3_unet/'
ImageType = '.jpg'
files = [s for s in os.listdir(read_path) if ImageType in s]
# load seg model
set_image_dim_ordering(dim_ordering='th') # if not configured in
model = load_model("../testbench/bg/" + bg_model)
print 'loaded model', bg_model
# debug
# model.summary()
for im_ori,im_i in zip(files,xrange(len(files))):
im_ori = cv2.imread(read_path + im_ori)
im_crop = im_ori
image_crop_roi, screen_out = do_segment(model,im_ori,im_crop,im_i,h,w)
cv2.imshow('seg_img_res',image_crop_roi)
cv2.waitKey()
def cifar():
# Determine proper input shape
K.set_image_dim_ordering('th')
input_shape = (1, 256, 192)
img_input = Input(shape=input_shape)
x = Convolution2D(64, 3, 3, activation='relu', border_mode='same', name='conv1_1')(img_input)
x = Convolution2D(64, 3, 3, activation='relu', border_mode='same', name='conv1_2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool1')(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_1')(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_2')(x)
x = Convolution2D(128, 3, 3, activation='relu', border_mode='same', name='conv2_3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool2')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_1')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_2')(x)
x = Convolution2D(256, 3, 3, activation='relu', border_mode='same', name='conv3_3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool3')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_1')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_2')(x)
x = Convolution2D(512, 3, 3, activation='relu', border_mode='same', name='conv4_3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='pool4')(x)
x = Flatten(name='flatten')(x)
x = Dense(1000, activation='relu', name='fc1')(x)
x = Dense(1000, activation='relu', name='fc2')(x)
x = Dense(2, activation='softmax', name='pred')(x)
# Create model.
model = Model(img_input, x)
#weights='MODS_keras_weights_3_he_normal_0.5_rmsprop_24.h5'
#model.load_weights(weights)
return model
import cPickle
from keras import backend as K
from keras.utils.np_utils import to_categorical
from keras.models import Sequential
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Dropout, Dense, Flatten
from keras.wrappers.scikit_learn import KerasClassifier
from sklearn.model_selection import GridSearchCV
import numpy as np
K.set_image_dim_ordering('th') #input shape: (channels, height, width)
with open('cifar-10-batches-py/data_batch_1', 'r') as file:
batch1 = cPickle.load(file)
with open('cifar-10-batches-py/data_batch_2', 'r') as file:
batch2 = cPickle.load(file)
with open('cifar-10-batches-py/data_batch_3', 'r') as file:
batch3 = cPickle.load(file)
with open('cifar-10-batches-py/data_batch_4', 'r') as file:
batch4 = cPickle.load(file)
with open('cifar-10-batches-py/data_batch_5', 'r') as file:
batch5 = cPickle.load(file)
def eva_image_6c(h, w):
print 'start evaluation'
images, mask = tools.import_data_unet_6c("../Test_Images/testpkg3_unet/", "cadbg_%03d.jpg", "fgbg_%03d.jpg", h, w, 3,
do_Flipping=False)
# params: loadData(data_path, file_img, file_mask, h, w, maxNum, do_Flipping=False)
test_num = (images.shape)[0]
print 'number of test images', test_num, ', shape', images.shape # (3, 1, 320, 320)
set_image_dim_ordering(dim_ordering='th') # if not configured in
try:
model = load_model("../testbench/bg/" + bg_model)
print 'loaded model', bg_model
except Exception as e:
print '[Hint-e]', e
# debug
# model.summary()
######################
mean = np.mean(images)
print 'mean', mean
stdev = np.std(images)
print 'stdev', stdev
######################
images_original = images.copy()
# print '3-number of test images', images_original.shape
images = (images - mean) / stdev
for i in range(0, images.shape[0]):
start = time.time()
ch = 3
result = model.predict(images[i, :, :, :].reshape(1, ch, h, w), batch_size=1) #
end = time.time()
print(end - start)
print 'Test image', i + 1, ", Min/Max: %f %f" % (np.min(result), np.max(result))
print 'result shape', (result.shape)
res = result[0, 0, :, :].reshape((h, w)) * 255 # old
print 'images_original shape', images_original.shape
input_resized = cv2.resize(np.uint8(images_original[i, :, :, :].reshape(h, w, 3) * 255), (480, 360))
# input_resized = cv2.resize(np.uint8(images_original[i, :, :, :].reshape(h, w) * 255), (480, 360)) #old
# print 'min/max:%f %f' % (np.min(images_original[i, :, :, :]), np.max(images_original[i, :, :, :]))
output_resized = cv2.resize(np.uint8(res), (480, 360))
# input_rgb = cv2.cvtColor(input_resized, cv2.COLOR_GRAY2RGB)
# cv2.imshow("input_rgb_window2", input_rgb)
# cv2.waitKey(10000)
# color = tools.add_colorOverlay(input_resized, output_resized)
# combined = np.hstack((input_rgb, color))
# cv2.imwrite('../testbench/res_' + bg_model[:-5] + '%03d.jpg' % i, np.uint8(res))
# cv2.imwrite("../testbench/combined_%03d.jpg" % i, input_resized)
# cv2.imwrite("../testbench/combined_%03d.jpg" % i, combined)
# cv2.imwrite("../testbench/color_%03d.jpg" % i, color)
# debug
cv2.imshow("input_resized_window1", input_resized)
cv2.imshow("out_window1", output_resized)
cv2.imshow("res_window1", np.uint8(res))
cv2.waitKey(500)
##########################################################
# res2 = result[0,0, :, 1].reshape((320,320))*255
# back = result[0,0, :, 2].reshape((320, 320)) * 255
# cv2.imshow("Standing", np.uint8(res))
# cv2.imshow("Sitting", np.uint8(res2))
# cv2.imshow("Background", np.uint8(back))
# cv2.imshow("input", np.uint8(((images[i, :, :, :] * stdev + mean) * 255).reshape(320, 320)))
cv2.waitKey(30)
def EVALUATE_WEBCAM_seg_and_classify(camera_port, stop,num_class): #(cam)
# load seg model
set_image_dim_ordering(dim_ordering='th') # if not configured in
model = load_model("../testbench/bg/" + bg_model)
print 'loaded model', bg_model
n_classes = num_class
#hy: check camera availability
camera = cv2.VideoCapture(camera_port)
frame_i = 0
# hy: initialize confmatrix
confMat2_TEST_Video = np.zeros((2, 2), dtype=np.float)
#if stop == False:
#if ckpt and ckpt.model_checkpoint_path:
# Camera 0 is the integrated web cam
# Number of frames to throw away while the camera adjusts to light levels
# ramp_frames = 1
while True and not stop: #hy: confirm camera is available
# Now we can initialize the camera capture object with the cv2.VideoCapture class.
# All it needs is the index to a camera port.
print 'Getting image...'
ret, frame = camera.read()
# Captures a single image from the camera and returns it in PIL format
#ret = camera.set(3, 320) #hy use properties 3 and 4 to set frame resolution. 3- w, 4- h
#ret = camera.set(4, 240)
cv2.waitKey(1)
# A nice feature of the imwrite method is that it will automatically choose the
# correct format based on the file extension you provide.
# cv2.imwrite(file, camera_capture)
#################################### /////////////////////////////
if frame is not None:
# print 'frame from webcam obtained'
# hy: before continue check if image is read correctly
# while frame is not None:
frame_i += 1
# hy:
h_frame = frame.shape[0]
w_frame = frame.shape[1] # hy: h 1536 x w 2304
print 'webcam frame shape h,w', h_frame,w_frame
else:
break
# cv2.imshow("ori", frame)
if frame_i % 50 == 0:
use_focus_window = 0
if use_focus_window:
crop_x1 = 550 # 550
crop_y1 = 700 # 700# 300
area_step_size = 740 # 740# 640
crop_x2 = crop_x1 + area_step_size * 1
crop_y2 = crop_y1 + area_step_size * 1 * settings.h_resize / settings.w_resize
frame_crop = frame[crop_y1:crop_y2, crop_x1:crop_x2]
frame_crop_color = frame_crop.copy()
# cv2.imwrite('../testbench/frame_color_tmp.jpg', np.uint8(frame_crop_color))
else:
crop_x1 = 0
crop_y1 = 0
crop_x2 = 0 + w_frame # 2300 #1920
crop_y2 = 0 + h_frame # 1536 #1080
frame_crop = frame[crop_y1:crop_y2, crop_x1:crop_x2]
frame_crop_color = frame_crop.copy()
frame_crop_roi, screen_out = do_segment(model, frame_crop_color, frame_i, 320, 320)
do_classification(frame, frame_i, frame_crop_roi, confMat2_TEST_Video, crop_y1, crop_y2,
crop_x1, crop_x2, n_classes, screen_out)
#TODO add termination condition
print 'no frame retrieved'
del(camera)
return stop
from keras.callbacks import ModelCheckpoint, EarlyStopping
from keras import backend as K
from keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
import pickle as pkl
import ISIC_dataset as ISIC
from metrics import dice_loss, jacc_loss, jacc_coef, dice_jacc_mean, jacc_coef_th, jacc_loss_th
import models
from sklearn.model_selection import train_test_split
from tqdm import tqdm, trange
from pre_processing import my_PreProc
from imgaug_test_cc import transform_img, reverse_gt
import argparse
np.random.seed(4)
K.set_image_dim_ordering('th') # Theano dimension ordering: (channels, width, height)
# some changes will be necessary to run with tensorflow
# Folder of training images and masks
training_folder = "./datasets/ISIC2018_Task1-2_Training_Input"
training_mask_folder = "./datasets/ISIC2018_Task1_Training_GroundTruth"
# Folder of validation and test images
val_folder = "./datasets/ISIC2018_Task1-2_Validation_Input"
test_folder = "./datasets/ISIC2018_Task1-2_Test_Input"
# Folder to store predicted masks
val_predicted_folder = "./results/ISIC2018_Validation_Predicted"
test_predicted_folder = "./results/ISIC2018_Test_Predicted"
# Folder of external data
def foo():
# Determine proper input shape
if keras.__version__ > '1.0.3':
K.set_image_dim_ordering('th')
input_shape = (1, 224, 224)
#img_input = Input(shape=input_shape)
model = Sequential()
model.add(Convolution2D(16, 3, 3,
input_shape=input_shape,init=weight_init, name='conv1_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(16, 3, 3,init=weight_init, name='conv1_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Convolution2D(32, 3, 3,init=weight_init, name='conv2_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(32, 3, 3,init=weight_init, name='conv2_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(32, 3, 3,init=weight_init, name='conv2_3'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Convolution2D(64, 3, 3,init=weight_init, name='conv3_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3,init=weight_init, name='conv3_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Convolution2D(128, 3,3,init=weight_init, border_mode='same', name='conv4_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(128, 3,3,init=weight_init, border_mode='same', name='conv4_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Flatten())
model.add(Dense(120, init=weight_init))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dropout(dropout))
model.add(Dense(2))
model.add(Activation('sigmoid'))
return model
import numpy as np
import time
import os
import argparse
import h5py
from scipy.misc import imread, imresize, imsave
from scipy.optimize import fmin_l_bfgs_b
from sklearn.preprocessing import normalize
from keras.models import Sequential
from keras.layers.convolutional import Convolution2D, ZeroPadding2D, AveragePooling2D
from keras import backend as Kr
Kr.set_image_dim_ordering('th')
# Command line arguments
parser = argparse.ArgumentParser(description='AI Artist')
parser.add_argument('--base_img_path', metavar='base', type=str, help='Path to base image')
parser.add_argument('--style_img_path', metavar='ref', type=str, help='Path to artistic style reference image')
parser.add_argument('--result_prefix', metavar='res', type=str, help='Prefix for saved results')
parser.add_argument('--rescale', dest='rescale', default='True', type=str, help='Rescale image after execution')
parser.add_argument('--keep_aspect', dest='keep_aspect', default='True', type=str, help='Maintain aspect ratio of image')
parser.add_argument('--tot_var_weight', dest='tv_weight', default=1e-3, type=float, help='Total variation in weights')
parser.add_argument('--content_weight', dest='content_weight', default=0.025, type=float, help='Weight of content')
parser.add_argument('--style_weight', dest='style_weight', default=1, type=float, help='Weight of style')
parser.add_argument('--img_size', dest='img_size', default=512, type=int, help='Output image size')
parser.add_argument('--content_layer', dest='content_layer', default='conv5_2', type=str, help="Optional: 'conv4_2'")
def VGG_16(classes_number):
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Flatten
from keras.layers.convolutional import Conv2D, MaxPooling2D, ZeroPadding2D
from keras import backend as K
K.set_image_dim_ordering('th')
# VGG16: https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3
model = Sequential()
model.add(ZeroPadding2D((1, 1), input_shape=(224, 224, 3)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
f = h5py.File(WEIGHTS_PATH + 'vgg16_weights.h5')
for k in range(f.attrs['nb_layers']):
if k >= len(model.layers):
# we don't look at the last (fully-connected) layers in the savefile
break
g = f['layer_{}'.format(k)]
weights = [
g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])
]
model.layers[k].set_weights(weights)
f.close()
print('Model loaded.')
model.add(Dense(classes_number, activation='sigmoid'))
return model
def get_model2(input_shape=input_shape_resnet, num_classes=1):
K.set_image_data_format('channels_last')
linknet = LinkNet2(input_shape=input_shape_resnet)
K.set_image_dim_ordering('tf')
#inputs = linknet.get_input().output
#inputs.set_shape( ( None ,224,224 , 3 ))
inputs = linknet.get_input()
print(inputs.shape)
#inputs = Input(shape = input_shape_resnet )
# lines to work with de padding layer
x = linknet.firstpad(inputs)
x = linknet.firstconv(x)
#x = linknet.firstconv( inputs )
print("xxxxx shape")
print(x.shape)
x = linknet.firstbn(x)
x = linknet.firstrelu(x)
x = linknet.firstmaxpool(x)
print("input shape encoders")
print(x.shape)
e1 = linknet.encoder1.call2(x)
e2 = linknet.encoder2.call2(e1)
e3 = linknet.encoder3.call2(e2)
e4 = linknet.encoder4.call2(e3)
print("encoders shapes ")
print(e1.shape)
print(e2.shape)
print(e3.shape)
print(e4.shape)
#d4 = linknet.decoder4( e4 )
#d4 = linknet.decoder4.call2( e4 ) + e3
#print( "e2 upsampled ")
#print(e2.shape)
d4 = linknet.decoder4.call2(e4)
e3 = UpSampling2D((2, 2))(e3)
d4 = keras.layers.Add()([e3, d4])
#d3 = linknet.decoder3.call2( d4 ) + e2
d3 = linknet.decoder3.call2(d4)
#y = UpSampling2D((2,2) )( e2 )
x = UpSampling2D((2, 2))(e2)
x = UpSampling2D((2, 2))(x)
d3 = keras.layers.Add()([x, d3])
#d2 = linknet.decoder2.call2( d3 ) + e1
d2 = linknet.decoder2.call2(d3)
y = UpSampling2D((8, 8))(e1)
d2 = keras.layers.Add()([y, d2]) # 440 , 440 , 64
print("dedede")
print(d2.shape)
d1 = linknet.decoder1.call2(d2)
print("decoders shape")
print(d4.shape)
print(d3.shape)
print(d2.shape)
print(d1.shape)
y = Conv2D(32, kernel_size=(3, 3), strides=2, padding="same")(d1)
y = BatchNormalization()(y)
y = Activation("relu")(y)
# [ None , 440 , 440 , 32]
y = Conv2D(16, kernel_size=(2, 2), strides=2, padding="same")(y)
y = BatchNormalization()(y)
y = Activation("relu")(y)
# Output [ 220 , 220 , 16]
output_final = Conv2D(1, kernel_size=(1, 1), activation="sigmoid")(y)
"""
#y = Conv2D( 8 , kernel_size=(2,2) , strides = 2 , padding= "same")(y)
#y = BatchNormalization( )(y)
#y = Activation("relu")(y)
# [110 , 110 , 8]
y = Conv2D( 4 , kernel_size=(2,2) , strides = 2 , padding="same")(y)
y = BatchNormalization( )(y)
y = Activation("relu")(y)
# {55 , 55 , 4}
#y.set_shape( (2,55,55,4 ) )
y = Conv2D( 4 , kernel_size=(5,5) , strides = 2 )(y)
y = BatchNormalization( )(y)
y = Activation("relu")(y)
#y = Conv2D( 2 , kernel_size=(5,5) , strides = 2 )(y)
#y = BatchNormalization( )(y)
#y = Activation("relu")(y)
# ( 13 , 13 , 2 )
rs = Lambda( lambda x : x , output_shape = (2,26,26,4) )(y)
#rs = Reshape( [55*55*4] )( y )
rs = Flatten( ) (y )
size = 224*224
#flat = Flatten( )( y )
fc = Dense( size )( rs )
fc = Activation("relu")(fc)
print("asdadasda")
print( fc.shape )
#utput = Reshape( ( -1 , ) )(fc)
#fc.set_shape( ( None , 224 ,224 , 1 ) )
print("output")
#print(output)
# [None , 220 , 220 , 32]
#f1 = linknet.finaldeconv1( d1 )
#f2 = Activation("relu")( f1 )
#f3 = linknet.finalconv2( f2 )
#f4 = linknet.finalrelu2( f3)
#f5 = linknet.finalconv3( f4 )
#print( f1.shape )
#f5.set_shape( (None , 224 , 224 , 1 ))
"""
model = Model(inputs=inputs, outputs=output_final)
print(model.summary())
return model
import sys
sys.path.append('..') # this allows it to find data_loader
sys.setrecursionlimit(90000)
from keras.models import Sequential,Model
from keras.layers import Activation,Convolution2D,LocallyConnected2D,Flatten,Dense,Input,Reshape,Embedding,Merge,merge
from keras.layers.convolutional import UpSampling2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.layers.pooling import AveragePooling2D
from keras.callbacks import CSVLogger,EarlyStopping,ModelCheckpoint
import keras.backend as K
K.set_image_dim_ordering('th') # NOTE: channel is first dim after batch.
import data_loader
import train
def small_discriminator(args):
DIMS = (args['cropped_width']*args['cropped_width'], data_loader.DATA_DIM[2])
d_input = Input(shape=(1, DIMS[0], DIMS[1]), name='d_input')
d_input_particle = Input(shape=(1,), name='d_input_particle')
d_input_energy = Input(shape=(1,), name='d_input_energy')
hid = Convolution2D(32, 5, 5, border_mode='same')(d_input)
hid = Flatten()(hid)
hid = merge([hid, d_input_particle, d_input_energy], mode='concat')
# hid = merge([hid, d_input_energy], mode='concat')
hid = Dense(8, activation='relu')(hid)
d_proba = Dense(1, activation='linear', name='d_proba')(hid)
def YOLO(input_shape=(3, 416, 416), num_classes=80, num_priors=5):
"""YOLO (v2) architecture
# Arguments
input_shape: Shape of the input image
num_classes: Number of classes (excluding background)
# References
https://arxiv.org/abs/1612.08242
https://arxiv.org/abs/1506.02640
"""
K.set_image_dim_ordering('th')
net = {}
input_tensor = Input(shape=input_shape)
net['input'] = input_tensor
net['conv1'] = (YOLOConvolution2D(32,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['input'])
net['relu1'] = (LeakyReLU(alpha=0.1))(net['conv1'])
net['pool1'] = (MaxPooling2D(pool_size=(2, 2),
border_mode='valid'))(net['relu1'])
net['conv2'] = (YOLOConvolution2D(64,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['pool1'])
net['relu2'] = (LeakyReLU(alpha=0.1))(net['conv2'])
net['pool2'] = (MaxPooling2D(pool_size=(2, 2),
border_mode='valid'))(net['relu2'])
net['conv3_1'] = (YOLOConvolution2D(128,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['pool2'])
net['relu3_1'] = (LeakyReLU(alpha=0.1))(net['conv3_1'])
net['conv3_2'] = (YOLOConvolution2D(64,
1,
1,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu3_1'])
net['relu3_2'] = (LeakyReLU(alpha=0.1))(net['conv3_2'])
net['conv3_3'] = (YOLOConvolution2D(128,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu3_2'])
net['relu3_3'] = (LeakyReLU(alpha=0.1))(net['conv3_3'])
net['pool3'] = (MaxPooling2D(pool_size=(2, 2),
border_mode='valid'))(net['relu3_3'])
net['conv4_1'] = (YOLOConvolution2D(256,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['pool3'])
net['relu4_1'] = (LeakyReLU(alpha=0.1))(net['conv4_1'])
net['conv4_2'] = (YOLOConvolution2D(128,
1,
1,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu4_1'])
net['relu4_2'] = (LeakyReLU(alpha=0.1))(net['conv4_2'])
net['conv4_3'] = (YOLOConvolution2D(256,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu4_2'])
net['relu4_3'] = (LeakyReLU(alpha=0.1))(net['conv4_3'])
net['pool4'] = (MaxPooling2D(pool_size=(2, 2),
border_mode='valid'))(net['relu4_3'])
net['conv5_1'] = (YOLOConvolution2D(512,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['pool4'])
net['relu5_1'] = (LeakyReLU(alpha=0.1))(net['conv5_1'])
net['conv5_2'] = (YOLOConvolution2D(256,
1,
1,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu5_1'])
net['relu5_2'] = (LeakyReLU(alpha=0.1))(net['conv5_2'])
net['conv5_3'] = (YOLOConvolution2D(512,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu5_2'])
net['relu5_3'] = (LeakyReLU(alpha=0.1))(net['conv5_3'])
net['conv5_4'] = (YOLOConvolution2D(256,
1,
1,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu5_3'])
net['relu5_4'] = (LeakyReLU(alpha=0.1))(net['conv5_4'])
net['conv5_5'] = (YOLOConvolution2D(512,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu5_4'])
net['relu5_5'] = (LeakyReLU(alpha=0.1))(net['conv5_5'])
net['pool5'] = (MaxPooling2D(pool_size=(2, 2),
border_mode='valid'))(net['relu5_5'])
net['conv6_1'] = (YOLOConvolution2D(1024,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['pool5'])
net['relu6_1'] = (LeakyReLU(alpha=0.1))(net['conv6_1'])
net['conv6_2'] = (YOLOConvolution2D(512,
1,
1,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu6_1'])
net['relu6_2'] = (LeakyReLU(alpha=0.1))(net['conv6_2'])
net['conv6_3'] = (YOLOConvolution2D(1024,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu6_2'])
net['relu6_3'] = (LeakyReLU(alpha=0.1))(net['conv6_3'])
net['conv6_4'] = (YOLOConvolution2D(512,
1,
1,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu6_3'])
net['relu6_4'] = (LeakyReLU(alpha=0.1))(net['conv6_4'])
net['conv6_5'] = (YOLOConvolution2D(1024,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu6_4'])
net['relu6_5'] = (LeakyReLU(alpha=0.1))(net['conv6_5'])
net['conv6_6'] = (YOLOConvolution2D(1024,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu6_5'])
net['relu6_6'] = (LeakyReLU(alpha=0.1))(net['conv6_6'])
net['conv6_7'] = (YOLOConvolution2D(1024,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['relu6_6'])
net['relu6_7'] = (LeakyReLU(alpha=0.1))(net['conv6_7'])
net['reorg7'] = (Reorg())(net['relu5_5'])
net['merge7'] = (merge([net['reorg7'], net['relu6_7']],
mode='concat',
concat_axis=1))
net['conv8'] = (YOLOConvolution2D(1024,
3,
3,
border_mode='same',
subsample=(1, 1),
epsilon=0.000001))(net['merge7'])
net['relu8'] = (LeakyReLU(alpha=0.1))(net['conv8'])
net['conv9'] = (Convolution2D(num_priors * (4 + num_classes + 1),
1,
1,
border_mode='same',
subsample=(1, 1)))(net['relu8'])
model = Model(net['input'], net['conv9'])
return model
Refernce:
https://machinelearningmastery.com/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras/
@author: jkuo
"""
import numpy as np
np.random.seed(123) # for reproducibility
from keras.models import Sequential # linear stack of NN layers
from keras.layers import Dense, Dropout, Activation, Flatten # core layers from Keras
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils #utils used to transform data
from keras import backend as K
K.set_image_dim_ordering(
'th') #using the theano ordering where the color channel comes first
#keras.backend.backed()# to check backend: tensorflow
from keras.datasets import mnist #mnist dataset
from matplotlib import pyplot as plt
# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
#print(X_train.shape) #(60000, 28, 28) 28x28 pixel images
# plot 4 images as gray scale
plt.subplot(221)
plt.imshow(X_train[0], cmap=plt.get_cmap('gray'))
plt.subplot(222)
plt.imshow(X_train[1], cmap=plt.get_cmap('gray'))
mpl.use('Agg') # no display mode
import matplotlib.pyplot as plt
import tensorflow as tf
import pandas as pd
from argparse import ArgumentParser
from datetime import datetime
from keras.applications.mobilenet import MobileNet
from keras.optimizers import TFOptimizer
from keras import backend as K # backend of Keras
from keras.utils import multi_gpu_model, to_categorical
from keras.callbacks import ModelCheckpoint
from multiprocessing import cpu_count
import scipy.misc
np.random.seed(1)
K.set_image_dim_ordering('tf') # use Tensorflow backend
# parameters of learning for the network
EPOCHES = 10 # how many times the whole train set will be shown for model
BATCH_SIZE = 128 # count of train samples, which are shown to optimizer before updating weights of network
IMG_ROWS, IMG_COLS = 224, 224 # size of images (at least 32x32)
IMG_CHANNELS = 1 # colour channels of images
CLASSES = 1000 # count of classes
# folders for savings
RESULTS_DIR = '../results'
WEIGHTS_DIR = '../weights'
# parameters of optimizer
LEARNING_RATE = 0.01
DECAY = 0.9
@author: Supriya
"""
# Import all the things we need ---
# by setting env variables before Keras import you can set up which backend and which GPU it uses
%matplotlib inline
import os,random
os.environ["KERAS_BACKEND"] = "theano"
# os.environ["KERAS_BACKEND"] = "tensorflow"
os.environ["THEANO_FLAGS"] = "floatX=float32,device=cpu,nvcc.flags=-D_FORCE_INLINES"
import numpy as np
import theano as th
import theano.tensor as T
from keras import backend as kBack
kBack.set_image_dim_ordering('th')
from keras.utils import np_utils
import keras.models as models
from keras.layers.core import Reshape,Dense,Dropout,Activation,Flatten
from keras.layers.noise import GaussianNoise
from keras.layers.convolutional import Convolution2D, MaxPooling2D, ZeroPadding2D
from keras.regularizers import *
from keras.optimizers import adam
import matplotlib.pyplot as plt
import seaborn as sns
import pickle, random, sys, keras
from collections import defaultdict
def create_model():
dr = 0.5 # dropout rate (%)
model = models.Sequential()
model.add(Reshape([1]+in_shp, input_shape=in_shp))
def train_single_classification_model_full_frame(num_fold, train_files, valid_files, restore, optim_name='Adam'):
from keras.callbacks import EarlyStopping, ModelCheckpoint, CSVLogger
from keras.optimizers import Adam, SGD
import keras.backend as K
K.set_image_dim_ordering('th')
cnn_type = 'VGG_3D_24_56_56_v2'
print('Creating and compiling model [{}]...'.format(cnn_type))
model = VGG_3D_24_56_56(24)
final_model_path = MODELS_PATH + '{}_fold_{}.h5'.format(cnn_type, num_fold)
cache_model_path = MODELS_PATH + '{}_temp_fold_{}.h5'.format(cnn_type, num_fold)
cache_model_path_detailed = MODELS_PATH + '{}_temp_fold_{}_'.format(cnn_type, num_fold) + 'ep_{epoch:03d}_loss_{val_loss:.4f}.h5'
if os.path.isfile(cache_model_path) and restore:
print('Load model from last point: ', cache_model_path)
model.load_weights(cache_model_path)
else:
print('Start training from begining')
print('Fitting model...')
batch_size = 32
learning_rate = 0.0001
epochs = 2000
patience = 50
print('Batch size: {}'.format(batch_size))
print('Model memory usage: {} GB'.format(get_model_memory_usage(batch_size, model)))
print('Learning rate: {}'.format(learning_rate))
steps_per_epoch = 200
validation_steps = 200
print('Samples train: {}, Samples valid: {}'.format(steps_per_epoch, validation_steps))
if optim_name == 'SGD':
optim = SGD(lr=learning_rate, decay=1e-6, momentum=0.9, nesterov=True)
else:
optim = Adam(lr=learning_rate)
model.compile(optimizer=optim, loss='binary_crossentropy', metrics=['accuracy'])
callbacks = [
EarlyStopping(monitor='val_loss', patience=patience, verbose=0),
ModelCheckpoint(cache_model_path, monitor='val_loss', save_best_only=True, verbose=0),
ModelCheckpoint(cache_model_path_detailed, monitor='val_loss', save_best_only=False, save_weights_only=True, verbose=0),
CSVLogger(HISTORY_FOLDER_PATH + 'history_fold_{}_{}_lr_{}_optim_{}.csv'.format(num_fold, cnn_type, learning_rate, optim_name), append=True)
]
history = model.fit_generator(generator=batch_generator_train(train_files, batch_size),
epochs=epochs,
steps_per_epoch=steps_per_epoch,
validation_data=batch_generator_train(valid_files, batch_size),
validation_steps=validation_steps,
verbose=2,
max_queue_size=16,
callbacks=callbacks)
min_loss = min(history.history['val_loss'])
print('Minimum loss for given fold: ', min_loss)
model.load_weights(cache_model_path)
model.save(final_model_path)
now = datetime.datetime.now()
filename = HISTORY_FOLDER_PATH + 'history_{}_{}_{:.4f}_lr_{}_{}.csv'.format(cnn_type, num_fold, min_loss, learning_rate, now.strftime("%Y-%m-%d-%H-%M"))
pd.DataFrame(history.history).to_csv(filename, index=False)
return min_loss
import os
# Third Party
import numpy as np
from keras.callbacks import ModelCheckpoint, LearningRateScheduler
from keras import backend as K
from keras.optimizers import Adam
from keras.models import Model
from keras.layers import Input
import nibabel as nb
# Internal
import dvpy as dv
import dvpy.tf
K.set_image_dim_ordering('tf') # Tensorflow dimension ordering in this code
class config:
def __init__(self):
# Dimension of padded input, for training.
self.dim = (256, 256)
# Number of Classes (Including Background)
self.num_classes = 6
# How many images should be processed in each batch?
self.batch_size = 32
# UNet Depth
self.unet_depth = 5
def EVA_IMAGE_seg_and_classify(MODEL_ID, bg_model, h, w,
in_ch=1, best_avg=0, save_res_path='', save_imgs=False, file_i=1, with_gt=False,
step_show=False, stop=False):
print 'Model ID:', MODEL_ID
res_pass_list, res_fail_list, list_of_imgs_res = [], [], []
dices, dice_non_empty, dice_empty, dices_cad, count_test, n_classes = 0, 0, 0, 0, 0, 2
max_dice, min_dice, avg_dice_non_empty, avg_dice_empty, overall_acc = 0, 1, 0, 0, 0
confMat1_TEST = np.zeros((n_classes, n_classes), dtype=np.float) # hy collect detailed confusion matrix
confMat2_TEST = np.zeros((2, 2), dtype=np.float)
read_paths_im, read_paths_m, files_im, files_m = get_read_path_and_files_for_im_m_2cl(read_from_file=False)
# load seg model
set_image_dim_ordering(dim_ordering='th') #
model = load_model(bg_model)
if INFO_0:
print 'loading model', bg_model
# model.summary()
if result_for_table:
print 'True/False', 'No.', 'Name', 'TargetLabel', 'PredictLabel', 'Precision', \
\
'Top2', 'Top2_pres', 'Top3', 'Top3_pres', 'Top4', 'Top4_pres', 'Top5', 'Top5_pres', 'last', 'last_pres'
cust_list = [''] # can define any filename patterns
for im_ori, ref_mask, i, read_path_im, read_path_m in zip(files_im, files_m, xrange(len(files_im)), read_paths_im,
read_paths_m):
fn = os.path.basename(im_ori)[:-4]
if i > -1: # > 46 and i < 54:
# if fn in cust_list: # 0 and i < 4:#> 46 and i < 54:
if INFO_0:
print 'read path:', read_path_im
im_ori_view = cv2.imread(read_path_im + im_ori)
im_crop = im_ori_view.copy()
im_ori_view = cv2.resize(im_ori_view, (h, w))
# IMAGE
pred_int, pred_thresh,fr_add_cont, old_mask,old_roi_res, \
new_mask, image_crop_roi, r1, r2, c1, c2, screen_out, roi_whitebg \
= do_segment_im(model, im_ori_view, im_crop, i, h, w, in_ch, show=False, save=False)
pred_thresh = new_mask.copy() # use optimized mask for dice calc
if len(pred_thresh.shape) == 3:
pred_thresh = cv2.cvtColor(pred_thresh, cv2.COLOR_RGB2GRAY)
if with_gt:
ref_mask = cv2.resize(cv2.imread(read_path_m + ref_mask, 0), (h, w))
ref_mask_thresh = ref_mask # * 255.0
thresh_ref = 0
ref_key = 255
idx = ref_mask_thresh[:, :] > thresh_ref
ref_mask_thresh[idx] = ref_key
pred_key = 255
if search_str not in fn:
count_test += 1
dice = tools.calc_dice_simi(pred_thresh, ref_mask_thresh, fn, k=pred_key)
print '\nDice for:', fn, ':', dice
dices += dice
if dice < min_dice:
min_dice = dice
if dice > max_dice:
max_dice = dice
if do_classification:
target_label = tools.get_ground_truth_label_im(read_path_im)
total_imgs_of_class = len(os.listdir(read_path_im))
if target_label == 1:
dice_non_empty += dice
avg_dice_non_empty = dice_non_empty / total_imgs_of_class
if target_label == 0:
dice_empty += dice
avg_dice_empty = dice_empty / total_imgs_of_class
prefix = get_model_index(bg_model, '\d')
pre_tensor_view = np.zeros((h, w, 3), np.uint8)
if screen_out:
classified_as = 1
if DEBUG:
print 'prefix:', prefix
found_dig = re.search('\d', os.path.basename(bg_model))
if found_dig:
dig = found_dig.start()
prefix = save_res_path + os.path.basename(bg_model)[dig:-5]
else:
print 'no file found'
reduce_border = False
if reduce_border:
# image_crop_roi = cv2.resize(im_crop,(h,w))[r1+border:r2-border, c1-border:c2+border] #crop_y1:crop_y2, crop_x1:crop_x2
image_crop_roi = cv2.resize(im_crop, (h, w))[r1 + border:r2 - border,
c1 + border:c2 - border] # crop_y1:crop_y2, crop_x1:crop_x2
if INFO_0:
print 'image_crop_roi shape (tf ordering hwc):', image_crop_roi.shape # tf ordering channel last
if min(image_crop_roi.shape) < 1:
# demo_final_seg_result(fn,pred_thresh,fr_add_cont,image_crop_roi,prefix,screen_out,save_im=False,save_stack_imgs=False)
print 'tensor size too small'
cv2.putText(fr_add_cont, 'too small ROI', org=(10, 20), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=1,
color=(0, 255, 0), thickness=2)
pre_tensor_view = np.zeros((h, w, 3), np.uint8)
else:
print 'no FG'
classified_as = 0
cv2.putText(fr_add_cont, 'no FG', org=(10, 20), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=1,
color=(0, 255, 0), thickness=2)
pre_tensor_view = np.zeros((h, w, 3), np.uint8)
if do_classification:
overall_acc, confMat1_TEST \
= EVA_IMAGE_classify_seats(read_path_im, im_ori_view, im_crop, pred_thresh,
classified_as, count_test, confMat1_TEST, confMat2_TEST, border,
i, n_classes, fn)
if create_stacked_imgs_for_paper:
s_size = (320, 320)
if read_path_im == read_path_m:
list_of_imgs = [cv2.resize(im_ori_view, s_size), cv2.resize(pred_int, s_size),
cv2.resize(new_mask, s_size),
]
winname = 'in-pred-oldmask-newmask'
else:
# list_of_imgs = [cv2.resize(im_ori_view, (320 / 2, 320 / 2)), cv2.resize(pred_int, s_size),
# cv2.resize(old_mask, (320 / 2, 320 / 2)), cv2.resize(fr_add_cont, s_size)]
list_of_imgs = [cv2.resize(im_ori_view, s_size), cv2.resize(ref_mask, s_size), cv2.resize(pred_int, s_size),
cv2.resize(new_mask, s_size),
cv2.resize(fr_add_cont, s_size),
cv2.resize(roi_whitebg, s_size), cv2.resize(pre_tensor_view, s_size)]
winname = 'in-gt-pred-newmask-cont-pretensor'
print 'save path:', prefix, fn
stacked_imgs = demo_stacked_n_col_images(prefix, fn, list_of_imgs, winname, save_im=True)
list_of_imgs_res.append(stacked_imgs)
# cv2.imwrite(save_res_path + 'stack_'+ os.path.basename(files_im[i]), stacked_imgs)
if step_show and not CLOSE_ALL and not stop:
k = cv2.waitKey(30) & 0xFF
while True and not stop:
if k == ord('n'):
print 'add to fail_list:', fn
res_fail_list.append(read_path_im + os.path.basename(files_im[i]))
# res_fail_list.append(files[i])
break
elif k == ord('y'):
print 'add to pass_list:', fn
res_pass_list.append(read_path_im + os.path.basename(files_im[i]))
save_imgs = False
if save_imgs:
cv2.imwrite(save_res_path + 'stack_' + os.path.basename(files_im[i]), stacked_imgs)
break
elif k == ord('q'): # ESC
stop = True
break
else:
k = cv2.waitKey(30) & 0xFF
if k != 255:
print 'k:', k # 81-l, 83-r, 82-u, 84-d
if cv2.waitKey(1) & 0xFF == ord('q'):
print 'key interrupt'
break
print_res_list = False
if print_res_list: #
print bg_model, 'test package:', read_path_im
print 'res_fail_list=', res_fail_list, '\nres_pass_list=', res_pass_list
print 'num of fail:', len(res_fail_list), '\nnum of pass:'******'\n'.join(lines)
with open(file, 'w') as f:
f.writelines(lines)
save_eva_to_file = False
if save_eva_to_file:
keyword = os.path.basename(os.path.normpath(read_path_im))
save_to_file('../Test_Images/img_list/fail_' + keyword + '_' + os.path.basename(bg_model)[:-5] + '.txt',
res_fail_list)
save_to_file('../Test_Images/img_list/pass_' + keyword + '_' + os.path.basename(bg_model)[:-5] + '.txt',
res_pass_list)
cv2.destroyAllWindows()
if count_test > 0:
avg_dice = float(dices / count_test)
else:
avg_dice = 0
if avg_dice > best_avg:
best_avg = avg_dice
print '\nseg avg dice:', avg_dice, 'max dice:', max_dice, ', min dice:', min_dice, ', ', bg_model
if do_classification:
print '2classifier overall_acc', overall_acc
print tools.print_label_title()
print '#######'
print confMat1_TEST
print 'seg avg_non_empty:', avg_dice_non_empty, 'seg avg_empty:', avg_dice_empty
else:
overall_acc = 0
num_total_ims = len(list_of_imgs_res)
print 'list imgs res:', num_total_ims
# create_stacked_imgs_for_paper = True
if create_stacked_imgs_for_paper and num_total_ims > 0 and num_total_ims < 7:
MODEL_ID = ''
demo_stacked_n_row_images(prefix, MODEL_ID, list_of_imgs_res, winname, save_im=True)
return best_avg, bg_model, overall_acc, stop
from keras.preprocessing import image
from keras.applications.vgg16 import VGG16
from keras.applications.vgg16 import preprocess_input
from keras.applications.resnet50 import ResNet50
from keras.applications.resnet50 import preprocess_input as r_preprocess
from keras.layers import Dropout, Input, Lambda, Convolution2D, MaxPooling2D, Flatten, Dense, AveragePooling2D
from keras.engine.topology import Layer
from keras.models import Model
from keras.optimizers import Adam, SGD
from keras.callbacks import ModelCheckpoint, Callback
from keras import backend as K
from keras import regularizers
from load_data import load_caption
img_dim_ordering = 'tf'
K.set_image_dim_ordering(img_dim_ordering)
tf.reset_default_graph()
#Lexical FCN model with MIML loss
def pretrained_model(img_shape, length):
'''
img_shape = (320, 320, 3)
length = 7677
'''
keras_input = Input(shape=img_shape, name = 'image_input')
model_resnet50_conv = ResNet50(input_shape=img_shape, weights='imagenet', include_top=False)
#model_vgg16_conv.summary()
x = model_resnet50_conv(keras_input)#(batch, 10, 10, 512)
print(model_resnet50_conv.summary())
x = AveragePooling2D(pool_size = (3, 3), strides = (3, 3), padding = 'same', name='avg_pool')(x)
return model
# network and training
NB_EPOCH = 20
BATCH_SIZE = 128
VERBOSE = 1
OPTIMIZER = Adam()
VALIDATION_SPLIT=0.2
IMG_ROWS, IMG_COLS = 28, 28 # input image dimensions
NB_CLASSES = 10 # number of outputs = number of digits
INPUT_SHAPE = (1, IMG_ROWS, IMG_COLS)
# data: shuffled and split between train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
K.set_image_dim_ordering("th")
# consider them as float and normalize
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
# we need a 60K x [1 x 28 x 28] shape as input to the CONVNET
X_train = X_train[:, np.newaxis, :, :]
X_test = X_test[:, np.newaxis, :, :]
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
import numpy as np
import pickle
import cv2
import os
from keras import optimizers #for compiling a keras model
from keras.models import Sequential #linear stack of layers
from keras.layers import Dense #Dense is a name for fully connected/linear layer in keras
from keras.layers import Dropout #Dropout is a technique where randomly selected neurons are ignored during training.
from keras.layers import Flatten
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras.callbacks import ModelCheckpoint #Adding checkpoints to your trainning process
from keras import backend as K #Keras does not do simple level operations like convolution so tensorflow or theano does it
K.set_image_dim_ordering(
'tf'
) #"tf" format means that the convolutional kernels will have the shape (rows, cols, input_depth, depth)
def get_image_size():
img = cv2.imread('gestures/0/100.jpg', 0)
return img.shape
def get_num_of_classes():
return len(os.listdir('gestures/'))
image_x, image_y = get_image_size()
def get_unet(img_rows, img_cols):
K.set_image_dim_ordering('th')
inputs = Input((1, img_rows, img_cols))
conv1 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(inputs)
conv1 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(pool1)
conv2 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(pool2)
conv3 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(pool3)
conv4 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(pool4)
conv5 = Convolution2D(512, 3, 3, activation='relu',
border_mode='same')(conv5)
up6 = merge([UpSampling2D(size=(2, 2))(conv5), conv4],
mode='concat',
concat_axis=1)
conv6 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(up6)
conv6 = Convolution2D(256, 3, 3, activation='relu',
border_mode='same')(conv6)
up7 = merge([UpSampling2D(size=(2, 2))(conv6), conv3],
mode='concat',
concat_axis=1)
conv7 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(up7)
conv7 = Convolution2D(128, 3, 3, activation='relu',
border_mode='same')(conv7)
up8 = merge([UpSampling2D(size=(2, 2))(conv7), conv2],
mode='concat',
concat_axis=1)
conv8 = Convolution2D(64, 3, 3, activation='relu', border_mode='same')(up8)
conv8 = Convolution2D(64, 3, 3, activation='relu',
border_mode='same')(conv8)
up9 = merge([UpSampling2D(size=(2, 2))(conv8), conv1],
mode='concat',
concat_axis=1)
conv9 = Convolution2D(32, 3, 3, activation='relu', border_mode='same')(up9)
conv9 = Convolution2D(32, 3, 3, activation='relu',
border_mode='same')(conv9)
conv10 = Convolution2D(1, 1, 1, activation='sigmoid')(conv9)
model = Model(input=inputs, output=conv10)
model.compile(optimizer=Adam(lr=1.0e-5),
loss=dice_coef_loss,
metrics=[dice_coef])
return model
print()
print('Begin Deep Learning Process (Simple Deep Learning')
NB_EPOCH = 150
BATCH_SIZE = 128
VERBOSE = 1
NB_CLASSES = 10
OPTIMIZER = Adam()
N_HIDDEN = 128
VALIDATION_SPLIT = 0.2
RESHAPE = 784
DROPOUT = 0.2
IMG_ROW, IMG_COL = 28, 28
INPUT_SHAPE = (1, IMG_ROW, IMG_COL)
K.set_image_dim_ordering("th")
X_train = X_train.reshape(60000, 1, IMG_ROW, IMG_COL)
X_test = X_test.reshape(20000, 1, IMG_ROW, IMG_COL)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
print('{} Train Samples'.format(X_train.shape[0]))
print('{} Test Samples'.format(X_test.shape[0]))
Y_train = np_utils.to_categorical(Y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(Y_test, NB_CLASSES)
def EVALUATE_VIDEO_seg_and_classify(VIDEO_FILE, num_class): # (v)
# load seg model
set_image_dim_ordering(dim_ordering='th') # if not configured in
model = load_model("../testbench/bg/" + bg_model)
print 'loaded model', bg_model
n_classes = num_class
video = cv2.VideoCapture(VIDEO_FILE) # hy: changed from cv2.VideoCapture()
video.set(1, 2) # hy: changed from 1,2000 which was for wheelchair test video,
# hy: propID=1 means 0-based index of the frame to be decoded/captured next
if not video.isOpened():
print "cannot find or open video file"
exit(-1)
# hy: initialize confmatrix
confMat2_TEST_Video = np.zeros((2, 2), dtype=np.float)
## Reading the video file frame by frame
video_frame_i = 0
while True: #and video_frame_i < 850:
ret, frame = video.read()
if ret: # time for a loop 7.28790903091 start from here
h = frame.shape[0]
w = frame.shape[1]
video_frame_i += 1
#print '\n\n########################################### start, frame', video_frame_i
# print 'frame shape h,w:', h, w # 1536 2304
else:
break
if video_frame_i % 2 == 0:
# time for a loop 7.43529987335,7.09782910347 variously, start from here
use_focus_window = 1
if use_focus_window:
crop_x1 = 550 # 550
crop_y1 = 700 #700# 300
area_step_size = 740 #740# 640
crop_x2 = crop_x1 + area_step_size * 1
crop_y2 = crop_y1 + area_step_size * 1 * settings.h_resize / settings.w_resize
frame_crop_color = frame[crop_y1:crop_y2, crop_x1:crop_x2]
#cv2.imwrite('../testbench/frame_color_tmp.jpg', np.uint8(frame_crop_color))
else:
crop_x1 = 0
crop_y1 = 0
crop_x2 = 0 + w # 2300 #1920
crop_y2 = 0 + h # 1536 #1080
frame_crop_color = frame[crop_y1:crop_y2, crop_x1:crop_x2]
# debug
# print "shape:y1,y2,x1,x2:", crop_y1,", ", crop_y2,", ", crop_x1,", ", crop_x2
# cv2.imshow("frame_cropped", frame_crop)
# time for a loop 7.08207583427 from here
#frame_crop = imutils.resize(cv2.cvtColor(frame_crop, cv2.COLOR_BGR2GRAY), width=320)
# debug
# print 'crop size', frame_crop.shape
# cv2.imshow("TensorFlow Window", imutils.resize(frame_crop.astype(np.uint8), 480))
frame_crop_roi, screen_out = do_segment(model, frame_crop_color, video_frame_i, 320, 320)
# time elapsed for classification 0.0430190563202
######################### get classified result start#################################
do_classification(frame,video_frame_i, frame_crop_roi, confMat2_TEST_Video, crop_y1, crop_y2, crop_x1,
crop_x2, n_classes,screen_out)
######################### Tensorflow
'''
# frame_demo = imutils.resize(frame, width = min(1200, settings.w_resize * 30)) #hy: choose a smaller window size
cv2.imshow("Demo", frame_demo)
cv2.waitKey(30)
'''
######################################
# cv2.waitKey(6000)
if cv2.waitKey(1) & 0xFF == ord('q'): # hy:press key-q to quit
break
#########################################################################
####THIS CODE IS INTENDED TO REPRODUCE THE RESULTS OF EEGNET###
####Training with 12 data sets, validation with 4 datasets, and test with 10 datasets######
########################################################################
import os
import csv
import random
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve, auc
from keras import backend as K
from keras.models import load_model
from keras.utils import np_utils
K.set_image_dim_ordering('th') # set dimension ordering to theano
# import models
from EEGModels import EEGNet, EEGNetOrg
from EEGModels import DeepConvNet
# individuals number
train_sample_num = [
2, 6, 7, 11, 12, 13, 14, 16, 17, 18, 20, 21, 22, 23, 24, 26
]
test_sample_num = [1, 3, 4, 5, 8, 9, 10, 15, 19, 25]
train_subject_num = len(train_sample_num)
test_subject_num = len(test_sample_num)
train_tot_trials = int(8 * 340)
test_tot_trials = int(test_subject_num * 340)
validation_tot_trials = int(4 * 340)
def seg_image_2c(h, w, file_i=1):
print 'start evaluation, model', bg_model
images, mask = tools.import_data_unet_2c("../tmp/distor_in/input/", "cad_%03d.jpg", "cad_m_%03d.jpg", h, w, 3, file_i,
do_Flipping=False)
# params: loadData(data_path, file_img, file_mask, h, w, maxNum, do_Flipping=False)
test_num = (images.shape)[0]
print 'number of test images', test_num, ', shape', images.shape # (3, 1, 320, 320)
images = images[1:-1, :, :, :] #
print '2-shape of test images', images.shape # (1, 1, 320, 320)
set_image_dim_ordering(dim_ordering='th') # if not configured in
try:
model = load_model("../testbench/bg/" + bg_model)
print 'loaded model', bg_model
except Exception as e:
print '[Hint-e]', e
# debug
# model.summary()
mean, stdev = tools.calc_mean_stdev(images)
images_original = images.copy()
# print '3-number of test images', images_original.shape
images = (images - mean) / stdev
# print 'number of test images', (images.shape), ', ... ', images.shape
for i in range(0, images.shape[0]):
start = time.time()
result = model.predict(images[i, :, :, :].reshape(1, 1, h, w), batch_size=1) # old
end = time.time()
print(end - start)
print 'Test image', i + 1, ", Min/Max: %f %f" % (np.min(result), np.max(result))
print 'result shape', (result.shape)
res = result[0, 0, :, :].reshape((h, w)) * 255 # old
input_resized = cv2.resize(np.uint8(images_original[i, :, :, :].reshape(h, w) * 255), (480, 360))
print 'min/max:%f %f' % (np.min(images_original[i, :, :, :]), np.max(images_original[i, :, :, :]))
# debug
# cv2.imshow("input_resized_window1", input_resized)
# cv2.waitKey(10000)
output_resized = cv2.resize(np.uint8(res), (480, 360))
input_rgb = cv2.cvtColor(input_resized, cv2.COLOR_GRAY2RGB)
# cv2.imshow("input_rgb_window2", input_rgb)
# cv2.waitKey(10000)
color = tools.add_colorOverlay(input_resized, output_resized)
combined = np.hstack((input_rgb, color))
save_file = True
if save_file:
cv2.imwrite('../testbench/res.jpg', np.uint8(res))
# cv2.imwrite('../testbench/res_' + bg_model[:-5] + '%03d.jpg' % i, np.uint8(res))
cv2.imwrite("../testbench/combined_%03d.jpg" % i, combined)
cv2.imwrite("../testbench/color_%03d.jpg" % i, color)
else:
cv2.imshow('res', np.uint8(res))
# cv2.imwrite('combined', combined)
# cv2.imwrite('color', color)
##########################################################
# res2 = result[0,0, :, 1].reshape((320,320))*255
# back = result[0,0, :, 2].reshape((320, 320)) * 255
# cv2.imshow("S", np.uint8(res))
# cv2.imshow("S2", np.uint8(res2))
# cv2.imshow("Bg", np.uint8(back))
input = np.uint8(((images[i, :, :, :] * stdev + mean) * 255).reshape(320, 320))
cv2.imshow("input", input)
cv2.waitKey(10)
return np.uint8(res)
# network and training
NB_EPOCH = 2
BATCH_SIZE = 128
VERBOSE = 1
OPTIMIZER = Adam()
VALIDATION_SPLIT = 0.2
IMG_ROWS, IMG_COLS = 28, 28 # input image dimensions
INPUT_SHAPE = (1, IMG_ROWS, IMG_COLS) # data: shuffled and split between train and test sets
'''loading of the data and defining the no of classes'''
NB_CLASSES = 10 # number of outputs = number of digits
(X_train, y_train), (X_test, y_test) = mnist.load_data()
K.set_image_dim_ordering("th") # consider them as float and normalize
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
# we need a 60K x [1 x 28 x 28] shape as input to the CONVNET
X_train = X_train[:, np.newaxis, :, :]
X_test = X_test[:, np.newaxis, :, :]
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = np_utils.to_categorical(y_train, NB_CLASSES)
y_test = np_utils.to_categorical(y_test, NB_CLASSES)
# initialize the optimizer and model
def EVALUATE_VIDEO_seg_and_classify(seg_model_name, VIDEO_FILE, num_class, in_ch, step_show=False, save_imgs=False,
stop=False): # (v)
seg_model = os.path.join(FLAGS.seg_model_search_p, seg_model_name)
# print 'seg model loaded:', seg_model
video = cv2.VideoCapture(VIDEO_FILE) # hy: changed from cv2.VideoCapture()
video.set(1, 2) # hy: changed from 1,2000 which was for wheelchair test video,
# hy: propID=1 means 0-based index of the frame to be decoded/captured next
if not video.isOpened():
print "cannot find or open video file:", VIDEO_FILE
exit(-1)
eva_count = 0
video_frame_i = 0 #
confMat1_TEST = np.zeros((num_class, num_class), dtype=np.float) # hy collect detailed confusion matrix
confMat2_TEST = np.zeros((2, 2), dtype=np.float)
# load seg model
set_image_dim_ordering(dim_ordering='th') #
model = load_model(seg_model)
while True and not stop: # and video_frame_i < 850:
ret, frame = video.read()
if cv2.waitKey(1) & 0xFF == ord('q'): # hy:press key-q to quit
print 'key interrupt,press q again to quit completely'
break
if ret: # time for a loop 7.28790903091 start from here
h, w = frame.shape[0], frame.shape[1]
video_frame_i += 1
# print 'frame',video_frame_i
# print 'frame shape h,w:', h, w # 1536 2304
if video_frame_i % 5 == 0: # ' and video_frame_i > 3750:#> 1350 and video_frame_i < 1470:
eva_count += 1
# time for a loop 7.43529987335,7.09782910347 variously, start from here
crop_x1 = 0
crop_y1 = 0
crop_x2 = 0 + w # 2300 #1920
crop_y2 = 0 + h # 1536 #1080
frame_crop = frame[crop_y1:crop_y2, crop_x1:crop_x2]
frame_crop_color = frame_crop.copy()
# debug
################################################################################################################
pred_int, pred_255, fr_add_cont, old_mask, old_roi_res, new_mask, \
pre_tensor, r1, r2, c1, c2, screen_out, roi_whitebg \
= do_segment_video(model, frame_crop_color, video_frame_i, FLAGS.IMAGE_SIZE, FLAGS.IMAGE_SIZE,
in_ch, show_bbox=True)
# add blue overlay for better demo
tmp_h, tmp_w, tmp_ch = frame_crop_color.shape
base = cv2.resize(frame_crop_color, (tmp_h, tmp_w))
new_mask_display = cv2.resize(new_mask, (tmp_h, tmp_w))
fr_add_cont_overlay = add_blueOverlay(base, new_mask_display)
if screen_out:
# prefix = FLAGS.save_res_path + get_model_index(Seg_MODEL_to_load, search_by='-')
prefix = FLAGS.save_res_path
fn = eva_count
# VIDEO
s_size = (800,
600) # cv2.resize(pred_int, s_size) cv2.resize(old_mask, s_size) cv2.resize(roi_whitebg, s_size) new_mask frame_crop_color
list_of_imgs = [cv2.resize(fr_add_cont_overlay, s_size)]
winname = 'fr_with_newmask'
stacked_imgs = create_stacked_n_col_images(prefix, fn, list_of_imgs, winname, save_im=True)
# cv2.imshow('stacked_imgs',stacked_imgs)
################################################################################################################
if not step_show:
pass
else:
k = cv2.waitKey(30) & 0xFF
while True and not stop:
if k == ord('n'):
print 'add to fail_list'
# res_fail_list.append(read_path_im + os.path.basename(files_im[i]))
# res_fail_list.append(files[i])
break
elif k == ord('y'):
print 'add to pass_list'
save_ori_frame = True
save_imgs = True
if save_imgs:
if save_ori_frame:
# im_save = cv2.resize(frame_crop_color, (1920, 1080), interpolation=cv2.INTER_CUBIC) # upsampling
im_save = frame_crop_color # upsampling
# or save image_crop_roi
else:
im_save = cv2.resize(frame_crop_color, (h, w))
v_str = os.path.splitext(VIDEO_FILE)
cv2.imwrite(FLAGS.save_res_path + v_str + '_' + str(video_frame_i) + '.jpg',
im_save)
print 'saved to', FLAGS.save_res_path + v_str + '_' + str(video_frame_i) + '.jpg'
break
elif k == ord('q'): # ESC
break
else:
k = cv2.waitKey(30) & 0xFF
if k != 255:
print 'k:', k # 81-l, 83-r, 82-u, 84-d
if cv2.waitKey(1) & 0xFF == ord('q'):
print 'key interrupt, press again to close all windows'
break
cv2.waitKey(10) # required for roi_seg
else:
print 'video end'
video.release()
stop = True
stop = True
return stop
def process_tst(nfolds):
FOLD_TO_CALC = [1, 2, 3, 4, 5]
recalc = 1
batch_size = 8
augmentation_size = AUGMENTATION_SIZE
cnn_type = 'ZF_full_keras_model_inception_v1'
subm = pd.read_csv(INPUT_PATH + 'submission_format.csv',
index_col='filename')
files = list(subm.index.values)
print('Files to process: {}'.format(len(files)))
pred_list = []
for num_fold in range(1, nfolds + 1):
print('Start KFold number {} from {}'.format(num_fold, nfolds))
if num_fold not in FOLD_TO_CALC:
continue
cache_path = CACHE_PATH + cnn_type + '_fold_{}.pklz'.format(num_fold)
if not os.path.isfile(cache_path) or recalc == 1:
import keras.backend as K
K.set_image_dim_ordering('th')
model = ZF_full_keras_model_inception_v1()
final_model_path = MODELS_PATH + '{}_fold_{}.h5'.format(
cnn_type, num_fold)
model.load_weights(final_model_path)
steps = math.ceil(len(files) / batch_size)
print('Steps: {}'.format(steps))
full_preds = model.predict_generator(generator=predict_generator(
files, batch_size),
steps=steps,
max_queue_size=10,
verbose=2)
if full_preds.shape[0] != augmentation_size * len(files):
print('Check predictions shape: {} != {}'.format(
full_preds.shape, augmentation_size * len(files)))
print('Predictions shape: {}'.format(full_preds.shape))
preds = []
for j in range(len(files)):
p = full_preds[j * augmentation_size:(j + 1) *
augmentation_size].copy().mean(axis=0)
preds.append(p.copy())
preds = np.array(preds)
save_in_file(preds, cache_path)
else:
preds = load_from_file(cache_path)
pred_list.append(preds)
pred_list = np.array(pred_list)
print('Full predictions shape: {}'.format(pred_list.shape))
preds = pred_list.mean(axis=0)
print('Averaged predictions shape: {}'.format(preds.shape))
for i in range(preds.shape[0]):
subm.loc[files[i], ANIMAL_TYPE] = preds[i]
subm.to_csv(FEATURES_PATH + 'ZF_full_keras_model_inception_v1_test.csv')
def Xception(include_top=True, weights='imagenet',
input_tensor=None):
'''Instantiate the Xception architecture,
optionally loading weights pre-trained
on ImageNet. This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
dimension ordering `(width, height, channels)`.
You should set `image_dim_ordering="tf"` in your Keras config
located at ~/.keras/keras.json.
Note that the default input image size for this model is 299x299.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or "imagenet" (pre-training on ImageNet).
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
# Returns
A Keras model instance.
'''
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if K.backend() != 'tensorflow':
raise Exception('The Xception model is only available with '
'the TensorFlow backend.')
if K.image_dim_ordering() != 'tf':
warnings.warn('The Xception model is only available for the '
'input dimension ordering "tf" '
'(width, height, channels). '
'However your settings specify the default '
'dimension ordering "th" (channels, width, height). '
'You should set `image_dim_ordering="tf"` in your Keras '
'config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "tf" dimension ordering.')
K.set_image_dim_ordering('tf')
old_dim_ordering = 'th'
else:
old_dim_ordering = None
# Determine proper input shape
if include_top:
input_shape = (299, 299, 3)
else:
input_shape = (None, None, 3)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = Conv2D(32, 3, 3, subsample=(2, 2), bias=False, name='block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, 3, 3, bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128, 1, 1, subsample=(2, 2),
border_mode='same', bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128, 3, 3, border_mode='same', bias=False, name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128, 3, 3, border_mode='same', bias=False, name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), border_mode='same', name='block2_pool')(x)
x = merge([x, residual], mode='sum')
residual = Conv2D(256, 1, 1, subsample=(2, 2),
border_mode='same', bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256, 3, 3, border_mode='same', bias=False, name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256, 3, 3, border_mode='same', bias=False, name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), border_mode='same', name='block3_pool')(x)
x = merge([x, residual], mode='sum')
residual = Conv2D(728, 1, 1, subsample=(2, 2),
border_mode='same', bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728, 3, 3, border_mode='same', bias=False, name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728, 3, 3, border_mode='same', bias=False, name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), border_mode='same', name='block4_pool')(x)
x = merge([x, residual], mode='sum')
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728, 3, 3, border_mode='same', bias=False, name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728, 3, 3, border_mode='same', bias=False, name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728, 3, 3, border_mode='same', bias=False, name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = merge([x, residual], mode='sum')
residual = Conv2D(1024, 1, 1, subsample=(2, 2),
border_mode='same', bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728, 3, 3, border_mode='same', bias=False, name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024, 3, 3, border_mode='same', bias=False, name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), border_mode='same', name='block13_pool')(x)
x = merge([x, residual], mode='sum')
x = SeparableConv2D(1536, 3, 3, border_mode='same', bias=False, name='block14_sepconv1')(x)
x = BatchNormalization(name='block14_sepconv1_bn')(x)
x = Activation('relu', name='block14_sepconv1_act')(x)
x = SeparableConv2D(2048, 3, 3, border_mode='same', bias=False, name='block14_sepconv2')(x)
x = BatchNormalization(name='block14_sepconv2_bn')(x)
x = Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(1000, activation='softmax', name='predictions')(x)
# Create model
model = Model(img_input, x)
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file('xception_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models')
else:
weights_path = get_file('xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model.load_weights(weights_path)
if old_dim_ordering:
K.set_image_dim_ordering(old_dim_ordering)
return model
def main():
testsetCount = 5
accuracies = [0, 0, 0,0,0]
for testid in range(0,testsetCount):
print(testid)
K.set_image_dim_ordering('tf')
#sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
# from keras_video_classifier.library.utility.plot_utils import plot_and_save_history
# from keras_video_classifier.library.recurrent_networks import VGG16LSTMVideoClassifier
# from keras_video_classifier.library.utility.ucf.UCF101_loader import load_ucf
#
data_set_name = 'AM_pics_' + str(testid)
# input_dir_path = os.path.join(os.path.dirname(__file__), 'AM_data')
# output_dir_path = os.path.join(os.path.dirname(__file__), 'models', data_set_name)
# report_dir_path = os.path.join(os.path.dirname(__file__), 'reports', data_set_name)
#
# np.random.seed(34)
#
# # this line downloads the video files of UCF-101 dataset if they are not available in the very_large_data folder
# #load_ucf(input_dir_path)
#
# classifier = VGG16LSTMVideoClassifier()
#
# history = classifier.fit(data_dir_path=input_dir_path, model_dir_path=output_dir_path, vgg16_include_top=False,
# data_set_name=data_set_name,from_picture=True)
#
# plot_and_save_history(history, VGG16LSTMVideoClassifier.model_name,
# report_dir_path + '/' + VGG16LSTMVideoClassifier.model_name + '-hi-dim-history_' + str(testid) + '.png')
print("predicting now !!!!!")
K.set_image_dim_ordering('tf')
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
from keras_video_classifier.library.recurrent_networks import VGG16LSTMVideoClassifier
from keras_video_classifier.library.utility.ucf.UCF101_loader import load_ucf, scan_ucf_with_labels
vgg16_include_top = False
data_dir_path = os.path.join(os.path.dirname(__file__), 'AM_data')
model_dir_path = os.path.join(os.path.dirname(__file__), 'models', data_set_name)
# data_dir_path = os.path.join(os.path.dirname(__file__), 'very_large_data')
# model_dir_path = os.path.join(os.path.dirname(__file__), 'models', 'UCF-101')
config_file_path = VGG16LSTMVideoClassifier.get_config_file_path(model_dir_path,
vgg16_include_top=vgg16_include_top)
weight_file_path = VGG16LSTMVideoClassifier.get_weight_file_path(model_dir_path,
vgg16_include_top=vgg16_include_top)
print("Reading weights from :", weight_file_path)
print("Reading Config from :", config_file_path)
np.random.seed(33)
print(weight_file_path)
# load_ucf(data_dir_path)
predictor = VGG16LSTMVideoClassifier()
predictor.load_model(config_file_path, weight_file_path)
videos = scan_ucf_with_labels(data_dir_path, [label for (label, label_index) in predictor.labels.items()],testid)
video_file_path_list = np.array([file_path for file_path in videos.keys()])
np.random.shuffle(video_file_path_list)
correct_count = 0
count = 0
for video_file_path in video_file_path_list:
label = videos[video_file_path]
predicted_label = predictor.predict(video_file_path, from_picture=True)
print('predicted: ' + predicted_label + ' actual: ' + label)
correct_count = correct_count + 1 if label == predicted_label else correct_count
count += 1
accuracy = correct_count / count
print('accuracy: ', accuracy)
accuracies[testid] = accuracy
print(accuracies)
print(sum(accuracies) / len(accuracies))
def Xception(include_top=True, weights='imagenet', input_tensor=None):
'''Instantiate the Xception architecture,
optionally loading weights pre-trained
on ImageNet. This model is available for TensorFlow only,
and can only be used with inputs following the TensorFlow
dimension ordering `(width, height, channels)`.
You should set `image_dim_ordering="tf"` in your Keras config
located at ~/.keras/keras.json.
Note that the default input image size for this model is 299x299.
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or "imagenet" (pre-training on ImageNet).
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
# Returns
A Keras model instance.
'''
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
if K.backend() != 'tensorflow':
raise Exception('The Xception model is only available with '
'the TensorFlow backend.')
if K.image_dim_ordering() != 'tf':
warnings.warn('The Xception model is only available for the '
'input dimension ordering "tf" '
'(width, height, channels). '
'However your settings specify the default '
'dimension ordering "th" (channels, width, height). '
'You should set `image_dim_ordering="tf"` in your Keras '
'config located at ~/.keras/keras.json. '
'The model being returned right now will expect inputs '
'to follow the "tf" dimension ordering.')
K.set_image_dim_ordering('tf')
old_dim_ordering = 'th'
else:
old_dim_ordering = None
# Determine proper input shape
if include_top:
input_shape = (32, 32, 1)
else:
input_shape = (None, None, 3)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
x = Conv2D(32, 3, 3, bias=False, name='new_block1_conv1')(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, 3, 3, bias=False, name='block1_conv2')(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(128,
1,
1,
subsample=(2, 2),
border_mode='same',
bias=False)(x)
residual = BatchNormalization()(residual)
x = SeparableConv2D(128,
3,
3,
border_mode='same',
bias=False,
name='block2_sepconv1')(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(128,
3,
3,
border_mode='same',
bias=False,
name='block2_sepconv2')(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
border_mode='same',
name='block2_pool')(x)
x = merge([x, residual], mode='sum')
residual = Conv2D(256,
1,
1,
subsample=(2, 2),
border_mode='same',
bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block3_sepconv1_act')(x)
x = SeparableConv2D(256,
3,
3,
border_mode='same',
bias=False,
name='block3_sepconv1')(x)
x = BatchNormalization(name='block3_sepconv1_bn')(x)
x = Activation('relu', name='block3_sepconv2_act')(x)
x = SeparableConv2D(256,
3,
3,
border_mode='same',
bias=False,
name='block3_sepconv2')(x)
x = BatchNormalization(name='block3_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
border_mode='same',
name='block3_pool')(x)
x = merge([x, residual], mode='sum')
residual = Conv2D(728,
1,
1,
subsample=(2, 2),
border_mode='same',
bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block4_sepconv1_act')(x)
x = SeparableConv2D(728,
3,
3,
border_mode='same',
bias=False,
name='block4_sepconv1')(x)
x = BatchNormalization(name='block4_sepconv1_bn')(x)
x = Activation('relu', name='block4_sepconv2_act')(x)
x = SeparableConv2D(728,
3,
3,
border_mode='same',
bias=False,
name='block4_sepconv2')(x)
x = BatchNormalization(name='block4_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
border_mode='same',
name='block4_pool')(x)
x = merge([x, residual], mode='sum')
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(728,
3,
3,
border_mode='same',
bias=False,
name=prefix + '_sepconv1')(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(728,
3,
3,
border_mode='same',
bias=False,
name=prefix + '_sepconv2')(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(728,
3,
3,
border_mode='same',
bias=False,
name=prefix + '_sepconv3')(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = merge([x, residual], mode='sum')
residual = Conv2D(1024,
1,
1,
subsample=(2, 2),
border_mode='same',
bias=False)(x)
residual = BatchNormalization()(residual)
x = Activation('relu', name='block13_sepconv1_act')(x)
x = SeparableConv2D(728,
3,
3,
border_mode='same',
bias=False,
name='block13_sepconv1')(x)
x = BatchNormalization(name='block13_sepconv1_bn')(x)
x = Activation('relu', name='block13_sepconv2_act')(x)
x = SeparableConv2D(1024,
3,
3,
border_mode='same',
bias=False,
name='block13_sepconv2')(x)
x = BatchNormalization(name='block13_sepconv2_bn')(x)
# x = MaxPooling2D((3, 3), strides=(2, 2), border_mode='same', name='block13_pool')(x)
# x = merge([x, residual], mode='sum')
# x = SeparableConv2D(1536, 3, 3, border_mode='same', bias=False, name='block14_sepconv1')(x)
# x = BatchNormalization(name='block14_sepconv1_bn')(x)
# x = Activation('relu', name='block14_sepconv1_act')(x)
# x = SeparableConv2D(2048, 3, 3, border_mode='same', bias=False, name='block14_sepconv2')(x)
# x = BatchNormalization(name='block14_sepconv2_bn')(x)
# x = Activation('relu', name='block14_sepconv2_act')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(2, activation='softmax', name='new_predictions')(x)
# Create model
model = Model(img_input, x)
# load weights
if weights == 'imagenet':
if include_top:
weights_path = get_file(
'xception_weights_tf_dim_ordering_tf_kernels.h5',
TF_WEIGHTS_PATH,
cache_subdir='models')
else:
weights_path = get_file(
'xception_weights_tf_dim_ordering_tf_kernels_notop.h5',
TF_WEIGHTS_PATH_NO_TOP,
cache_subdir='models')
model.load_weights(weights_path, by_name=True)
if old_dim_ordering:
K.set_image_dim_ordering(old_dim_ordering)
return model
def start_bundle(self, context=None):
os.environ["KERAS_BACKEND"] = "theano"
import vgg16bn
from keras import backend as K
K.set_image_dim_ordering('th')
self.vgg = vgg16bn.Vgg16BN(include_top=False, size=self.size)
# https://www.kaggle.com/danielelton/digit-recognizer/keras-cnn-with-explanation
import pandas as pd
import numpy as np
from keras.utils.np_utils import to_categorical
from keras import backend as K
from keras.models import Sequential
from keras.layers.convolutional import *
from keras.layers.core import Dropout, Dense, Flatten, Activation
from keras.callbacks import EarlyStopping
import os
K.set_image_dim_ordering('th') #input shape: (channels, height, width)
root_dir = os.path.abspath('../..')
data_dir = os.path.join(root_dir, 'data_examples', 'DigitRecognizer')
train_df = pd.read_csv(os.path.join(data_dir, 'train.csv'))
valid_df = pd.read_csv(os.path.join(data_dir, 'test.csv'))
x_train = train_df.drop(['label'], axis=1).values.astype('float32')
Y_train = train_df['label'].values.astype('float32')
x_valid = valid_df.values.astype('float32')
img_width, img_height = 28, 28
n_train = x_train.shape[0]
n_valid = x_valid.shape[0]
n_classes = 10
from keras.layers import Dense, LSTM, Dropout, Conv1D, Conv2D, MaxPooling2D, Flatten
from keras.callbacks import ModelCheckpoint
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error
import pandas as pd
import scipy.io as sio
from os import listdir
from os.path import isfile, join
import numpy as np
import keras
from sklearn.metrics import accuracy_score
from keras import backend as K
import sys
from ultis import load_data
K.set_image_dim_ordering('tf') # For problems with ordering
number_of_classes = 4
def change(x):
answer = np.zeros((np.shape(x)[0]))
for i in range(np.shape(x)[0]):
max_value = max(x[i, :])
max_index = list(x[i, :]).index(max_value)
answer[i] = max_index
return answer.astype(np.int)
file_list = listdir('./cnn_data/')
file_list = [file for file in file_list if file.endswith('.npy')]
def train_2c(PROJ_DIR, train_mode, model_path, model_con_name, data_path, test_data_path, log_LABEL,
learning_rate, batch_size, MAX_ITERATION, INPUT_SIZE,
rnd_blurriness_min, rnd_blurriness_max, rnd_darkness_min, rnd_darkness_max, dropouts):
print ('PROJ_DIR,train_mode,model_path,model_con_name,data_path,test_data_path,log_LABEL,\
learning_rate,batch_size,MAX_ITERATION,INPUT_SIZE,rnd_blurriness_min,rnd_blurriness_max,\
rnd_darkness_min,rnd_darkness_max,dropouts',
PROJ_DIR, train_mode, model_path, model_con_name, data_path, test_data_path, log_LABEL,
learning_rate, batch_size, MAX_ITERATION, INPUT_SIZE,
rnd_blurriness_min, rnd_blurriness_max, rnd_darkness_min, rnd_darkness_max, dropouts)
model_path_name = os.path.join(model_path, model_con_name)
if 'con' in train_mode:
# manual
print '\nfollow model:', model_path_name, 'learning rate:', learning_rate
set_image_dim_ordering(dim_ordering='th')
h, w = INPUT_SIZE, INPUT_SIZE
if 'con' not in train_mode:
model_path_name = model_path + '.hdf5'
print '\ntrain binary classes, load data,learning rate:', learning_rate
images, masks = load_and_preprocess_data_k(h, w, PROJ_DIR, data_path,
rnd_blurriness_min, rnd_blurriness_max, rnd_darkness_min, rnd_darkness_max)
print 'train len:', len(images)
images_t, masks_t = load_and_preprocess_data_onlinetest_k(h, w, PROJ_DIR, test_data_path,
rnd_blurriness_min, rnd_blurriness_max, rnd_darkness_min,
rnd_darkness_max)
print 'images shape', images.shape
# images = images.transpose((None, 1, h, w))
print 'set checkpoint'
save_params = ModelCheckpoint(filepath=model_path + log_LABEL + '_{epoch:02d}-{val_loss:.2f}.hdf5',
monitor='val_loss', verbose=2,
save_best_only=False, save_weights_only=False, mode='auto')
keras.callbacks.History()
epochs = MAX_ITERATION #
learning_rate = learning_rate #
# decay_rate = learning_rate / epochs #not so good
momentum = 0.99
sgd = arch.SGD(lr=learning_rate, momentum=momentum) #
set_image_dim_ordering(dim_ordering='th')
print 'load network'
if train_mode == 'new_train':
model = arch.segnet_arch_2c(dropouts, h, w)
if train_mode == 'con_train':
model = load_model(model_path_name)
print 'compile'
# compile option 1
model.compile(loss='binary_crossentropy', optimizer=sgd)
model.fit(images, masks, batch_size=batch_size, nb_epoch=epochs, verbose=1, shuffle=True,
validation_data=(images_t, masks_t), callbacks=[save_params])
# visulization
# verbose=1 to switch on printing batch result
print 'save'
model.save(model_path + 'model_' + log_LABEL + '.h5')
import numpy as np
from tqdm import tqdm
from keras.models import Model
from keras.layers import Dense, Dropout, Flatten, Input, Conv2D, Reshape
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import UpSampling2D
from keras.optimizers import Adam
from keras import backend
from keras import initializers
# set keras/tensorflow configuration as channel-first
backend.set_image_dim_ordering('th')
# set parameters and load dataset
randomDim = 100
dLosses = []
gLosses = []
adam = Adam(lr=0.0002, beta_1=0.5)
X_train = np.load('X_13styles.npy')
# set the dataset as channel-first and reshape it between -1 and 1
X_train = X_train.transpose((0,3,1,2))
X_train = X_train.astype(np.float32)/127.5 - 1.0
# generator
g_input = Input(shape=(randomDim,))
g = Dense(256*8*8,
kernel_initializer=initializers.RandomNormal(stddev=0.02))(g_input)
g = LeakyReLU(0.2)(g)
g = Reshape((256, 8, 8))(g)
g = UpSampling2D(size=(2, 2))(g)
g = Conv2D(128, kernel_size=(5, 5), padding='same')(g)
g = LeakyReLU(0.2)(g)
def train(args):
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = args.dev
#todo: manage parameters in main
if args.data == "big":
dataset_path = "/cvgl/group/GazeCapture/gazecapture"
if args.data == "small":
dataset_path = "eye_tracker_train_and_val.npz"
if args.data == "big":
train_path = "/cvgl/group/GazeCapture/train"
val_path = "/cvgl/group/GazeCapture/validation"
test_path = "/cvgl/group/GazeCapture/test"
print("{} dataset: {}".format(args.data, dataset_path))
print('train111111111111')
# train parameters
n_epoch = args.max_epoch
batch_size = args.batch_size
patience = args.patience
print('train22222222222222')
# image parameter
img_cols = 64
img_rows = 64
img_ch = 3
# model
K.set_image_dim_ordering('th')
model = get_eye_tracker_model(img_ch, img_cols, img_rows)
print(img_ch)
# model summary
model.summary()
print('train33333333333333333333')
# weights
# print("Loading weights...", end='')
# weights_path = "weights/weights.003-4.05525.hdf5"
# model.load_weights(weights_path)
# print("Done.")
# optimizer
sgd = SGD(lr=1e-1, decay=5e-4, momentum=9e-1, nesterov=True)
adam = Adam(lr=1e-3)
# compile model
model.compile(optimizer=adam, loss='mse')
# data
# todo: parameters not hardocoded
if args.data == "big":
# train data
train_names = load_data_names(train_path)
# validation data
val_names = load_data_names(val_path)
# test data
test_names = load_data_names(test_path)
print('train444444444444444444444')
if args.data == "small":
train_data, val_data = load_data_from_npz(dataset_path)
# debug
# x, y = load_batch([l[0:batch_size] for l in train_data], img_ch, img_cols, img_rows)
# x, y = load_batch_from_names(train_names[0:batch_size], dataset_path, img_ch, img_cols, img_rows)
# last dataset checks
if args.data == "small":
print("train data sources of size: {} {} {} {} {}".format(
train_data[0].shape[0], train_data[1].shape[0], train_data[2].shape[0],
train_data[3].shape[0], train_data[4].shape[0]))
print("validation data sources of size: {} {} {} {} {}".format(
val_data[0].shape[0], val_data[1].shape[0], val_data[2].shape[0],
val_data[3].shape[0], val_data[4].shape[0]))
if args.data == "big":
model.fit_generator(
generator=generator_train_data(train_names, dataset_path, batch_size, img_ch, img_cols, img_rows),
steps_per_epoch=(len(train_names)) / batch_size,
epochs=n_epoch,
verbose=1,
validation_data=generator_val_data(val_names, dataset_path, batch_size, img_ch, img_cols, img_rows),
validation_steps=(len(val_names)) / batch_size,
callbacks=[EarlyStopping(patience=patience),
ModelCheckpoint("weights_big/weights.{epoch:03d}-{val_loss:.5f}.hdf5", save_best_only=True)
]
)
if args.data == "small":
model.fit_generator(
generator=generator_npz(train_data, batch_size, img_ch, img_cols, img_rows),
steps_per_epoch=(train_data[0].shape[0])/batch_size,
epochs=n_epoch,
verbose=1,
validation_data=generator_npz(val_data, batch_size, img_ch, img_cols, img_rows),
validation_steps=(val_data[0].shape[0])/batch_size,
callbacks=[EarlyStopping(patience=patience),
ModelCheckpoint("weights/weights.{epoch:03d}-{val_loss:.5f}.hdf5", save_best_only=True)
]
)
def foo():
# Determine proper input shape
if keras.__version__ > '1.0.3':
K.set_image_dim_ordering('th')
input_shape = (1, 224, 224)
#img_input = Input(shape=input_shape)
model = Sequential()
model.add(
Convolution2D(32,
3,
3,
input_shape=input_shape,
init=weight_init,
name='conv1_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(32, 3, 3, init=weight_init, name='conv1_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Convolution2D(64, 3, 3, init=weight_init, name='conv2_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, init=weight_init, name='conv2_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3, init=weight_init, name='conv2_3'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Convolution2D(128, 3, 3, init=weight_init, name='conv3_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Convolution2D(128, 3, 3, init=weight_init, name='conv3_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(
Convolution2D(512,
3,
3,
init=weight_init,
border_mode='same',
name='conv4_1'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(
Convolution2D(512,
3,
3,
init=weight_init,
border_mode='same',
name='conv4_2'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(dropout))
model.add(Flatten())
model.add(Dense(120, init=weight_init))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dropout(dropout))
model.add(Dense(2))
model.add(Activation('sigmoid'))
return model
assert args.dset in ["mnist", "celebA"]
# Set the backend by modifying the env variable
if args.backend == "theano":
os.environ["KERAS_BACKEND"] = "theano"
elif args.backend == "tensorflow":
os.environ["KERAS_BACKEND"] = "tensorflow"
# Import the backend
import keras.backend as K
# manually set dim ordering otherwise it is not changed
if args.backend == "theano":
image_dim_ordering = "th"
K.set_image_dim_ordering(image_dim_ordering)
elif args.backend == "tensorflow":
image_dim_ordering = "tf"
K.set_image_dim_ordering(image_dim_ordering)
import train_GAN
# Set default params
d_params = {"mode": "train_GAN",
"dset": args.dset,
"generator": args.generator,
"batch_size": args.batch_size,
"n_batch_per_epoch": args.n_batch_per_epoch,
"nb_epoch": args.nb_epoch,
"model_name": "CNN",
"epoch": args.epoch,
theano.config.nvcc.flags = '-D_FORCE_INLINES'
theano.config.cxx = os.environ['CONDA_PREFIX'] + '/bin/g++'
else:
raise Exception('No configuration found when the backend is ' +
os.environ['KERAS_BACKEND'])
# import and check Keras version
import keras
import keras.backend as K
from keras import __version__ as keras_version
from pkg_resources import parse_version
if (parse_version(keras_version) >= parse_version('2.0')):
raise RuntimeError('DeepCell requires Keras 1 to run')
# configure Keras, to avoid using file ~/.keras/keras.json
K.set_image_dim_ordering('th') # theano's image format (required by DeepCell)
K.set_floatx('float32')
K.set_epsilon('1e-07')
##
###############################################################################
from __future__ import print_function
from keras.optimizers import SGD, RMSprop
from keras.callbacks import ModelCheckpoint, LearningRateScheduler
import cytometer
from cytometer.deepcell import rate_scheduler, train_model_sample, get_data_sample
from cytometer.deepcell_models import bn_feature_net_61x61 as the_model
dataset = "3T3_all_61x61"
#sklearn
from sklearn.utils import shuffle
from sklearn.cross_validation import train_test_split
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score
# Import libraries
import os,cv2
import sys
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from PIL import Image
K.set_image_dim_ordering('tf')
#important Params
img_rows, img_cols = 200, 200 # input image dimensions #460, 480
img_channels = 1 # number of channels (Gray Scale)
num_epoch=5 # Training epoch
batch_size = 100 # batch_size to train
nb_pool = 2 # size of pooling area for max pooling
stride = 2 # ??????
num_classes = 2 # Define the number of classes
nb_conv = 3 # convolution kernel size
# Define data path
# get the current directory
PATH_1 = os.getcwd()
def build_keras_model(args, modelEpsilon, input_shape, hiddenShrinkage, M , y , M_validation = None, y_validation = None) :
hLayerCount = args.hidCount
k.set_image_dim_ordering('tf') # otherwise it would give 'negative dimension size' for maxpool operations
#k.image_dim_ordering()
BNEnabled = int(args.bnorm) == 1
decay_Enabled = int(args.lr_decay) == 1
shrinkage = hiddenShrinkage
# k.set_image_dim_ordering('tf')
tf.set_random_seed(args.randomSeed) ## tf runs off a different random generator, let it be random for now, to be able to see if it really is the random init that is causing the 'zero' results?
if args.optimizer == 1 :
optimizer=Adam(lr=args.learnRate, epsilon=modelEpsilon, beta_1=args.momentum, beta_2=0.999, decay=args.lr_decay) # for float16, otherwise we get NaNs
else :
optimizer = SGD(lr=args.learnRate, momentum=args.momentum, decay=args.lr_decay)
# , beta_1=0.99, since the new Batchnorm logic this isn't needed
loss = 'mean_squared_error'
accMetrc = 'mae'
# Set up the base model.
model = Sequential()
lastLayerSize = args.firstLayerSize #lastLayerSize_MAX
# Input = knet_main.knnLayer( myNet,np.array([-1]), knet_main.LAYER_SUBTYPE_INPUT)
w_reg = l1_l2(l1=0.0, l2=hiddenShrinkage)
# if conv was enabled we then do NOT regularize stuff at the first FC layer as we only want to regularize by h2 once
if args.convLayers > 0 :
lastOutput = input_shape[0] # for conv nets it is channels last format for Tensorflow, so the first element of the input shape is the actual number of SNPs
print("Adding "+str(args.convLayers)+" conv layers, with initial input dimension: " + str(lastOutput), flush=True)
currentNumFilters= args.convFilters
currentStride = 3
filter_size = 5 # as it turns out it is not actually a problem if the conv outputs something that isn't an integer, so we just need to downsample it
model.add(Conv1D(currentNumFilters, filter_size, input_shape=(input_shape),kernel_regularizer=w_reg, kernel_initializer='he_normal' , padding="same", strides=currentStride ))
if BNEnabled : model.add(BatchNormalization())
addActivation(model,args.hidAct)
if args.dropout != -1 : model.add(Dropout(args.dropout))
# k.floatx() # 'float32'
# args.convLayers = 2
lastOutput = (lastOutput - filter_size +2) / currentStride + 1
lastOutput = int(lastOutput) # as these can only be integers
print("filter size : " + str(filter_size), flush=True)
#i=1
shrinkage = 0.0
currentStride = 1
pool_size = 2
for i in range(1, args.convLayers +1) :
# decide on filter size, depending on input, Conv layers must always produce even outputs so that maxpool can half them
filter_size = 3
if lastOutput % 2 != 0 : filter_size = 4 # if the current output is not even, then we have to use a filter size of 4, otherwise we get fractions after the maxpool operation
## currentNumFilters = (i+1) * args.convFilters
currentNumFilters = currentNumFilters // 2
model.add(Conv1D(currentNumFilters, filter_size,kernel_regularizer=None, kernel_initializer='he_normal' , padding="same", strides=currentStride))
if BNEnabled : model.add(BatchNormalization())
addActivation(model,args.hidAct)
if args.dropout != -1 : model.add(Dropout(args.dropout))
lastOutput = (lastOutput - filter_size +2) / currentStride + 1
lastOutput = int(lastOutput) # as these can only be integers
print("filter size affter Conv ("+str(i)+") : " + str(filter_size) + " / output: " + str(lastOutput), flush=True)
lastOutput = (lastOutput - pool_size) / pool_size + 1 # compute what dimensions the conv+maxpool operations are going to leave for the next layer
print("filter size affter Maxpool ("+str(i)+") : " + str(filter_size) + " / output: " + str(lastOutput), flush=True)
model.add(MaxPooling1D()) # the default is 2
model.add(Flatten()) # Flatten the data for input into the plain hidden layer
for i in range(1,hLayerCount+1) : # iterate 1 based, otherwise we will get a reduction after the first layer, no matter the widthReductionRate, as 0 is divisible by anything
if i > 1 or args.convLayers > 0 : shrinkageParam = w_reg # only add regularizer for first layer, subsequent layers will always have none
else : shrinkageParam = None
#if i == (hLayerCount-1) : lastWidth = 2 # enforce so that the last widht is always 2, ie 1 neuron makes it MORE like the other LESS likely
if i == 1: model.add(Dense(lastLayerSize,kernel_regularizer=shrinkageParam, kernel_initializer='he_normal', input_shape = input_shape))
else : model.add(Dense(lastLayerSize,kernel_regularizer=shrinkageParam, kernel_initializer='he_normal'))
if BNEnabled : model.add(BatchNormalization())
addActivation(model,args.hidAct)
if args.dropout != -1 : model.add(Dropout(args.dropout))
print("added layer at depth: " + str(i) + " with width: " + str(lastLayerSize) + " / shrinkage: " + str(shrinkage))
# control the 'fatness' of the network: we reduce the width at a given rate: if this is 1, then at every subsequent layer, if its 2, then every 2nd layer etc
if i % args.widthReductionRate == 0 : lastLayerSize = lastLayerSize // 2
if lastLayerSize < 2 : break # if
#
if hLayerCount == 0 : model.add(Dense(1, kernel_initializer='he_normal',kernel_regularizer=w_reg, input_shape = input_shape))
else : model.add(Dense(1, kernel_initializer='he_normal',kernel_regularizer=shrinkageParam))
if len( y.shape) > 1 : model.add(Activation('softmax'))
# Compile the model.
model.compile(loss=loss, optimizer=optimizer, metrics=[accMetrc])
return(model)
import os
from config import config
from mhd_util import *
from NetModel_conc import *
import matplotlib.pyplot as pl
working_path = "/home/customer/document/lung-nodule-detection/data/"
weights_path = "/home/customer/document/lung-nodule-detection/data/weights/"
output_path = "/home/customer/document/lung-nodule-detection/data/output/"
window=48
out_w=44
height = window
width = window
depth = window
batch_size=1
K.set_image_dim_ordering('th') # Theano dimension ordering in this code
crop_size=2
data_form=np.float32
shape=0
ClassRoot='/home/customer/document/lung-nodule-detection/challenge/ClassTrain/Data/'
if __name__ == '__main__':
model=ClassNet_FlexWindow()
#model36=ClassNet_36()
#model24=ClassNet_24()
#plot(model,to_file='/home/customer/document/lung-nodule-detection/huangyj/ClassModel.png',show_shapes=True)
#plot_model(model,to_file='/home/customer/document/lung-nodule-detection/challenge/ClassTrain/ClassModel48.png',show_shapes=True)
#plot_model(model36,to_file='/home/customer/document/lung-nodule-detection/challenge/ClassTrain/ClassModel36.png',show_shapes=True)
#plot_model(model24,to_file='/home/customer/document/lung-nodule-detection/challenge/ClassTrain/ClassModel24.png',show_shapes=True)
use_existing=True
def alexnet_model(weights_path=None):
"""
Returns a keras model for AlexNet, achieving roughly 80% at ImageNet2012 validation set
Model and weights from
https://github.com/heuritech/convnets-keras/blob/master/convnetskeras/convnets.py
and only slightly modified to work with TF backend
"""
K.set_image_dim_ordering('th')
inputs = Input(shape=(3, 227, 227))
conv_1 = Conv2D(96, 11, strides=4, activation='relu', name='conv_1')(inputs)
conv_2 = MaxPooling2D((3, 3), strides=(2, 2))(conv_1)
conv_2 = cross_channel_normalization(name="convpool_1")(conv_2)
conv_2 = ZeroPadding2D((2, 2))(conv_2)
conv_2 = merge([
Conv2D(128, 5, activation="relu", name='conv_2_' + str(i + 1))
(split_tensor(ratio_split=2, id_split=i)(conv_2)
) for i in range(2)], mode='concat', concat_axis=1, name="conv_2")
conv_3 = MaxPooling2D((3, 3), strides=(2, 2))(conv_2)
conv_3 = cross_channel_normalization()(conv_3)
conv_3 = ZeroPadding2D((1, 1))(conv_3)
conv_3 = Conv2D(384, 3, activation='relu', name='conv_3')(conv_3)
conv_4 = ZeroPadding2D((1, 1))(conv_3)
conv_4 = merge([
Conv2D(192, 3, activation="relu", name='conv_4_' + str(i + 1))(
split_tensor(ratio_split=2, id_split=i)(conv_4)
) for i in range(2)], mode='concat', concat_axis=1, name="conv_4")
conv_5 = ZeroPadding2D((1, 1))(conv_4)
conv_5 = merge([
Conv2D(128, 3, activation="relu", name='conv_5_' + str(i + 1))(
split_tensor(ratio_split=2, id_split=i)(conv_5)
) for i in range(2)], mode='concat', concat_axis=1, name="conv_5")
dense_1 = MaxPooling2D((3, 3), strides=(2, 2), name="convpool_5")(conv_5)
dense_1 = Flatten(name="flatten")(dense_1)
dense_1 = Dense(4096, activation='relu', name='dense_1')(dense_1)
dense_2 = Dropout(0.5)(dense_1)
dense_2 = Dense(4096, activation='relu', name='dense_2')(dense_2)
dense_3 = Dropout(0.5)(dense_2)
dense_3 = Dense(1000, name='dense_3')(dense_3)
prediction = Activation("softmax", name="softmax")(dense_3)
m = Model(input=inputs, output=prediction)
if weights_path is None:
weights_path = 'Data/alexnet_weights.h5'
m.load_weights(weights_path)
# Model was trained using Theano backend
# This changes convolutional kernels from TF to TH, great accuracy improvement
convert_all_kernels_in_model(m)
# sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
# m.compile(optimizer=sgd, loss='mse')
return m
