def __init__(self): input_1 = Input(shape=(None, None, 3)) conv_1 = Convolution2D(64, kernel_size=(3, 3), padding='same', activation='relu')(input_1) conv_2 = Convolution2D(64, kernel_size=(5, 5), padding='same', activation='relu')(conv_1) dconv_1 = Convolution2DTranspose(64, kernel_size=(3, 3), padding='same', activation='relu')(conv_2) merge_1 = merge.maximum([dconv_1, conv_2]) dconv_2 = Convolution2DTranspose(64, kernel_size=(3, 3), padding="same", activation='relu')(merge_1) merge_2 = merge.maximum([dconv_2, conv_1]) conv3 = Convolution2D(3, (5, 5), padding="same", activation='relu')(merge_2) self.model = Model(inputs=input_1, outputs=conv3) self.model.compile(optimizer='adam', loss='mean_squared_error', metrics=['acc']) self.model.summary() self.batch_size = 128
def model(): m = Sequential() m.add( Convolution2D(24, kernel_size=(5, 5), strides=(2, 2), activation='relu', input_shape=(66, 200, 1))) m.add(BatchNormalization()) m.add( Convolution2D(36, kernel_size=(5, 5), strides=(2, 2), activation='relu')) m.add(BatchNormalization()) m.add( Convolution2D(48, kernel_size=(5, 5), strides=(2, 2), activation='relu')) m.add(BatchNormalization()) m.add( Convolution2D(64, kernel_size=(3, 3), strides=(1, 1), activation='relu')) m.add(BatchNormalization()) m.add( Convolution2D(64, kernel_size=(3, 3), strides=(1, 1), activation='relu')) m.add(BatchNormalization()) m.add(Flatten()) m.add(Dense(1164, activation='relu')) m.add(BatchNormalization()) m.add(Dense(200, activation='relu')) m.add(BatchNormalization()) m.add(Dense(50, activation='relu')) m.add(BatchNormalization()) m.add(Dense(10, activation='relu')) m.add(BatchNormalization()) # Output layer m.add(Dense(1)) m.compile(loss="MSE", optimizer=Adam(lr=0.001)) print(m.summary()) return m
def lstm_categorical(input_dimension=(7, 120, 160, 3)): img_in = Input( shape=(input_dimension), name='img_in' ) # First layer, input layer, Shape comes from camera.py resolution, RGB x = TimeDistributed( Convolution2D(32, 8, 8, subsample=(4, 4), activation='relu'))(img_in) x = TimeDistributed( Convolution2D(64, 4, 4, subsample=(2, 2), activation='relu'))(x) x = TimeDistributed(Convolution2D(64, 3, 3, activation='relu'))(x) x = TimeDistributed(Flatten())(x) x = LSTM(512, activation='tanh')(x) # Steering Categorical angle_out = Dense(15, activation='softmax', name='angle_out')(x) # Throttle throttle_out = Dense(1, activation='relu', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[angle_out, throttle_out]) adam = Adam(lr=0.0001, clipnorm=1.0) model.compile(optimizer=adam, loss={ 'angle_out': 'categorical_crossentropy', 'throttle_out': 'mean_absolute_error' }, loss_weights={ 'angle_out': 0.9, 'throttle_out': .001 }) return model
def default_Q_categorical(): """ For pretrained DQN Q network """ model = Sequential() model.add( Convolution2D(32, 8, 8, subsample=(4, 4), border_mode='same', input_shape=(120, 160, 4))) #80*80*4 model.add(Activation('relu')) model.add(Convolution2D(64, 4, 4, subsample=(2, 2), border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3, subsample=(1, 1), border_mode='same')) model.add(Activation('relu')) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) # 15 categorical bins for Steering angles model.add(Dense(15, activation="linear")) # No training #adam = Adam(lr=1e-4) #model.compile(loss='mse',optimizer=adam) print("We finished building the Q model") return model
def marks_linear(): img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in x = Cropping2D(cropping=((42, 0), (0, 0)))(x) # trim 40 pixels off top #x = Lambda(lambda x: x / 127.5 - 1.)(x) # normalize and re-center x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='linear')(x) x = Dropout(.1)(x) x = Dense(50, activation='linear')(x) x = Dropout(.1)(x) # categorical output of the angle angle_out = Dense(1, activation='linear', name='angle_out')(x) # continous output of throttle throttle_out = Dense(1, activation='linear', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[angle_out, throttle_out]) model.compile(optimizer='adam', loss={'angle_out': 'mean_squared_error', 'throttle_out': 'mean_squared_error'}, loss_weights={'angle_out': 0.5, 'throttle_out': .5}) print("Created default_linear model") return model
def vgg_face_blank(): # Model initialization mdl = Sequential() # First layer is a dummy-permutation = Identity to specify input shape mdl.add(Permute((1, 2, 3), input_shape=(224, 224, 3))) # WARNING : 0 is the sample dim # Model body for l in convblock(64, 1, bits=2): mdl.add(l) for l in convblock(128, 2, bits=2): mdl.add(l) for l in convblock(256, 3, bits=3): mdl.add(l) for l in convblock(512, 4, bits=3): mdl.add(l) for l in convblock(512, 5, bits=3): mdl.add(l) # Model head mdl.add(Convolution2D(4096, kernel_size=(7, 7), activation='relu', name='fc6')) mdl.add(Dropout(0.5)) mdl.add(Convolution2D(4096, kernel_size=(1, 1), activation='relu', name='fc7')) mdl.add(Dropout(0.5)) mdl.add(Convolution2D(2622, kernel_size=(1, 1), activation='relu', name='fc8')) mdl.add(Flatten()) mdl.add(Activation('softmax')) return mdl
def create_model(self, num_outputs, input_shape=(120, 160, 3), drop=0.2): """ define the NN layers for this model. """ img_in = Input(shape=input_shape, name='img_in') x = img_in x = Convolution2D(24, (5,5), strides=(2,2), activation='relu', name="conv2d_1")(x) x = SpatialDropout2D(drop)(x) x = Convolution2D(32, (5,5), strides=(1,1), activation='relu', name="conv2d_2")(x) x = SpatialDropout2D(drop)(x) x = Convolution2D(64, (5,5), strides=(1,1), activation='relu', name="conv2d_3")(x) x = SpatialDropout2D(drop)(x) x = Convolution2D(64, (3,3), strides=(1,1), activation='relu', name="conv2d_4")(x) x = SpatialDropout2D(drop)(x) x = Convolution2D(64, (3,3), strides=(1,1), activation='relu', name="conv2d_5")(x) x = SpatialDropout2D(drop)(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='relu')(x) x = Dropout(drop)(x) x = Dense(50, activation='relu')(x) x = Dropout(drop)(x) outputs = Dense(num_outputs, activation='softmax', name="outputs")(x) model = Model(inputs=img_in, outputs=outputs) return model
def entrenamiento_red2(): cnn = Sequential() cnn.add(Convolution2D(filtrosConv1, tamanio_filtro1, padding='same', input_shape=(altura, longitud, 3), activation='relu')) cnn.add(MaxPooling2D(pool_size=tamanio_pool)) cnn.add(Convolution2D(filtrosConv2, tamanio_filtro2, padding='same', activation='relu')) cnn.add(MaxPooling2D(pool_size=tamanio_pool)) #Teniendo una imagen con muchas capas, ahora la vamos a aplanar cnn.add(Flatten()) #Despues de aplanar las imagenes, se conectan las capas cnn.add(Dense(256,activation='relu')) #A la capa densa, se le van a ir apagando el 50% de las neuronas con cada paso, #esto se hace para evitar el sobre-ajuste cnn.add(Dropout(0.5)) #Se hace la conexion con la capa de salida cnn.add(Dense(clases, activation='softmax')) #Parametros para optimizar el algoritmo cnn.compile(loss='categorical_crossentropy', optimizer=optimizers.Adam(lr=lr), metrics=['accuracy']) cnn.fit_generator(imagen_entrenamiento_red2, steps_per_epoch=pasos, epochs=epocas, validation_data=imagen_validacion_red2, validation_steps=pasos_validacion) dir='./modelo/red2/' if not os.path.exists(dir): os.mkdir(dir) cnn.save('./modelo/red2/modelo.h5') cnn.save_weights('./modelo/red2/pesos.h5')
def default_categorical(): 'default_categorical model from donkey car' img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in x = Cropping2D(cropping=((30, 10), (0, 0)))( x) # crop 40 pixels off top and 10 off bottom x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) # x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='relu')(x) x = Dropout(.1)(x) x = Dense(50, activation='relu')(x) x = Dropout(.1)(x) # categorical output of the angle angle_out = Dense(3, activation='softmax', name='angle_cat_out')(x) # continous output of throttle # throttle_out = Dense(1, activation='relu', name='throttle_out')(x) # Reduce to 1 number, Positive number only model = Model(inputs=[img_in], outputs=[angle_out]) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model
def make_model(): left_image_in = Input(shape=(240, 320, 3),name='img_left') right_image_in = Input(shape=(240, 320, 3),name='img_right') # concat into a 6 channel input volume x = concatenate([left_image_in, right_image_in], axis=2) # FCN layers x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) # Dense layers x = Flatten(name='flattened')(x) x = Dense(100, activation='relu')(x) x = Dropout(.1)(x) x = Dense(50, activation='relu')(x) x = Dropout(.1)(x) # Steering angle angle = Dense(15, activation='softmax', name='angle_cat_out')(x) angle_out = Dense(1, activation='sigmoid', name='angle_out')(angle) # throttle output throttle_out = Dense(1, activation='relu', name='throttle_out')(x) model = Model(inputs=[left_image_in, right_image_in], outputs=[angle_out, throttle_out]) # model.compile(optimizer='adam', # loss={'angle_out': 'mean_squared_error', # 'throttle_out': 'mean_absolute_error'}, # loss_weights={'angle_out': 0.9, 'throttle_out': .01}) return model
def rnn_lstm(seq_length=3, num_outputs=2, image_shape=(120, 160, 3)): img_seq_shape = (seq_length, ) + image_shape img_in = Input(batch_shape=img_seq_shape, name='img_in') drop_out = 0.3 x = Sequential() x.add(TD(Cropping2D(cropping=((40, 0), (0, 0))), input_shape=img_seq_shape)) #trim 60 pixels off top x.add(TD(BatchNormalization())) x.add(TD(Convolution2D(24, (5, 5), strides=(2, 2), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(Convolution2D(32, (5, 5), strides=(2, 2), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(Convolution2D(32, (3, 3), strides=(2, 2), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(Convolution2D(32, (3, 3), strides=(1, 1), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(MaxPooling2D(pool_size=(2, 2)))) x.add(TD(Flatten(name='flattened'))) x.add(TD(Dense(100, activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(LSTM(128, return_sequences=True, name="LSTM_seq")) x.add(Dropout(.1)) x.add(LSTM(128, return_sequences=False, name="LSTM_out")) x.add(Dropout(.1)) x.add(Dense(128, activation='relu')) x.add(Dropout(.1)) x.add(Dense(64, activation='relu')) x.add(Dense(10, activation='relu')) x.add(Dense(num_outputs, activation='linear', name='model_outputs')) return x
def init_model(self): self.cnn = Sequential() self.cnn.add( Convolution2D(32, 3, padding=constant.PADDING_SAME, input_shape=self.shape)) self.cnn.add(Activation(constant.RELU_ACTIVATION_FUNCTION)) self.cnn.add(Convolution2D(32, 3, 3)) self.cnn.add(Activation(constant.RELU_ACTIVATION_FUNCTION)) self.cnn.add(MaxPooling2D(pool_size=(2, 2))) self.cnn.add(Dropout(constant.DROP_OUT_O_25)) self.cnn.add(Convolution2D(64, 3, padding=constant.PADDING_SAME)) self.cnn.add(Activation(constant.RELU_ACTIVATION_FUNCTION)) self.cnn.add(Convolution2D(64, 3, 3)) self.cnn.add(Activation(constant.RELU_ACTIVATION_FUNCTION)) self.cnn.add(MaxPooling2D(pool_size=(2, 2))) self.cnn.add(Dropout(constant.DROP_OUT_O_25)) self.cnn.add(Flatten()) self.cnn.add(Dense(constant.NUMBER_FULLY_CONNECTED)) self.cnn.add(Activation(constant.RELU_ACTIVATION_FUNCTION)) self.cnn.add(Dropout(constant.DROP_OUT_0_50)) self.cnn.add(Dense(self.n_classes)) self.cnn.add(Activation(constant.SOFTMAX_ACTIVATION_FUNCTION)) self.cnn.summary()
def default_linear_master(): img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='linear')(x) x = Dropout(.1)(x) x = Dense(50, activation='linear')(x) x = Dropout(.1)(x) # categorical output of the angle angle_out = Dense(1, activation='linear', name='angle_out')(x) # continous output of throttle throttle_out = Dense(1, activation='linear', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[angle_out, throttle_out]) model.compile(optimizer='adam', loss={ 'angle_out': 'mean_squared_error', 'throttle_out': 'mean_squared_error' }, loss_weights={ 'angle_out': 0.5, 'throttle_out': .5 }) return model
def default_n_linear(num_outputs): img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in x = Cropping2D(cropping=((60, 0), (0, 0)))(x) # trim 60 pixels off top x = Lambda(lambda x: x / 127.5 - 1.)(x) # normalize and re-center x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(64, (5, 5), strides=(1, 1), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='relu')(x) x = Dropout(.1)(x) x = Dense(50, activation='relu')(x) x = Dropout(.1)(x) outputs = [] for i in range(num_outputs): outputs.append( Dense(1, activation='linear', name='n_outputs' + str(i))(x)) model = Model(inputs=[img_in], outputs=outputs) model.compile(optimizer='adam', loss='mse') return model
def _residual_block(self, ip, id): mode = True if self.config.mode == 'train' else False channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 init = ip x = Convolution2D(self.config.n, (3, 3), activation='linear', padding='same', name='sr_res_conv_' + str(id) + '_1')(ip) x = BatchNormalization(axis=channel_axis, name="sr_res_batchnorm_" + str(id) + "_1")( x, training=mode) x = Activation('relu', name="sr_res_activation_" + str(id) + "_1")(x) x = Convolution2D(64, (3, 3), activation='linear', padding='same', name='sr_res_conv_' + str(id) + '_2')(x) x = BatchNormalization(axis=channel_axis, name="sr_res_batchnorm_" + str(id) + "_2")( x, training=mode) m = Add(name="sr_res_merge_" + str(id))([x, init]) return m
def contruModelo(self): cnn = Sequential() cnn.add( Convolution2D(self.filtrosConv1, self.tamano_filtro1, padding="same", input_shape=(self.altura, self.longitud, 3), activation='relu')) cnn.add(MaxPooling2D(pool_size=self.tamano_pool)) cnn.add( Convolution2D(self.filtrosConv2, self.tamano_filtro2, padding="same", activation='relu')) cnn.add(MaxPooling2D(pool_size=self.tamano_pool)) cnn.add( Convolution2D(self.filtrosConv3, self.tamano_filtro3, padding="same", activation='relu')) cnn.add(MaxPooling2D(pool_size=self.tamano_pool)) cnn.add(Flatten()) #cnn.add(Dense(16,activation='relu')) cnn.add(Dense(256, activation='relu')) #sigmoidal--- lineal cnn.add(Dense(self.cantidad_acciones, activation='softmax')) #tanh cnn.compile(loss='mse', optimizer=optimizers.RMSprop(lr=self.aprendizaje)) return cnn
def create(self): # Step 1: convolution self.__classifier.add( Convolution2D(5, 5, input_shape=(50, 50, 1), padding='same', activation='relu')) # Step 2: pooling self.__classifier.add(MaxPooling2D(pool_size=(4, 4))) # Add a convolutional layer self.__classifier.add( Convolution2D(15, 5, input_shape=(50, 50, 1), padding='same', activation='relu')) # Add another max pooling layer self.__classifier.add(MaxPooling2D(pool_size=(4, 4))) # Step 3: Flattening self.__classifier.add(Flatten()) # Step 4: Full connection self.__classifier.add( Dense(units=self.__train_data_symbol_count, activation='softmax')) # Compiling the CNN self.__classifier.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
def donkey_model(): img_in = Input(shape=(224, 224, 3), name='img_in') x = img_in # Convolution2D class name is an alias for Conv2D x = Convolution2D(filters=24, kernel_size=(5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=32, kernel_size=(5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=64, kernel_size=(5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='relu')(x) x = Flatten(name='flattened')(x) x = Dense(units=100, activation='linear')(x) x = Dropout(rate=.1)(x) x = Dense(units=50, activation='linear')(x) x = Dropout(rate=.1)(x) # continous output of throttle control_out = Dense(units=5, activation='linear', name='control_out')(x) model = Model(inputs=[img_in], outputs=[control_out]) model.compile(optimizer='adam', loss={'control_out': 'categorical_crossentropy'}, metrics=['acc']) return model
def default_n_linear(num_outputs, input_shape=(256, 512, 3), roi_crop=(0, 0)): drop = 0.1 input_shape = adjust_input_shape(input_shape, roi_crop) model = Sequential() model.add(Convolution2D(24, (5,5), strides=(2,2), activation='relu', name="conv2d_1", input_shape=input_shape)) model.add(Dropout(drop)) model.add(Convolution2D(32, (5,5), strides=(2,2), activation='relu', name="conv2d_2")) model.add(Dropout(drop)) model.add(Convolution2D(64, (5,5), strides=(2,2), activation='relu', name="conv2d_3")) model.add(Dropout(drop)) model.add(Convolution2D(64, (3,3), strides=(1,1), activation='relu', name="conv2d_4")) model.add(Dropout(drop)) model.add(Convolution2D(64, (3,3), strides=(1,1), activation='relu', name="conv2d_5")) model.add(Dropout(drop)) model.add(Flatten(name='flattened')) model.add(Dense(100, activation='relu')) model.add(Dropout(drop)) model.add(Dense(50, activation='relu')) model.add(Dropout(drop)) model.add(Dense(num_outputs)) model.add(Activation('linear')) return model
def default_n_linear(num_outputs, input_shape=(120, 160, 3), roi_crop=(0, 0)): drop = 0.1 #we now expect that cropping done elsewhere. we will adjust our expeected image size here: input_shape = adjust_input_shape(input_shape, roi_crop) img_in = Input(shape=input_shape, name='img_in') x = img_in x = Convolution2D(24, (5,5), strides=(2,2), activation='relu', name="conv2d_1")(x) x = Dropout(drop)(x) x = Convolution2D(32, (5,5), strides=(2,2), activation='relu', name="conv2d_2")(x) x = Dropout(drop)(x) x = Convolution2D(64, (5,5), strides=(2,2), activation='relu', name="conv2d_3")(x) x = Dropout(drop)(x) x = Convolution2D(64, (3,3), strides=(1,1), activation='relu', name="conv2d_4")(x) x = Dropout(drop)(x) x = Convolution2D(64, (3,3), strides=(1,1), activation='relu', name="conv2d_5")(x) x = Dropout(drop)(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='relu')(x) x = Dropout(drop)(x) x = Dense(50, activation='relu')(x) x = Dropout(drop)(x) outputs = [] for i in range(num_outputs): outputs.append(Dense(1, activation='linear', name='n_outputs' + str(i))(x)) model = Model(inputs=[img_in], outputs=outputs) return model
def cnn_model(): input_tensor = Input(shape=(HEIGTH, WIDTH, CHANNELS)) x = input_tensor # 第一层卷积 conv1 = Convolution2D(filters=32, kernel_size=(3, 3), strides=(2, 2), padding='same')(x) bath_normal1 = BatchNormalization()(conv1) dropout1 = Dropout(0.2)(bath_normal1) activate1 = Activation('relu')(dropout1) # 第二层卷积 conv2 = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(activate1) bath_normal2 = BatchNormalization()(conv2) dropout2 = Dropout(0.2)(bath_normal2) activate2 = Activation('relu')(dropout2) # 第s三层卷积 conv3 = Convolution2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(activate2) bath_normal3 = BatchNormalization()(conv3) dropout3 = Dropout(0.2)(bath_normal3) activate3 = Activation('relu')(dropout3) # flatten x = Flatten()(activate3) x = Dropout(0.25)(x) x = Dense(num_classes, activation='softmax')(x) model = tf.keras.Model(inputs=input_tensor, outputs=x) return model
def residual_layer(x): conv = Convolution2D(256, (3, 3), padding='SAME')(x) norm = BatchNormalization()(conv) relu = Activation('relu')(norm) conv2 = Convolution2D(256, (3, 3), padding='SAME')(relu) m = merge.concatenate([conv2, x]) return Activation('relu')(m)
def default_linear(): img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in # Convolution2D class name is an alias for Conv2D x = Convolution2D(filters=24, kernel_size=(5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=32, kernel_size=(5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=64, kernel_size=(5, 5), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='relu')(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(1, 1), activation='relu')(x) x = Flatten(name='flattened')(x) x = Dense(units=100, activation='linear')(x) x = Dropout(rate=.1)(x) x = Dense(units=50, activation='linear')(x) x = Dropout(rate=.1)(x) # categorical output of the angle angle_out = Dense(units=1, activation='linear', name='angle_out')(x) # continous output of throttle throttle_out = Dense(units=1, activation='linear', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[angle_out, throttle_out]) model.compile(optimizer='adam', loss={'angle_out': 'mean_squared_error', 'throttle_out': 'mean_squared_error'}, loss_weights={'angle_out': 0.5, 'throttle_out': .5}) return model
def default_categorical(): from keras.layers import Input, Dense, merge from keras.models import Model from keras.layers import Cropping2D, Convolution2D, MaxPooling2D, Reshape, BatchNormalization from keras.layers import Activation, Dropout, Flatten, Dense img_in = Input(shape=(120, 160, 3), name='img_in') x = img_in x = Cropping2D(cropping=((45,0), (0,0)))(x) x = Convolution2D(24, (5,5), strides=(2,2), activation='relu')(x) x = Convolution2D(32, (5,5), strides=(2,2), activation='relu')(x) x = Convolution2D(64, (5,5), strides=(2,2), activation='relu')(x) x = Convolution2D(64, (3,3), strides=(1,1), activation='relu')(x) x = Convolution2D(64, (3,3), strides=(1,1), activation='relu')(x) # Possibly add MaxPooling (will make it less sensitive to position in image). Camera angle fixed, so may not to be needed x = Flatten(name='flattened')(x) # Flatten to 1D (Fully connected) x = Dense(100, activation='relu')(x) # Classify the data into 100 features, make all negatives 0 x = Dropout(.1)(x) # Randomly drop out (turn off) 10% of the neurons (Prevent overfitting) x = Dense(50, activation='relu')(x) # Classify the data into 50 features, make all negatives 0 x = Dropout(.1)(x) # Randomly drop out 10% of the neurons (Prevent overfitting) #categorical output of the angle angle_out = Dense(15, activation='softmax', name='angle_out')(x) # Connect every input with every output and output 15 hidden units. Use Softmax to give percentage. 15 categories and find best one based off percentage 0.0-1.0 #continous output of throttle throttle_out = Dense(1, activation='relu', name='throttle_out')(x) # Reduce to 1 number, Positive number only model = Model(inputs=[img_in], outputs=[angle_out, throttle_out]) model.compile(optimizer='adam', loss={'angle_out': 'categorical_crossentropy', 'throttle_out': 'mean_absolute_error'}, loss_weights={'angle_out': 0.9, 'throttle_out': .0001}) return model
def nn(self): nn = Sequential() nn.add( Convolution2D(self.filtroprimeravez, self.filtrouno, padding="same", input_shape=(self.longituddelaimagen, self.alturadelaimagen, 3), activation='relu')) nn.add(MaxPooling2D(pool_size=self.pulido)) nn.add( Convolution2D(self.filtrosegundavez, self.filtrodos, padding="same")) nn.add(MaxPooling2D(pool_size=self.pulido)) nn.add(Flatten()) nn.add(Dense(256, activation='relu')) nn.add(Dropout(0.1)) nn.add(Dense(self.numerodenfermedades, activation='softmax')) nn.compile(loss='categorical_crossentropy', optimizer=optimizers.Adam(lr=self.lr), metrics=['accuracy']) nn.fit_generator(self.entrenamiento_generador, steps_per_epoch=self.pasos, epochs=self.pruebas, validation_data=self.validacion_generador, validation_steps=self.validacon) #nn.save('./modelo_lab_experimental/modelo_pezenfermo.h5') #nn.save_weights('./modelo_lab_experimental/pesospezenfermo.h5') return nn
def default_linear(): "fully connected version of the default linear model" img_in = Input(shape=(224, 224, 3), name='img_in') x = img_in # Convolution2D class name is an alias for Conv2D x = Convolution2D(filters=64, kernel_size=(5, 5), strides=(2, 2), activation='elu')(x) #output shape 110x110 x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='elu')(x) #output shape 27x27 x = MaxPool2D(pool_size=(2,2))(x) x = Convolution2D(filters=64, kernel_size=(3, 3), strides=(2, 2), activation='relu')(x) #output shape 7x7 x = MaxPool2D(pool_size=(2,2))(x) x = Convolution2D(filters=5, kernel_size=(3,3), strides=(2, 2), activation='relu')(x) x = MaxPool2D(pool_size=(2,2))(x) #output 5x5 control_out = Flatten(name='control_out')(x) # control_out = Dense(units=4, activation='relu', name='control_out')(x) # continous output of throttle for later possibly # throttle_out = Dense(units=1, activation='linear', name='throttle_out')(x) model = Model(inputs=[img_in], outputs=[control_out]) model.compile(optimizer='adam', loss={'control_out': 'categorical_crossentropy'}, metrics=['acc']) return model
def rnn_lstm(seq_length=3, num_outputs=2, image_shape=(120,160,3)): #we now expect that cropping done elsewhere. we will adjust our expeected image size here: #input_shape = adjust_input_shape(input_shape, roi_crop) img_seq_shape = (seq_length,) + image_shape img_in = Input(batch_shape = img_seq_shape, name='img_in') drop_out = 0.3 x = Sequential() x.add(TD(Convolution2D(24, (5,5), strides=(2,2), activation='relu'), input_shape=img_seq_shape)) x.add(TD(Dropout(drop_out))) x.add(TD(Convolution2D(32, (5,5), strides=(2,2), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(Convolution2D(32, (3,3), strides=(2,2), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(Convolution2D(32, (3,3), strides=(1,1), activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(TD(MaxPooling2D(pool_size=(2, 2)))) x.add(TD(Flatten(name='flattened'))) x.add(TD(Dense(100, activation='relu'))) x.add(TD(Dropout(drop_out))) x.add(LSTM(128, return_sequences=True, name="LSTM_seq")) x.add(Dropout(.1)) x.add(LSTM(128, return_sequences=False, name="LSTM_fin")) x.add(Dropout(.1)) x.add(Dense(128, activation='relu')) x.add(Dropout(.1)) x.add(Dense(64, activation='relu')) x.add(Dense(10, activation='relu')) x.add(Dense(num_outputs, activation='linear', name='model_outputs')) return x
def default_loc(num_outputs, num_locations, input_shape): ''' Notes: this model depends on concatenate which failed on keras < 2.0.8 ''' drop = 0.5 img_in = Input(shape=input_shape, name='img_in') x = img_in x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu', name="conv2d_1")(x) x = Dropout(drop)(x) x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu', name="conv2d_2")(x) x = Dropout(drop)(x) x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu', name="conv2d_3")(x) x = Dropout(drop)(x) x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu', name="conv2d_4")(x) x = Dropout(drop)(x) x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu', name="conv2d_5")(x) x = Dropout(drop)(x) x = Flatten(name='flattened')(x) x = Dense(100, activation='relu')(x) x = Dropout(drop)(x) z = Dense(50, activation='relu')(x) z = Dropout(.1)(z) #categorical output of the angle angle_out = Dense(15, activation='softmax', name='angle')(z) #categorical output of throttle throttle_out = Dense(20, activation='softmax', name='throttle')(z) #categorical output of location loc_out = Dense(num_locations, activation='softmax', name='loc')(z) #categorical output of lane lane_out = Dense(2, activation='softmax', name='lane')(z) #model = Model(inputs=[img_in], outputs=[angle_out, throttle_out, loc_out, lane_out]) model = Model(inputs=[img_in], outputs=[angle_out, throttle_out, loc_out]) return model
def add_model(self, input_data, target_data=None): """Implements core of model that transforms input_data into predictions. The core transformation for this model which transforms a batch of input data into a batch of predictions. Args: input_data: A tensor of shape (batch_size, num_steps, time_stamps). target_data: A tensor of shape (batch_size, num_steps, time_stamps). Returns: predict: A tensor of shape (batch_size, num_steps, time_stamps) """ # Consider signal matrix as an image with channels. height = self.config.num_steps width = self.config.time_stamps channels = self.config.channels batch_size = self.config.batch_size # input_data: (-1, height, width, channels) input_data = tf.reshape(input_data, [-1, channels, height, width]) input_data = tf.transpose(input_data, perm=[0, 2, 3, 1]) x0 = Convolution2D(64, (3, 3), activation='relu', padding='same', name='sr_res_conv1')(input_data) x1 = Convolution2D(64, (3, 3), activation='relu', padding='same', strides=(2, 2), name='sr_res_conv2')(x0) x2 = Convolution2D(64, (3, 3), activation='relu', padding='same', strides=(2, 2), name='sr_res_conv3')(x1) x = self._residual_block(x2, 1) for i in range(self.config.nb_residual): x = self._residual_block(x, i + 2) x = Add()([x, x2]) x = self._upscale_block(x, 1) x = Add()([x, x1]) x = self._upscale_block(x, 2) x = Add()([x, x0]) output = Convolution2D(self.config.channels, (3, 3), activation="linear", padding='same', name='sr_res_conv_final')(x) prediction = tf.transpose(output, perm=[0, 3, 1, 2]) prediction = tf.reshape(prediction, [batch_size, height, width]) return prediction
def Nvidia(num_outputs, input_shape, roi_crop): input_shape = adjust_input_shape(input_shape, roi_crop) img_in = Input(shape=input_shape, name='img_in') x = img_in # rate # dropout regularization, with a 90% keep probability. rate = 0.1 # Convolutional Layer 1 x = Convolution2D(filters=24, kernel_size=5, strides=(2, 2), input_shape=input_shape)(x) x = Dropout(rate)(x) x = Convolution2D(filters=36, kernel_size=5, strides=(2, 2), activation='relu')(x) x = Dropout(rate)(x) #x = MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='valid')(x) x = Convolution2D(filters=48, kernel_size=5, strides=(2, 2), activation='relu')(x) x = Dropout(rate)(x) x = Convolution2D(filters=64, kernel_size=3, strides=(1, 1), activation='relu')(x) x = Dropout(rate)(x) #x = MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='valid')(x) x = Convolution2D(filters=64, kernel_size=3, strides=(1, 1), activation='relu')(x) x = Dropout(rate)(x) # Flatten Layers [Flatten to 1D (Fully connected)] x = Flatten()(x) # Fully Connected Layer x = Dense(1164, activation='relu')(x) x = Dense(100, activation='relu')(x) x = Dense(50, activation='relu')(x) x = Dense(10, activation='relu')(x) outputs = [] for i in range(num_outputs): # Output layer outputs.append( Dense(1, activation='linear', name='n_outputs' + str(i))(x)) model = Model(inputs=[img_in], outputs=outputs) return model