Beispiel #1
0
def trainModel(train_file, vocab_size):

    train = pd.read_csv(train_file)
    Xs = train.iloc[:, :20]
    Ys = train.iloc[:, 20:]

    xs = np.array(Xs)
    ys = np.array(Ys)

    model = Sequential()
    model.add(Embedding(vocab_size, 10, input_length=20))
    model.add(Bidirectional(LSTM(64)))
    model.add(Dense(10, activation='linear'))

    print("compile..")
    model.compile('adam', 'mse')
    print("tyrain..")
    model.fit(xs, ys)
    print("trained...")

    model.layers.pop()  # Get rid of the classification layer
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []

    predictions = model.predict(
        xs)  # here actually you have the item_doc-2-vec
    print(predictions)
def VGG_celeba(nb_classes, img_dim, pretr_weights_file=None, model_name=None):
    """
    Build Convolution Neural Network

    args : nb_classes (int) number of classes
           img_dim (tuple of int) num_chan, height, width
           pretr_weights_file (str) file holding pre trained weights

    returns : model (keras NN) the Neural Net model
    """

    model = Sequential()
    model.add(Convolution2D(32, 3, 3, name="convolution2d_1", input_shape=(3, 224, 224), border_mode="same", activation='relu'))
    model.add(Convolution2D(32, 3, 3, name="convolution2d_2", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_1"))

    model.add(Convolution2D(64, 3, 3, name="convolution2d_3", border_mode="same", activation='relu'))
    model.add(Convolution2D(64, 3, 3, name="convolution2d_4", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_2"))

    model.add(Convolution2D(128, 3, 3, name="convolution2d_5", border_mode="same", activation='relu'))
    model.add(Convolution2D(128, 3, 3, name="convolution2d_6", border_mode="same", activation='relu'))
    model.add(Convolution2D(128, 3, 3, name="convolution2d_7", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_3"))

    model.add(Convolution2D(256, 3, 3, name="convolution2d_8", border_mode="same", activation='relu'))
    model.add(Convolution2D(256, 3, 3, name="convolution2d_9", border_mode="same", activation='relu'))
    model.add(Convolution2D(256, 3, 3, name="convolution2d_10", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_4"))

    model.add(Convolution2D(512, 3, 3, name="convolution2d_11", border_mode="same", activation='relu'))
    model.add(Convolution2D(512, 3, 3, name="convolution2d_12", border_mode="same", activation='relu'))
    model.add(Convolution2D(512, 3, 3, name="convolution2d_13", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_5"))

    model.add(Flatten(name="flatten_1"))
    model.add(Dense(4096, activation='relu', name="dense_1"))
    model.add(Dropout(0.5, name="dropout_1"))
    model.add(Dense(4096, activation='relu', name="dense_2"))
    model.add(Dropout(0.5, name="dropout_2"))
    model.add(Dense(2, activation='softmax', name="dense_3"))

    if model_name:
        model.name = model_name
    else:
        model.name = "VGG_celeba"

    if pretr_weights_file:
        model.load_weights(pretr_weights_file)
        model.layers.pop()
        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []
        model.add(Dense(nb_classes, activation='softmax', name="dense_4"))

    # Freeze layers until specified number
    # for k in range(freeze_until):
    #     model.layers[k].trainable = True

    return model
Beispiel #3
0
def vgg_std16_model(img_rows, img_cols, color_type=1):
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(color_type,
                                                 img_rows, img_cols)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(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))
    model.add(Dense(1000, activation='softmax'))

    model.load_weights('../input/vgg16_weights.h5')

    # Code above loads pre-trained data and
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(10, activation='softmax'))
    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd, loss='categorical_crossentropy')
    return model
Beispiel #4
0
def VGG_16(weights_path=None):
    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))
    model.add(Dense(1000, activation='softmax'))

    if weights_path:
        model.load_weights(weights_path)

    # uncomment the following two lines to remove the top 2 layers for feature extraction
    model.layers.pop()
    model.layers.pop()

    # Keras's bug, the modify based on (https://github.com/keras-team/keras/issues/2371)
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []

    return model
Beispiel #5
0
def VGG_16_Terrassa(weights_path=""):
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(3, 224, 224)))
    model.add(Convolution2D(64, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu', trainable=False))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu', trainable=False))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', trainable=False))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(Flatten())
    model.add(Dense(4096, activation='relu', trainable=False))
    model.add(Dropout(0.5))
    model.add(Dense(4096, activation='relu', trainable=False))
    model.add(Dropout(0.5))
    model.add(Dense(1000, activation='softmax'))

    if weights_path:
        print("Weights Loaded")
        model.load_weights(weights_path)

    model.layers.pop()
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(13, activation='softmax'))

    return model
Beispiel #6
0
def VGG_16_Terrassa(weights_path=""):
	model = Sequential()
	model.add(ZeroPadding2D((1,1),input_shape=(3,224,224)))
	model.add(Convolution2D(64, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(64, 3, 3, activation='relu',trainable = False))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(128, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(128, 3, 3, activation='relu',trainable = False))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu',trainable = False))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu',trainable = False))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu',trainable = False))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu',trainable = False))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(Flatten())
	model.add(Dense(4096, activation='relu',trainable = False))
	model.add(Dropout(0.5))
	model.add(Dense(4096, activation='relu',trainable = False))
	model.add(Dropout(0.5))
	model.add(Dense(1000, activation='softmax'))

	if weights_path:
		print ("Weights Loaded")
		model.load_weights(weights_path)

	model.layers.pop()
	model.layers.pop()
	model.outputs = [model.layers[-1].output]
	model.layers[-1].outbound_nodes = []
	model.add(Dense(13, activation='softmax'))

	return model
Beispiel #7
0
def VGG_16(weights_path=None):
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(3, 224, 224)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(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))
    model.add(Dense(1000, activation='softmax'))

    if weights_path:
        model.load_weights(weights_path)

    #Remove the last two layers to get the 4096D activations
    model.layers.pop()
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    return model
def CNN(nb_classes, img_dim, pretr_weights_file=None, model_name=None):
    """
    Build Convolution Neural Network

    args : nb_classes (int) number of classes
           img_dim (tuple of int) num_chan, height, width

    returns : model (keras NN) the Neural Net model
    """

    model = Sequential()
    model.add(Convolution2D(32, 3, 3, name="convolution2d_1", input_shape=(3, 224, 224), border_mode="same", activation='relu'))
    model.add(Convolution2D(32, 3, 3, name="convolution2d_2", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_1"))

    model.add(Convolution2D(64, 3, 3, name="convolution2d_3", border_mode="same", activation='relu'))
    model.add(Convolution2D(64, 3, 3, name="convolution2d_4", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_2"))

    model.add(Convolution2D(128, 3, 3, name="convolution2d_5", border_mode="same", activation='relu'))
    model.add(Convolution2D(128, 3, 3, name="convolution2d_6", border_mode="same", activation='relu'))
    model.add(Convolution2D(128, 3, 3, name="convolution2d_7", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_3"))

    # model.add(Convolution2D(256, 3, 3, name="convolution2d_8", border_mode="same", activation='relu'))
    # model.add(Convolution2D(256, 3, 3, name="convolution2d_9", border_mode="same", activation='relu'))
    # model.add(Convolution2D(256, 3, 3, name="convolution2d_10", border_mode="same", activation='relu'))
    # model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_4"))

    # model.add(Convolution2D(512, 3, 3, name="convolution2d_11", border_mode="same", activation='relu'))
    # model.add(Convolution2D(512, 3, 3, name="convolution2d_12", border_mode="same", activation='relu'))
    # model.add(Convolution2D(512, 3, 3, name="convolution2d_13", border_mode="same", activation='relu'))
    # model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_5"))

    model.add(Flatten(name="flatten_1"))
    model.add(Dense(1024, activation='relu', name="dense_1"))
    model.add(Dropout(0.5, name="dropout_1"))
    model.add(Dense(1024, activation='relu', name="dense_2"))
    model.add(Dropout(0.5, name="dropout_2"))
    model.add(Dense(nb_classes, activation='softmax', name="dense_3"))

    if model_name:
        model.name = model_name
    else:
        model.name = "CNN"

    if pretr_weights_file:
        model.load_weights(pretr_weights_file)
        model.layers.pop()
        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []
        model.add(Dense(nb_classes, activation='softmax', name="dense_4"))

    return model
Beispiel #9
0
def CNN(nb_classes, img_dim, pretr_weights_file=None, model_name=None):
    """
    Build Convolution Neural Network

    args : nb_classes (int) number of classes
           img_dim (tuple of int) num_chan, height, width

    returns : model (keras NN) the Neural Net model
    """

    model = Sequential()
    model.add(Convolution2D(32, 3, 3, name="convolution2d_1", input_shape=(3, 224, 224), border_mode="same", activation='relu'))
    model.add(Convolution2D(32, 3, 3, name="convolution2d_2", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_1"))

    model.add(Convolution2D(64, 3, 3, name="convolution2d_3", border_mode="same", activation='relu'))
    model.add(Convolution2D(64, 3, 3, name="convolution2d_4", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_2"))

    model.add(Convolution2D(128, 3, 3, name="convolution2d_5", border_mode="same", activation='relu'))
    model.add(Convolution2D(128, 3, 3, name="convolution2d_6", border_mode="same", activation='relu'))
    model.add(Convolution2D(128, 3, 3, name="convolution2d_7", border_mode="same", activation='relu'))
    model.add(MaxPooling2D((2,2), strides=(2, 2), name="maxpooling2d_3"))

    model.add(Flatten(name="flatten_1"))
    model.add(Dense(1024, activation='relu', name="dense_1"))
    model.add(Dropout(0.5, name="dropout_1"))
    model.add(Dense(1024, activation='relu', name="dense_2"))
    model.add(Dropout(0.5, name="dropout_2"))
    model.add(Dense(nb_classes, activation='softmax', name="dense_3"))

    if model_name:
        model.name = model_name
    else:
        model.name = "CNN"

    if pretr_weights_file:
        model.load_weights(pretr_weights_file)
        model.layers.pop()
        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []
        model.add(Dense(nb_classes, activation='softmax', name="dense_4"))

    return model
Beispiel #10
0
def larger_model():
    # create model
    model = Sequential()
    model.add(Conv2D(64, (3, 3), input_shape=(48, 48, 1),
                     trainable=train[0]))  #64,100
    model.add(Activation('relu'))
    BatchNormalization(
        axis=-1
    )  # https://yashk2810.github.io/Applying-Convolutional-Neural-Network-on-the-MNIST-dataset/
    model.add(Conv2D(64, (3, 3), trainable=train[1]))  #64,100
    model.add(Activation('tanh'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    BatchNormalization(axis=-1)
    model.add(Conv2D(128, (2, 2), trainable=train[2]))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Flatten())
    BatchNormalization()
    model.add(Dense(100, trainable=train[3]))
    model.add(Activation('tanh'))
    BatchNormalization()
    model.add(Dropout(0.25))
    model.add(Dense(50, trainable=train[4]))
    model.add(Activation('relu'))
    model.add(Dense(10))
    model.add(Activation('tanh'))
    model.add(Dense(7))
    model.add(Activation('softmax'))
    if pre_tra == 'Y':
        model.load_weights(
            '/home/AN35190/fer+/fer+_data/data_48x48/best/best.hdf5')
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(1, activation=last))
    # Compile model
    optimizer = Adam(lr=ler)
    model.compile(loss='mse', optimizer=optimizer, metrics=['mse'])
    return model
Beispiel #11
0
def vgg19_model(img_rows, img_cols, channel=1, num_classes=None):
    """
    VGG 19 Model for Keras
    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/8d096f48a1be4a2d660d
    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilZ2RVeVhKY0FyRmc/view?usp=sharing
    #Arguments
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of class labels for our classification task
     # Returns
        A Keras model instance.
    """

    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(channel, img_rows, img_cols)))
    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(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(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(ZeroPadding2D((1, 1)))
    model.add(Conv2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    #the weights file should be downloaded from https://github.com/fchollet/deep-learning-models/releases
    model.load_weights(
        'model_weights/vgg19_weights_tf_dim_ordering_tf_kernels.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Defines the metrics for calculating top3 accuracy
    from keras.metrics import top_k_categorical_accuracy

    def top_3_categorical_accuracy(y_true, y_pred):
        return top_k_categorical_accuracy(y_true, y_pred, k=3)

    # Compiles the model with stochastic gradient descent
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy', top_3_categorical_accuracy])

    #Model overview
    model.summary()
    model.get_config()

    return model
Beispiel #12
0
def model_vgg16_google(datashape=(32, 32, 3), num_classes=10, path=None):

    # img_rows, img_cols, channel=1, num_classes=None):
    """VGG 16 Model for Keras

    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3

    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of categories for our classification task
    """

    model = Sequential()
    model.add(layers.ZeroPadding2D((1, 1), input_shape=datashape))
    model.add(layers.Conv2D(64, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(64, (3, 3), activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(128, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(128, (3, 3), activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, (3, 3), activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, (3, 3), activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, (3, 3), activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, (3, 3), activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    model.add(layers.Flatten())
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(1000, activation='softmax'))

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(layers.Dense(num_classes, activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    #for layer in model.layers[:10]:
    #    layer.trainable = False

    if path != None:
        # Loads ImageNet pre-trained data
        model.load_weights(path)

    return model
Beispiel #13
0
def make_model(rows , cols , learning_rate = 1e-3):

    
    nb_filters = 32
    nb_pool = 2
    nb_conv = 3
    


    
    #make model
    model = Sequential()
    #Layer1 shape : (? ,129 ,126 , 1)
    #model.add(ZeroPadding2D( (1,1) ))
    model.add(Conv2D(nb_filters,(nb_conv,nb_conv),padding = 'same' , activation = 'relu' , input_shape = (129,126,1) ))
    #want use leaky relu
    
    model.add(MaxPooling2D(pool_size = (nb_pool,nb_pool) ))
    model.add(Dropout(0.25))
    '''
    #Layer2 shape : (? , , , )
    model.add(Conv2D(nb_filters, (nb_conv, nb_conv) , activation = 'relu'))
    #batch nomaliztion
    model.add(MaxPooling2D(pool_size = (nb_pool,nb_pool) ))
    model.add(Dropout(0.25))
    
    #Layer3 shape : (? , , , )
    model.add(Conv2D(nb_filters, (nb_conv, nb_conv) , activation = 'relu'))
    #batch nomaliztion
    model.add(MaxPooling2D(pool_size = (nb_pool,nb_pool) ))
    model.add(Dropout(0.25))
    model.add(Flatten())
    
    #Final shape : (? , , , )
    model.add(Conv2D(nb_filters, (nb_conv, nb_conv) , activation = 'relu'))
    #batch nomaliztion
    model.add(MaxPooling2D(pool_size = (nb_pool,nb_pool) ))
    model.add(Dropout(0.25))
    model.add(Flatten())
    '''
    
    #Add Fully Connected Layer
    
    #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))
    #model.add(Dense(1000, activation='softmax'))
    
    #load imagenet pre=trained data
    #model.load_weights('')
    
    #truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(1000, activation='softmax'))
    
    adam = Adam(lr=learning_rate)
    model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])
    
    return model
	model.add(BatchNormalization())
	model.add(Activation('relu'))
	model.add(Dropout(0.5))
	model.add(Dense(nb_classes))
	model.add(BatchNormalization())
	model.add(Activation('softmax'))


if(LOAD_WEIGHTS):
	model.load_weights("models_trained/cifar10_cnn_v1_batch/weigths/cifar10_cnn_v1_batch_weights_epoch20.h5")
	print("Loaded model from disk: "+weights_path_to_load + model_name_to_load+"_weights_epoch20.h5")

model.layers.pop()
model.layers.pop()
model.layers.pop()
model.outputs = [model.layers[-1].output]
model.layers[-1].outbound_nodes = []
model.add(Dense(13))
model.add(BatchNormalization())
model.add(Activation('softmax'))


model.summary()

# Train the model using SGD + momentum 
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
			  optimizer=sgd,
			  metrics=['accuracy'])

# Save model architecture
Beispiel #15
0
def vgg19_model(img_rows,
                img_cols,
                channel=1,
                num_classes=None,
                model_path="../imagenet_models/"):
    """
    VGG 19 Model for Keras

    Model Schema is based on
    https://gist.github.com/baraldilorenzo/8d096f48a1be4a2d660d

    ImageNet Pretrained Weights
    https://drive.google.com/file/d/0Bz7KyqmuGsilZ2RVeVhKY0FyRmc/view?usp=sharing

    @param img_rows: Rows in input.
    @param img_cols: Columns in input.
    @param channel: 1 for grayscale, 3 for color.
    @param num_classes: Number of class labels for our classification task.
    @param model_path: Path containing the ImageNet model.

    @return: Model object.
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(channel, img_rows, img_cols)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    model.add(Flatten())
    model.add(Dense(4096, activation='relu'))
    model.add(Dropout(0.7))  # Originally 0.5
    model.add(Dense(4096, activation='relu'))
    model.add(Dropout(0.7))  # Originally 0.5
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights(model_path + 'vgg19_weights.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy', 'top_k_categorical_accuracy'])

    return model
def C3D_model():
    model = Sequential()

    #1st group
    model.add(
        Convolution3D(64,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv1',
                      subsample=(1, 1, 1),
                      input_shape=(3, 16, 112, 112),
                      trainable=False))
    model.add(
        MaxPooling3D(pool_size=(1, 2, 2),
                     strides=(1, 2, 2),
                     border_mode='valid',
                     name='pool1'))

    #2nd group
    model.add(
        Convolution3D(128,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv2',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(
        MaxPooling3D(pool_size=(2, 2, 2),
                     strides=(2, 2, 2),
                     border_mode='valid',
                     name='pool2'))

    #3rd group
    model.add(
        Convolution3D(256,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv3a',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(
        Convolution3D(256,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv3b',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(
        MaxPooling3D(pool_size=(2, 2, 2),
                     strides=(2, 2, 2),
                     border_mode='valid',
                     name='pool3'))

    #4th group
    model.add(
        Convolution3D(512,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv4a',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(
        Convolution3D(512,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv4b',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(
        MaxPooling3D(pool_size=(2, 2, 2),
                     strides=(2, 2, 2),
                     border_mode='valid',
                     name='pool4'))

    #5th group
    model.add(
        Convolution3D(512,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv5a',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(
        Convolution3D(512,
                      3,
                      3,
                      3,
                      activation='relu',
                      border_mode='same',
                      name='conv5b',
                      subsample=(1, 1, 1),
                      trainable=False))
    model.add(ZeroPadding3D(padding=(0, 1, 1), name='zeropadding'))
    model.add(
        MaxPooling3D(pool_size=(2, 2, 2),
                     strides=(2, 2, 2),
                     border_mode='valid',
                     name='pool5'))
    model.add(Flatten(name='flatten'))

    #FC group
    model.add(Dense(4096, activation='relu', name='fc6', trainable=False))
    model.add(Dropout(0.5, name='do1'))
    model.add(Dense(4096, activation='relu', name='fc7'))
    model.add(Dropout(0.5, name='do2'))
    model.add(Dense(487, activation='softmax', name='fc8'))

    model.load_weights('data/c3d-sports1M_weights.h5')

    #pop the last 4 layers of the model
    for _ in range(0, 4):
        model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []

    return model
Beispiel #17
0
def VGG_16():
	weights_path = '/home/nishant/Documents/Academics/CS676A/project/cs676project/code/models2/CNN/vgg16_weights.h5'

	from keras.models import Sequential
	from keras.layers.core import Flatten, Dense, Dropout
	from keras.layers.convolutional import Convolution2D, MaxPooling2D, ZeroPadding2D

	model = Sequential()
	model.add(ZeroPadding2D((1,1),input_shape=(3,224,224)))
	model.add(Convolution2D(64, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(64, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(128, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(128, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(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))
	model.add(Dense(1000, activation='softmax'))

	if weights_path:
		model.load_weights(weights_path)

	#Remove the last two layers to get the 4096D activations
	model.layers.pop()
	model.layers.pop()

	# Fix required for the output to be 4096D in newer versions of keras
	model.outputs = [model.layers[-1].output]
	model.layers[-1].outbound_nodes = []

	print 'VGG Model loading complete!'

	return model
Beispiel #18
0
def VGG(nb_classes, img_dim, pretr_weights_file=None, model_name=None):
    """
    Build Convolution Neural Network

    args : nb_classes (int) number of classes
           img_dim (tuple of int) num_chan, height, width
           pretr_weights_file (str) file holding pre trained weights

    returns : model (keras NN) the Neural Net model
    """

    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=img_dim, name="zeropadding2d_1"))
    model.add(Convolution2D(64, 3, 3, activation='relu', name="convolution2d_1"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_2"))
    model.add(Convolution2D(64, 3, 3, activation='relu', name="convolution2d_2"))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_1"))

    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_3"))
    model.add(Convolution2D(128, 3, 3, activation='relu', name="convolution2d_3"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_4"))
    model.add(Convolution2D(128, 3, 3, activation='relu', name="convolution2d_4"))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_2"))

    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_5"))
    model.add(Convolution2D(256, 3, 3, activation='relu', name="convolution2d_5"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_6"))
    model.add(Convolution2D(256, 3, 3, activation='relu', name="convolution2d_6"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_7"))
    model.add(Convolution2D(256, 3, 3, activation='relu', name="convolution2d_7"))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_3"))

    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_8"))
    model.add(Convolution2D(512, 3, 3, activation='relu', name="convolution2d_8"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_9"))
    model.add(Convolution2D(512, 3, 3, activation='relu', name="convolution2d_9"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_10"))
    model.add(Convolution2D(512, 3, 3, activation='relu', name="convolution2d_10"))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_4"))

    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_11"))
    model.add(Convolution2D(512, 3, 3, activation='relu', name="convolution2d_11"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_12"))
    model.add(Convolution2D(512, 3, 3, activation='relu', name="convolution2d_12"))
    model.add(ZeroPadding2D((1, 1), name="zeropadding2d_13"))
    model.add(Convolution2D(512, 3, 3, activation='relu', name="convolution2d_13"))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), name="maxpooling2d_5"))

    model.add(Flatten(name="flatten_1"))
    model.add(Dense(4096, activation='relu', name="dense_1"))
    model.add(Dropout(0.5, name="dropout_1"))
    model.add(Dense(4096, activation='relu', name="dense_2"))
    model.add(Dropout(0.5, name="dropout_2"))
    model.add(Dense(1000, activation='softmax', name="dense_3"))

    if model_name:
        model.name = model_name
    else:
        model.name = "VGG"

    if pretr_weights_file:
        model.load_weights(pretr_weights_file)
        model.layers.pop()
        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []
        model.add(Dense(nb_classes, activation='softmax', name="dense_4"))

    # Freeze layers until specified number
    # for k in range(freeze_until):
    #     model.layers[k].trainable = True

    return model
def vgg_std16_model():
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(3, 224, 224)))    # don't change unless you know what you are doing
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(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))
    model.add(Dense(1000, activation='softmax'))

    model.load_weights('vgg16_weights.h5')
    print "Model Loaded!"

    # Code above loads pre-trained data and
    # old
    # model.layers.pop()
    # model.add(Dense(10, activation='softmax'))
    # Learning rate is changed to 0.001

    # new
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(10, activation='softmax'))

    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd, metrics=['accuracy'], loss='categorical_crossentropy')
    return model
Beispiel #20
0
def vgg16_model(input_shape, output_shape, params,filew,patch_dir_store,numbits):
    num_class=output_shape[-1]
    dimpx=input_shape[-1]
    INP_SHAPE = (numbits, dimpx, dimpx)
    dim_org=keras.backend.image_data_format()
    """VGG 16 Model for Keras

    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3

    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of categories for our classification task
    """
    padding='same'
    kernel_size=(3,3)
    model = Sequential()
    model.add(Conv2D(64, kernel_size, activation='relu', padding=padding , data_format=dim_org,input_shape=INP_SHAPE))
    model.add(Conv2D(64, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(MaxPooling2D((2,2), strides=(2,2),data_format=dim_org))
    
    model.add(Conv2D(128, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(Conv2D(128, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(MaxPooling2D((2,2), strides=(2,2),data_format=dim_org))
    
    model.add(Conv2D(256, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(Conv2D(256, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(MaxPooling2D((2,2), strides=(2,2),data_format=dim_org))
    
    model.add(Conv2D(512, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(Conv2D(512, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(Conv2D(512, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(MaxPooling2D((2,2), strides=(2,2),data_format=dim_org))
    
    model.add(Conv2D(512, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(Conv2D(512, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
    model.add(Conv2D(512, kernel_size, activation='relu', padding=padding,data_format=dim_org ))
#    model.add(MaxPooling2D((2,2), strides=(2,2),data_format=dim_org))
    model.add(AveragePooling2D(pool_size=(2,2),data_format=dim_org))
#    
    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights('vgg16_weights.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_class, activation='softmax'))

    for layer in model.layers[:-5]:
        layer.trainable = False

    model.compile(optimizer=Adam(lr=learning_rate), loss='categorical_crossentropy', metrics=['categorical_accuracy'])
    filew.write ('learning rate:'+str(learning_rate)+'\n')
    print ('learning rate:'+str(learning_rate))
    json_string = model.to_json()
    pickle.dump(json_string, open(os.path.join(patch_dir_store,modelname), "wb"),protocol=-1)
    orig_stdout = sys.stdout
    f = open(os.path.join(patch_dir_store,'modelvgg16.txt'), 'w')
    sys.stdout = f
    print(model.summary())
    sys.stdout = orig_stdout
    f.close()
    print model.layers[-1].output_shape #== (None, 16, 16, 21)

    return model
def vgg16_model(img_rows, img_cols, channel=1, num_classes=None):
    """VGG 16 Model for Keras

    ImageNet Pretrained Weights
    
    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color
      num_classes - number of categories for our classification task
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(channel, 224, 224)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights(
        '/imagenet_models_weights/vgg16_weights_th_dim_ordering_th_kernels.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    #    for layer in model.layers[:10]:
    #        layer.trainable = False

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    return model
Beispiel #22
0
def VGG_16(weights_path=None):
	#weights_path = '/home/nishant/Documents/Academics/CS676A/project/cs676project/code/models2/CNN/vgg16_weights.h5'
	from keras.models import Sequential
	from keras.layers.core import Flatten, Dense, Dropout
	from keras.layers.convolutional import Convolution2D, MaxPooling2D, ZeroPadding2D

	model = Sequential()
    #注意,TensorFlow的input_shape形式是宽高、滤子个数
	model.add(ZeroPadding2D((1,1),input_shape=(224,224,3)))
	model.add(Convolution2D(64, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(64, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(128, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(128, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(256, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(MaxPooling2D((2,2), strides=(2,2)))

	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(512, 3, 3, activation='relu'))
	model.add(ZeroPadding2D((1,1)))
	model.add(Convolution2D(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))
	model.add(Dense(1000, activation='softmax'))

	if weights_path:
		model.load_weights(weights_path)

	#Remove the last two layers to get the 4096D activations
	model.layers.pop()
	model.layers.pop()

	# Fix required for the output to be 4096D in newer versions of keras
	model.outputs = [model.layers[-1].output]
	model.layers[-1].outbound_nodes = []

	print( 'VGG Model loading complete!')

	return model
Beispiel #23
0
def vgg16_model(img_rows, img_cols, channel=1, num_classes=None):
    """
    Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing
    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of categories for our classification task
    """

    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(channel, img_rows, img_cols)))
    model.add(Convolution2D(64, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), dim_ordering='th'))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), dim_ordering='th'))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), dim_ordering='th'))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), dim_ordering='th'))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), dim_ordering='th'))

    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights(
        '/home/rick/derma/vgg16_weights_th_dim_ordering_th_kernels.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    return model
Beispiel #24
0
    def createVGG16(self, first=False):
        '''
        THIS FUNCTION CREATES THE VGG16 MODEL
        :param first: ONLY TRUE FOR THE FIRST TIME TO SAVE VGG16 WEIGHTS
        :return: CNN MODEL
        '''
        if(first):
            model = VGG16()
            model.save_weights('VGG16.h5')

        model = Sequential()
        #model.add(ZeroPadding2D((1, 1), input_shape=(224, 224, 3)))
        model.add(Convolution2D(64, 3, 3, activation='relu', input_shape=(224,224,3), trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(64, 3, 3, activation='relu', trainable=False))
        model.add(MaxPooling2D((2, 2), strides=(2, 2), trainable=False))

        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(128, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(128, 3, 3, activation='relu', trainable=False))
        model.add(MaxPooling2D((2, 2), strides=(2, 2)))

        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(256, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(256, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(256, 3, 3, activation='relu', trainable=False))
        model.add(MaxPooling2D((2, 2), strides=(2, 2), trainable=False))

        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
        model.add(MaxPooling2D((2, 2), strides=(2, 2), trainable=False))

        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
        #model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu', trainable=False))
        model.add(MaxPooling2D((2, 2), strides=(2, 2), trainable=False))

        model.add(Flatten(trainable=False))
        model.add(Dense(4096, activation='relu', trainable=False))
       # model.add(Dropout(0.5))
        model.add(Dense(4096, activation='relu', trainable=True))
       # model.add(Dropout(0.5))
        #model.add(Dense(1000, activation='softmax'))

        model.load_weights('VGG16.h5', by_name=True)
        model.layers.pop()
        model.layers.pop()
        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []
        plot(model, to_file='model2.png')
        return model
Beispiel #25
0
def vgg_std16_model(img_rows, img_cols):
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(3,
                                                 img_rows, img_cols)))

    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(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))
    model.add(Dense(1000, activation='softmax'))
    model.load_weights('../../models/vgg16_weights.h5')

    model.layers.pop()
    model.layers.pop()
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(10, activation='softmax'))

    # model.layers.pop() # Get rid of the classification layer
    # model.layers.pop() # Get rid of the dropout layer
    # model.outputs = [model.layers[-1].output]
    # model.layers[-1].outbound_nodes = []

    # for layer in model.layers[:-4]:
    #     layer.trainable = False

    # model.add(Dropout(0.5))

    # model.add(Dense(10, activation='softmax'))

    adam = Adam(lr=1e-5, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
    # Learning rate is changed to 0.001

    # sgd = SGD(lr=1e-5, decay=0, momentum=0, nesterov=False)

    model.compile(optimizer=adam,
    	loss='categorical_crossentropy',
    	metrics=['accuracy'])
    return model
Beispiel #26
0
def vgg16_model(img_rows, img_cols, channel=3, num_classes=None):
    """VGG 16 Model for Keras
    Model Schema is based on
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3
    ImageNet Pretrained Weights
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing
    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color
      num_classes - number of categories for our classification task
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(1, 28, 28)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))
    #model.load_weights('emnist/vgg16_weights.h5')

    weights_path = 'emnist/vgg16_weights.h5'
    f = h5py.File(weights_path)
    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'])
        ]
        layer = model.layers[k]
        if isinstance(layer, Convolution2D):
            weights[0] = np.transpose(
                np.array(weights[0])[:, :, ::-1, ::-1], (2, 3, 1, 0))
        layer.set_weights(weights)
    f.close()
    print('Model loaded.')

    # Add Fully Connected Layer
    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))
    model.add(Dense(10, activation='softmax'))

    # Loads ImageNet pre-trained data

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    #for layer in model.layers[:10]:
    #    layer.trainable = False

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    return model
def vgg16_regression_model(img_rows, img_cols, channel=1, num_classes=None):
    """VGG 16 Regression Model for Keras

    Model Schema is based on
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3

    ImageNet Pretrained Weights
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color
      num_classes - number of categories for our classification/regression task
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(img_rows, img_cols, channel)))
    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)))

    # Add Fully Connected Layer
    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))
    model.add(Dense(
        1000, activation='softmax'))  # For Imagenet 1000 item classification

    # Loads ImageNet pre-trained data
    model.load_weights(
        'imagenet_models/vgg16_weights_tf_dim_ordering_tf_kernels.h5')

    # Truncate and replace softmax layer with a normal Dense layer without softmax activation
    # to allow for regressional training
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes))

    for i in range(5):
        model.layers.pop()

    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []

    # Uncomment below to set the dense layers and last conv block to be fine tunable
    #for layer in model.layers[:-13]:
    #layer.trainable = False

    model.compile(
        optimizer='adam',
        loss='mean_squared_error',
        metrics=['mean_absolute_error', 'mean_absolute_percentage_error'])

    return model
Beispiel #28
0
def vgg16_model(img_rows, img_cols, channel=1, num_classes=None):
    """VGG 16 Model for Keras

    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3

    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of categories for our classification task
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(channel, img_rows, img_cols)))
    model.add(Convolution2D(64, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), data_format="channels_first"))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), data_format="channels_first"))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), data_format="channels_first"))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), data_format="channels_first"))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2), data_format="channels_first"))

    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights('imagenet_models/vgg16_weights.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    for layer in model.layers[:10]:
        layer.trainable = False

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])

    return model
Beispiel #29
0
    def _build_base_model(self):
        model = Sequential()

        # section 1

        model.add(
            Convolution2D(filters=32,
                          kernel_size=5,
                          strides=2,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal",
                          input_shape=(self.n_frames, self.n_bands,
                                       self.n_channels)))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(
            Convolution2D(filters=32,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(MaxPooling2D(pool_size=(2, 2)))

        model.add(Dropout(0.3))

        # section 2
        model.add(
            Convolution2D(filters=64,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(
            Convolution2D(filters=64,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.3))

        # section 3
        model.add(
            Convolution2D(filters=128,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(
            Convolution2D(filters=128,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(
            Convolution2D(filters=128,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(
            Convolution2D(filters=128,
                          kernel_size=3,
                          strides=1,
                          padding="same",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.3))

        # section 4
        model.add(
            Convolution2D(filters=512,
                          kernel_size=3,
                          strides=1,
                          padding="valid",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))
        model.add(Dropout(0.5))

        model.add(
            Convolution2D(filters=512,
                          kernel_size=1,
                          strides=1,
                          padding="valid",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))
        model.add(Dropout(0.5))

        # section 5
        model.add(
            Convolution2D(filters=10,
                          kernel_size=1,
                          strides=1,
                          padding="valid",
                          kernel_regularizer=l2(0.0001),
                          kernel_initializer="normal"))
        model.add(BatchNormalization())
        model.add(Activation('relu'))
        model.add(GlobalAveragePooling2D())

        model.add(Activation('softmax'))

        # load the saved checkpoint weights
        # model.load_weights('/Users/nbip/proj/dtu/dtu-bach/dev/sound_classification_weights.hdf5')
        model.load_weights(self.weights_path)

        # pop the top layers?
        # Try to remove a different number of layers. Removing 2 seems to work okay
        # Previous one was model.layers.pop() which did not work
        for _ in range(2):
            model.pop()

        # needed fix, to have an output of the model
        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []

        return model
Beispiel #30
0
# Add Fully Connected Layer
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))
model.add(Dense(1000, activation='softmax'))

# Loads ImageNet pre-trained data
model.load_weights(
    './imagenet_models/vgg16_weights_tf_dim_ordering_tf_kernels.h5')

# Truncate and replace softmax layer for transfer learning
model.layers.pop()
model.outputs = [model.layers[-1].output]
model.layers[-1].outbound_nodes = []
model.add(Dense(num_classes, activation='softmax'))

# Load weights after first 100 epoch
# model.load_weights('first_try.h5')
sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer='adadelta',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# 进行数据增强用于更好的训练模型
train_datagen = ImageDataGenerator(rescale=1. / 255,
                                   shear_range=0.2,
                                   zoom_range=0.2,
                                   horizontal_flip=True)
def vgg_std16_model(config):
    """
    VGG 16 Model for Keras

    Model Schema is based on
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3

    ImageNet Pretrained Weights
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color
      num_class - number of class labels for our classification task
    """
    feature_layers = [
        ZeroPadding2D((1, 1),
                      input_shape=(config['n_channel'], config['n_rows'],
                                   config['n_cols'])),
        Convolution2D(64, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(64, 3, 3, activation='relu'),
        MaxPooling2D((2, 2), strides=(2, 2)),
        ZeroPadding2D((1, 1)),
        Convolution2D(128, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(128, 3, 3, activation='relu'),
        MaxPooling2D((2, 2), strides=(2, 2)),
        ZeroPadding2D((1, 1)),
        Convolution2D(256, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(256, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(256, 3, 3, activation='relu'),
        MaxPooling2D((2, 2), strides=(2, 2)),
        ZeroPadding2D((1, 1)),
        Convolution2D(512, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(512, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(512, 3, 3, activation='relu'),
        MaxPooling2D((2, 2), strides=(2, 2)),
        ZeroPadding2D((1, 1)),
        Convolution2D(512, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(512, 3, 3, activation='relu'),
        ZeroPadding2D((1, 1)),
        Convolution2D(512, 3, 3, activation='relu'),
        MaxPooling2D((2, 2), strides=(2, 2))
    ]
    classification_layers = [
        Flatten(),
        Dense(4096, activation='relu'),
        Dropout(0.5),
        Dense(4096, activation='relu'),
        Dropout(0.5),
        Dense(1000, activation='softmax')
    ]

    model = Sequential()
    for l in feature_layers + classification_layers:
        model.add(l)
    for l in feature_layers:
        l.trainable = False
    # Loads ImageNet pre-trained data
    model.load_weights(config['pre_weight_path'])

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(config['n_class'], activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    #for layer in model.layers[:10]:
    #    layer.trainable = False

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    return model
Beispiel #32
0
def VGG_19(weights_path=None,heatmap=False, classes=1000):
    model = Sequential()

    if heatmap:
        model.add(ZeroPadding2D((1,1),input_shape=(3,None,None)))
    else:
        model.add(ZeroPadding2D((1,1),input_shape=(3,224,224)))
    model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_4'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_2'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_3'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_4'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_2'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_3'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_4'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(Flatten())
    model.add(Dense(4096, activation='relu', name='dense_1'))
    model.add(Dropout(0.5))
    model.add(Dense(4096, activation='relu', name='dense_2'))
    model.add(Dropout(0.5))
    model.add(Dense(1000, name='dense_3'))
    model.add(Activation("softmax"))

    if weights_path:
        model.load_weights(weights_path)


   # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-4, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])


    return model
elif weight_type == 'ft':
    num_classes = 9
    base_model = ResNet50
    base_model = base_model(weights='imagenet', include_top=False)

    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    x = Dense(1024, activation='relu')(x)
    predictions = Dense(num_classes, activation='softmax')(x)

    clustering_model = Model(inputs=base_model.input, outputs=predictions)
    clustering_model.load_weights(fine_tuned_resnet_weight_path)

    clustering_model.layers.pop()
    clustering_model.layers.pop()
    clustering_model.outputs = [clustering_model.layers[-1].output]
    clustering_model.layers[-1].outbound_nodes = []

    clustering_model.layers[0].trainable = False

clustering_model.compile(optimizer='sgd',
                         loss='categorical_crossentropy',
                         metrics=['accuracy'])

rows = []
all_paths = []

with open(imgs_path) as csv_file:
    paths = csv.reader(csv_file, delimiter=',')
    ## all of the paths in the given file should be separated by ,
    ##so that the endresult for paths after the for loop would be
Beispiel #34
0
def VGG_16(weights_path=None, heatmap=False, classes=1000):
    model = Sequential()
    if heatmap:
        model.add(ZeroPadding2D((1,1),input_shape=(3,None,None)))
    else:
        model.add(ZeroPadding2D((1,1),input_shape=(3,224,224)))
    model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_2'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_3'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_1'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_2'))
    model.add(ZeroPadding2D((1,1)))
    model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_3'))
    model.add(MaxPooling2D((2,2), strides=(2,2)))

    if heatmap:
        model.add(Convolution2D(4096,7,7,activation="relu",name="dense_1"))
        model.add(Convolution2D(4096,1,1,activation="relu",name="dense_2"))
        model.add(Convolution2D(1000,1,1,name="dense_3"))
        model.add(Softmax4D(axis=1,name="softmax"))
    else:
        model.add(Flatten(name="flatten"))
        model.add(Dense(4096, activation='relu', name='dense_1'))
        model.add(Dropout(0.5))
        model.add(Dense(4096, activation='relu', name='dense_2'))
        model.add(Dropout(0.5))
        model.add(Dense(1000, name='dense_3'))
        model.add(Activation("softmax",name="softmax"))

    if weights_path:
        model.load_weights(weights_path)


    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    #for layer in model.layers[:10]:
    #    layer.trainable = False

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])

    return model



    return model
Beispiel #35
0
def vgg16_model(img_rows, img_cols, channel=1, num_classes=None):
    """VGG 16 Model for Keras

    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3

    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of categories for our classification task
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(channel, img_rows, img_cols)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights('imagenet_models/vgg16_weights.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Uncomment below to set the first 10 layers to non-trainable (weights will not be updated)
    #for layer in model.layers[:10]:
    #    layer.trainable = False

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy'])

    return model
def compute_and_return(img_path):
    img_width, img_height = 64, 64
    num_classes = 900

    if K.image_data_format() == 'channels_first':
        input_shape = (3, img_width, img_height)
    else:
        input_shape = (img_width, img_height, 3)

    # 搭建模型
    model = Sequential()
    model.add(Conv2D(64, (3, 3), input_shape=input_shape))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

    model.add(Conv2D(64, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

    model.add(Conv2D(128, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

    model.add(Conv2D(256, (3, 3)))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))

    model.add(Flatten())
    model.add(Dense(1024))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(num_classes, activation='softmax'))

    # 加载训练好的权重
    model.load_weights('third_try.h5')

    # 因为需要取倒数第二层的输出为检测结果进行后续比对,故弹出最后一层
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []

    # 声明用于存储检测结果的变量
    list_of_images = []
    compare = {}
    result = {}
    i = 0

    # 读入test_query中选中的图片
    img = cv2.resize(cv2.imread(img_path), (64, 64)).astype(np.float32)
    img /= 255
    img = np.expand_dims(img, axis=0)

    #读出倒数第二层的输出结果
    dense1_orijin_output = model.predict(img)

    reference_path = './test_reference/'

    # 开始遍历reference文件夹里面的图片
    for dir_item in os.listdir(reference_path):
        full_path = os.path.abspath(os.path.join(reference_path, dir_item))
        if dir_item.endswith('.jpg'):
            img = cv2.resize(cv2.imread(full_path),
                             (64, 64)).astype(np.float32)
            img /= 255
            img = np.expand_dims(img, axis=0)
            dense1_output = model.predict(img)
            # 计算倒数第二层向量间的欧氏距离
            dist = np.sqrt(
                np.sum(np.square(dense1_orijin_output - dense1_output)))
            compare[dir_item] = dist

    # 将存储照片名称和欧式距离的字典按照欧式距离大小从小到大进行排序
    sorted_compare = sorted(compare.items(), key=operator.itemgetter(1))

    for item in range(len(sorted_compare)):
        key, value = sorted_compare[item]
        result[key] = value

    flag = random.randint(18, 22)

    # 从字典里将相近图片的名称提取出来,并组合成地址,添加到列表中
    for key in result.keys():
        list_of_images.append(reference_path + key)
        i = i + 1
        if i == flag:
            i = 0
            break

    # 写入xml文件
    # doc = xml.dom.minidom.Document()
    # root = doc.createElement('Message')
    # root.setAttribute('Version', '1.0')
    # doc.appendChild(root)
    # node_items = doc.createElement('Items')
    # node_items.setAttribute('name', re.findall(r"\d+", img_path)[0])  # 正则表达式仅将图片名中的数字提取出来
    #
    # for i in range(flag):
    #     node_item = doc.createElement('Item')
    #     node_item.setAttribute('image_name', re.findall(r"\d+", list(result.keys())[i])[0])
    #     node_items.appendChild(node_item)
    #
    # root.appendChild(node_items)
    # fp = open('xml_doc' + '/' + 'result.xml', 'w')
    # doc.writexml(fp, indent='\t', addindent='\t', newl='\n', encoding='utf-8')

    # 返回列表的前15个元素用于显示
    return list_of_images[:15]
Beispiel #37
0
def model_vgg19(datashape=(32, 32, 3), num_classes=10, path=None):
    """
    VGG 19 Model for Keras

    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/8d096f48a1be4a2d660d

    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilZ2RVeVhKY0FyRmc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of class labels for our classification task
    """

    model = Sequential()
    model.add(layers.ZeroPadding2D((1, 1), input_shape=datashape))
    model.add(layers.Conv2D(64, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(64, 3, 3, activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(128, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(128, 3, 3, activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(256, 3, 3, activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.ZeroPadding2D((1, 1)))
    model.add(layers.Conv2D(512, 3, 3, activation='relu'))
    model.add(layers.MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    model.add(layers.Flatten())
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(4096, activation='relu'))
    model.add(layers.Dropout(0.5))
    model.add(layers.Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights('imagenet_models/vgg19_weights.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(layers.Dense(num_classes, activation='softmax'))

    return model
Beispiel #38
0
def vgg16_model(img_rows, img_cols, channel=1, num_classes=None):
    """VGG 16 Model for Keras
    Model Schema is based on
    https://gist.github.com/baraldilorenzo/07d7802847aaad0a35d3
    ImageNet Pretrained Weights
    https://drive.google.com/file/d/0Bz7KyqmuGsilT0J5dmRCM0ROVHc/view?usp=sharing
    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color
      num_classes - number of categories for our classification task
    """
    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(img_rows, img_cols, channel)))
    model.add(Convolution2D(64, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, (3, 3), activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    model.add(Flatten())
    model.add(Dense(2048, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(2048, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(1000, activation='softmax'))

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))
    return model
Beispiel #39
0
def vgg19_model(img_rows, img_cols, channel=1, num_classes=None):
    """
    VGG 19 Model for Keras

    Model Schema is based on 
    https://gist.github.com/baraldilorenzo/8d096f48a1be4a2d660d

    ImageNet Pretrained Weights 
    https://drive.google.com/file/d/0Bz7KyqmuGsilZ2RVeVhKY0FyRmc/view?usp=sharing

    Parameters:
      img_rows, img_cols - resolution of inputs
      channel - 1 for grayscale, 3 for color 
      num_classes - number of class labels for our classification task
    """

    model = Sequential()
    model.add(ZeroPadding2D((1, 1), input_shape=(img_rows, img_cols, channel)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(64, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(128, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(256, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(ZeroPadding2D((1, 1)))
    model.add(Convolution2D(512, 3, 3, activation='relu'))
    model.add(MaxPooling2D((2, 2), strides=(2, 2)))

    # Add Fully Connected Layer
    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))
    model.add(Dense(1000, activation='softmax'))

    # Loads ImageNet pre-trained data
    model.load_weights(
        '/home/cnd/.keras/models/vgg19_weights_tf_dim_ordering_tf_kernels.h5')

    # Truncate and replace softmax layer for transfer learning
    model.layers.pop()
    model.outputs = [model.layers[-1].output]
    model.layers[-1].outbound_nodes = []
    model.add(Dense(num_classes, activation='softmax'))

    # Learning rate is changed to 0.001
    sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
    model.compile(optimizer=sgd,
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])

    return model
Beispiel #40
0
    def vgg16(self, train=True):
        p = 0.5

        if not train:
            p = 0.0

        model = Sequential()
        model.add(ZeroPadding2D((1, 1), input_shape=(3, 224, 224)))
        model.add(Convolution2D(64, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(64, 3, 3, activation='relu'))
        model.add(MaxPooling2D((2, 2), strides=(2, 2)))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(128, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(128, 3, 3, activation='relu'))
        model.add(MaxPooling2D((2, 2), strides=(2, 2)))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(256, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(256, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(256, 3, 3, activation='relu'))
        model.add(MaxPooling2D((2, 2), strides=(2, 2)))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu'))
        model.add(MaxPooling2D((2, 2), strides=(2, 2)))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(512, 3, 3, activation='relu'))
        model.add(ZeroPadding2D((1, 1)))
        model.add(Convolution2D(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(p))
        model.add(Dense(4096, activation='relu'))
        model.add(Dropout(p))
        model.add(Dense(1000, activation='softmax'))

        if train:
            model.load_weights('weights/vgg16_weights.h5')

        for layer in model.layers:
            layer.trainable = False

        for i in range(7):
            model.layers.pop()

        model.outputs = [model.layers[-1].output]
        model.layers[-1].outbound_nodes = []

        model.add(
            Convolution2D(1024,
                          3,
                          3,
                          activation='relu',
                          name='cam_conv1',
                          border_mode='same'))
        model.add(AveragePooling2D((14, 14)))
        model.add(Flatten())
        model.add(Dense(20, activation='sigmoid', name='dense_smk'))

        print(model.summary())
        if not train:
            model.load_weights('newweights/vggvoc_cam.h5')

        model.compile(loss='categorical_crossentropy', optimizer=sgd)

        return model