def CNN_model(frameHeight, frameWidth): model = Sequential() model.add(Convolution2D(32, 3, 3, border_mode='same', init='he_normal', activation='relu', input_shape=(1, int(frameHeight), int(frameWidth)))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) model.add(Convolution2D(64, 3, 3, border_mode='same', init='he_normal', activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Convolution2D(128, 3, 3, border_mode='same', init='he_normal', activation='relu')) model.add(MaxPooling2D(pool_size=(8, 8))) model.add(Dropout(0.2)) model.add(Flatten()) model.add(Dense(32, W_regularizer=l2(1.26e-7))) model.add(Activation('relu')) model.add(Dense(2, W_regularizer=l2(1e-0))) model.add(Activation('softmax')) model.compile(Adam(lr=1e-3), loss='categorical_crossentropy') plot(model, to_file='model.png') return model
def cnn_optimise(W): # Number of feature maps (outputs of convolutional layer) N_fm = 300 # kernel size of convolutional layer kernel_size = 8 conv_input_width = W.shape[1] conv_input_height = 200 # maxlen of sentence model = Sequential() # Embedding layer (lookup table of trainable word vectors) model.add( Embedding(input_dim=W.shape[0], output_dim=W.shape[1], weights=[W], W_constraint=unitnorm(), init="uniform") ) # Reshape word vectors from Embedding to tensor format suitable for Convolutional layer model.add(Reshape(dims=(1, conv_input_height, conv_input_width))) # first convolutional layer model.add(Convolution2D(N_fm, kernel_size, conv_input_width, border_mode="valid", W_regularizer=l2(0.0001))) # ReLU activation model.add(Dropout(0.5)) model.add(Activation("relu")) # aggregate data in every feature map to scalar using MAX operation model.add(MaxPooling2D(pool_size=(conv_input_height - kernel_size + 1, 1), border_mode="valid")) model.add(Dropout(0.5)) model.add(Flatten()) # Inner Product layer (as in regular neural network, but without non-linear activation function) model.add(Dense(input_dim=N_fm, output_dim=1)) # SoftMax activation; actually, Dense+SoftMax works as Multinomial Logistic Regression model.add(Activation("sigmoid")) plot(model, to_file="./images/model.png") return model
def make_keras_model(n_hidden_layers, dimof_middle, dimof_input): from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.utils import np_utils, generic_utils from keras.wrappers.scikit_learn import KerasClassifier dimof_output =1 print("dimof_input : ",dimof_input, "dimof_output : ", dimof_output) batch_size = 100 dropout = 0.5 countof_epoch = 5 model = Sequential() model.add(Dense(input_dim=dimof_input, output_dim=dimof_middle, init="glorot_uniform",activation='relu')) model.add(Dropout(dropout)) for n in range(n_hidden_layers): model.add(Dense(input_dim=dimof_middle, output_dim=dimof_middle, init="glorot_uniform",activation='relu')) model.add(Dropout(dropout)) model.add(Dense(input_dim=dimof_middle, output_dim=dimof_output, init="glorot_uniform",activation='sigmoid')) #Compiling (might take longer) model.compile(class_mode='binary',loss='binary_crossentropy', optimizer='adam',metrics=["accuracy"]) visualize_util.plot(model, to_file='model.png') return model
def visualize_model(model): model.summary() visualize_util.plot(model, to_file='../../figures/%s.png' % model.name, show_shapes=True, show_layer_names=True)
def __init__(self, options): """Initialise network structure.""" # Pre-define batch for use in objective function feature_matching self.timesteps = options['timesteps'] self.features = options['features'] self.gamma = options['gamma'] self.drop = options['dropout'] self.plot = options['plot'] self.epoch = options['epoch'] self.batch_size = options['batch_size'] self.init = options['layer_init'] self.pre_train_D = options['pre_train_D'] self.num_GRU = options["GRU_layers"] self.is_mir_eval = options["IS_MIR_EVAL"] self.G_lr = options["G_lr"] self.D_lr = options["D_lr"] self.GAN_lr = options["GAN_lr"] self.mir_eval = {'SAR': [], 'SIR': [], 'SDR': []} self.batch = np.zeros((self.batch_size, self.timesteps, self.features)) self.D__init__() self.G__init__() self.GAN__init__() if self.plot: plot(self.GAN, to_file='model.png')
def createmodel(img_channels,img_rows,img_cols,classes=1): # This is a Sequential model. Graph models can be used in order to create more complex networks. # Teaching Points: # 1. Here we utilize the adam optimization algorithm. In order to use the SGD algorithm one could replace the {adam=keras.optimizers.Adadelta(lr=0)} line with {sgd = SGD(lr=0.0, momentum=0.9, decay=0.0, nesterov=False)} make sure you import the correct optimizer from keras. # 2. This is a binary classification problem so make sure that the correct activation loss function combination is used. For such a problem the sigmoid activation function with the binary cross entropy loss is a good option # 3. Since this is a binary problem use model.add(Dense(1)) NOT 2... # 4. For multi class model this code can be easily modified by selecting the softmax as activation function and the categorical cross entropy as loss model = Sequential() # first set of CONV => RELU => POOL model.add(Convolution2D(20, 5, 5, border_mode="same", input_shape=(img_channels, img_rows, img_cols))) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # second set of CONV => RELU => POOL model.add(Convolution2D(50, 5, 5, border_mode="same")) model.add(Activation("relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # set of FC => RELU layers model.add(Flatten()) model.add(Dense(500)) model.add(Activation("relu")) # softmax classifier model.add(Dense(classes)) # model.add(Activation('relu')) model.add(Activation('sigmoid')) # learning schedule callback adam=keras.optimizers.Adadelta(lr=0) lrate = LearningRateScheduler(step_decay) model.compile(loss='binary_crossentropy', optimizer=adam, metrics=['accuracy']) plot(model, to_file='modellen.png') return model
def evaluate_single_model(model, folder_name, model_name, features_test, labels_test, save_model=True): cat_labels_test = np_utils.to_categorical(labels_test) loss, acc = model.evaluate(features_test, cat_labels_test, verbose=2) write = "**********Evaluating " + str(model_name) + "************\n" write += 'Testing data size: ' + str(len(labels_test)) + '\n' write += str(Counter(labels_test)) + '\n' write += 'loss: ' + str(loss) + ' acc' + str("%.2f" % round(acc, 4)) + '\n' result = model.predict(features_test) result_label = np.argmax(result, 1) gt_label = labels_test con_matrix = confusion_matrix(gt_label, result_label) write += str(con_matrix) + '\n' write += "Classification report:\n" write += str(classification_report(gt_label, result_label)) + '\n' # create folder if not exists if not os.path.exists(folder_name): os.makedirs(folder_name) if save_model: model_json = model.to_json() with open(folder_name + model_name + "_model.json", "w") as json_file: json_file.write(model_json) # serialize weights to HDF5 model.save_weights(folder_name + model_name + "_model.h5") print("Saved model to disk") plot(model, to_file=folder_name + model_name + "_model.png", show_shapes=True) return write, acc
def imdb_test(): # set parameters: max_features = 5000 # number of vocabulary maxlen = 200 # padding batch_size = 16 nb_epoch = 10 print('Loading data...') (X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=max_features, test_split=0.2) print("Pad sequences (samples x time)") X_train = sequence.pad_sequences(X_train, maxlen=maxlen) X_test = sequence.pad_sequences(X_test, maxlen=maxlen) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape) nb_classes = 2 y_train = np_utils.to_categorical(y_train, nb_classes) y_test = np_utils.to_categorical(y_test, nb_classes) model = imdb_cnn() plot(model, to_file='./images/imdb_model.png') # try using different optimizers and different optimizer configs # model.compile(loss='binary_crossentropy', optimizer='adagrad', class_mode="binary") model.compile(loss='categorical_crossentropy', optimizer='adagrad') print("Train...") early_stopping = EarlyStopping(monitor='val_loss', patience=5) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_data=(X_test, y_test), show_accuracy=True, callbacks=[early_stopping]) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size, show_accuracy=True) print('Test score:', score) print('Test accuracy:', acc)
def build_model(config): sent_input = Input(shape=(config.max_len,),dtype='int32',name = "sent_input") # define inpute sent_embedding = Embedding(config.vocab_size,config.word_dims, # W_regularizer=l2(0.01), dropout=0.2, name="sent_w2v",)(sent_input) convs = [] if config.pool_method=="mean": pool_method = mean_1d elif config.pool_method=="max": pool_method = max_1d for nb_filter,filter_length in zip(config.nb_filters,config.filter_lengths): conv = Convolution1D(nb_filter=nb_filter, filter_length=filter_length, border_mode='valid', activation='relu', subsample_length=1, name="conv_len_{}_nb_{}".format(filter_length,nb_filter))(sent_embedding) pooling = Lambda(pool_method, output_shape=(nb_filter,),name="max_pooling_len_{}_nb_{}".format(filter_length,nb_filter))(conv) convs.append(pooling) concat = merge(convs, mode='concat',name = "sent_merge") hidden = Dropout(p = config.hidden_dropout)(Dense(config.hidden_dims,activation="relu",name = "sent_hidden")(concat)) out = Activation('softmax')(Dense(config.label_size)(hidden)) model = Model(input=sent_input, output=out,name=config.model_name) print("build completed") model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics=['accuracy']) print(model.summary()) from keras.utils.visualize_util import plot plot(model, to_file='flatten_10.png',show_shapes=True) return model
def compile_model(self, lr=0.0001, loss_weights=0.1): optimizer = Adam(lr=lr) loss = 'mse' # loss = custom_objective self.model.compile(optimizer=optimizer, loss=loss) #metrics=['mse']) plot(self.model, to_file='model.png')
def get_new_model(in_width, lstm_hidden, out_width, batch_size, ltype): model = Sequential() # if args.time_dist_dense: # model.add(LSTM(in_width, lstm_hidden, return_sequences=True)) # model.add(TimeDistributedDense(lstm_hidden, out_width)) # else: # if args.rnn: # model.add(SimpleRNN(in_width, lstm_hidden, return_sequences=False)) # else: print "Number of hidden layers:", args.depth # model.add(LSTM(lstm_hidden , input_dim=in_width, return_sequences=False if args.depth == 0 else True)) for i in range(args.depth): model.add(generate_layer(ltype, in_width, lstm_hidden, "last" if i+1 == args.depth else "first" if i==0 else "middle")) # model.add(LSTM(lstm_hidden , input_dim=in_width, return_sequences=False if i+1 == args.depth else True)) model.add(Dropout(args.dropout)) model.add(Dense(out_width)) model.add(Activation('softmax')) optimizer = Adagrad(clipnorm=args.clipnorm) model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer=optimizer) from keras.utils.visualize_util import plot plot(model, show_shapes=True, to_file='model.png') return model
def draw_model(model): from IPython.display import SVG from keras.utils.visualize_util import to_graph from keras.utils.visualize_util import plot SVG(to_graph(model).create(prog='dot', format='svg')) plot(model, to_file='UFCNN/UFCNN_1.png')
def build_model(self): lstm_branch = [] input_branch = [] for i in range(self.layers_number): main_input = Input(shape=(self.lstm_timesteps, self.input_dim), name="main_input_" + str(i)) input_branch.append(main_input) lstm_out = LSTM(self.lstm_hidden, return_sequences=True)(main_input) # auxiliary_input = Input(batch_shape=(self.batch_size,1,self.lstm_timesteps), name='auxiliary_input'+str(i)) auxiliary_input = Input(shape=(1, self.lstm_timesteps), name="auxiliary_input" + str(i)) input_branch.append(auxiliary_input) """ x1 = Merge([lstm_out, auxiliary_input], mode=lambda x, y: (x*y).sum(axis=0), name='merge_lstm_auxi'+str(i)) """ x1 = merge([auxiliary_input, lstm_out], mode="dot", dot_axes=[2, 1], name="merge_lstm_auxi" + str(i)) assert x1 flatten = Reshape((self.lstm_hidden,))(x1) c_input = Input(shape=(6,), name="c_input" + str(i)) input_branch.append(c_input) x2 = merge([flatten, c_input], mode="concat") x2 = Dense( self.lstm_hidden, activation="relu", W_regularizer=l2(0.001), activity_regularizer=activity_l2(0.001) )(x2) assert x2 lstm_branch.append(x2) lstm_all_out = merge(lstm_branch, mode="sum", name="lstm_all_out") """ dense_relu = Dense(self.lstm_hidden, activation='relu', W_regularizer=l2(0.001), activity_regularizer=activity_l2(0.001))(lstm_all_out) """ final_loss = Dense(self.output_dim, name="main_output")(lstm_all_out) self.model = Model(input_branch, output=final_loss) self.model.compile(loss="mean_squared_error", optimizer="adagrad") plot(self.model, to_file="multiple_model.png", show_shapes=True)
def save_model(model, name="model"): model_json = model.to_json() model_out = open(name + '.json', 'w') model_out.write(model_json) model_out.close() plot(model, to_file='model_' + name + '.png') model.save_weights('weights_' + name, overwrite=True)
def main(): #load data #X_train,Y_train,X_valid,Y_valid,X_test=load_data(training_dir,valid_dir,test_dir,labels,sample) #preprocess data by mean subtraction and normalization #X_train,X_valid,X_test=preprocess(X_train,X_valid,X_test) #del X_train #del X_test #or load pre-processed data from a previously saved hdf5 file: data=h5py.File('imagenet.hdf5','r') X_train=np.asarray(data['X_train']) Y_train=np.asarray(data['Y_train']) X_valid=np.asarray(data['X_valid']) Y_valid=np.asarray(data['Y_valid']) X_test=np.asarray(data['X_test']) print(Y_valid.shape) print(X_valid.shape) #print "loaded data from pickle" #OPTIONAL: save loaded/pre-processed data to a pickle to save time in the future ''' print "saving preprocessed data to hdf5 file" f=h5py.File('imagenet.hdf5','w') dset_xtrain=f.create_dataset("X_train",data=X_train) dset_ytrain=f.create_dataset("Y_train",data=Y_train) dset_xvalid=f.create_dataset("X_valid",data=X_valid) dset_yvalid=f.create_dataset("Y_valid",data=Y_valid) dset_xtest=f.create_dataset("X_test",data=X_test) f.flush() f.close() print "done saving pre-processed data to hdf5 file!" ''' #train a VGG-like convent vgg_model,history=vgg_train(X_train,Y_train) train_scores=vgg_evaluate(vgg_model,X_train,Y_train) print "VGG-like net training scores:"+str(train_scores) valid_scores=vgg_evaluate(vgg_model,X_valid,Y_valid) print "VGG-like net validation scores:"+str(valid_scores) #Visualize the pretty model plot(vgg_model,to_file="vgg_like_convnet.png") predictions=vgg_model.predict(X_test,verbose=1) class_predictions=vgg_model.predict_classes(X_test) #save all the outputs! sys.setrecursionlimit(50000) output=open('vgg_like_results.pkl','w') pickle.dump(history,output) pickle.dump(train_scores,output) pickle.dump(valid_scores,output) pickle.dump(predictions,output) pickle.dump(class_predictions,output) output.close() #train a Keras version of the ConvNet implemented in Assignment#2 in class #TODO #train AlexNet '''
def train_and_predict(): imgs_train, imgs_output_train = load_train_data() imgs_train = imgs_train.astype('float32') mean = np.mean(imgs_train) # mean for data centering std = np.std(imgs_train) # std for data normalization imgs_train -= mean imgs_train /= std imgs_output_train = imgs_output_train.astype('float32') imgs_output_train /= 255. # scale outputs to [0, 1] imgs_test, imgs_output_test = load_test_data() imgs_test = imgs_test.astype('float32') imgs_test -= mean imgs_test /= std imgs_output_test = imgs_output_test.astype('float32') imgs_output_test /= 255. # scale outputs to [0, 1] print('-'*30) print('Creating and compiling model...') print('-'*30) model = get_unet() model_checkpoint = ModelCheckpoint('unet.hdf5', monitor='val_loss', save_best_only=True ) print('-'*30) print('Fitting model...') print('-'*30) earlyStopping=EarlyStopping(monitor='val_loss', patience=20, verbose=0, mode='auto') model.fit(imgs_train, imgs_output_train, batch_size=16, nb_epoch=100, verbose=1, callbacks=[model_checkpoint, earlyStopping], validation_split=0.1, validation_data=None, shuffle=True) print('-'*30) print('Loading saved weights...') print('-'*30) model.load_weights('unet.hdf5') print('-'*30) print('Predicting outputs on test data...') print('-'*30) imgs_output_test2 = model.predict(imgs_test, verbose=1) np.save('imgs_output_test2.npy', imgs_output_test2) print('-'*30) print('Evaluating test loss...') print('-'*30) score = model.evaluate(imgs_test, imgs_output_test, batch_size=16) print(score) print('-'*30) print('Ploting model...') print('-'*30) plot(model, to_file='model.png')
def plot_model(self, filename='brnn_model.png'): """ Plot model. Arguments: filename: {string}, the name/path to the file to which the weights are going to be plotted. """ print "Plot Model %s ..." %filename plot(self.model, to_file=filename)
def write_model_graph(self): model = self.create_model() # write dot text to file with open(config["model_dot"], "wb") as out: m = model_to_dot(model) dot_text = m.create_dot() out.write(dot_text) print("Wrote .dot to {}".format(config["model_dot"])) # write graph to file plot(model, to_file=config["model_graph"], show_shapes=True)
def plot_model(self, filename): """ Plot model. Arguments: filename: {string}, the name/path to the file to which the model graphic is plotted. """ print "Plot Model %s ..." %filename plot(self.model, to_file=filename)
def draw_model(model): from IPython.display import SVG from keras.utils.visualize_util import to_graph from keras.utils.visualize_util import plot #graph = to_graph(model, show_shape=True) #graph.write_png("UFCNN_1.png") SVG(to_graph(model).create(prog='dot', format='svg')) plot(model, to_file='UFCNN_1.png')
def build(self): enc_size = self.size_of_env_observation() argument_size = IntegerArguments.size_of_arguments input_enc = InputLayer(batch_input_shape=(self.batch_size, enc_size), name='input_enc') input_arg = InputLayer(batch_input_shape=(self.batch_size, argument_size), name='input_arg') input_prg = Embedding(input_dim=PROGRAM_VEC_SIZE, output_dim=PROGRAM_KEY_VEC_SIZE, input_length=1, batch_input_shape=(self.batch_size, 1)) f_enc = Sequential(name='f_enc') f_enc.add(Merge([input_enc, input_arg], mode='concat')) f_enc.add(MaxoutDense(128, nb_feature=4)) self.f_enc = f_enc program_embedding = Sequential(name='program_embedding') program_embedding.add(input_prg) f_enc_convert = Sequential(name='f_enc_convert') f_enc_convert.add(f_enc) f_enc_convert.add(RepeatVector(1)) f_lstm = Sequential(name='f_lstm') f_lstm.add(Merge([f_enc_convert, program_embedding], mode='concat')) f_lstm.add(LSTM(256, return_sequences=False, stateful=True, W_regularizer=l2(0.0000001))) f_lstm.add(Activation('relu', name='relu_lstm_1')) f_lstm.add(RepeatVector(1)) f_lstm.add(LSTM(256, return_sequences=False, stateful=True, W_regularizer=l2(0.0000001))) f_lstm.add(Activation('relu', name='relu_lstm_2')) # plot(f_lstm, to_file='f_lstm.png', show_shapes=True) f_end = Sequential(name='f_end') f_end.add(f_lstm) f_end.add(Dense(1, W_regularizer=l2(0.001))) f_end.add(Activation('sigmoid', name='sigmoid_end')) f_prog = Sequential(name='f_prog') f_prog.add(f_lstm) f_prog.add(Dense(PROGRAM_KEY_VEC_SIZE, activation="relu")) f_prog.add(Dense(PROGRAM_VEC_SIZE, W_regularizer=l2(0.0001))) f_prog.add(Activation('softmax', name='softmax_prog')) # plot(f_prog, to_file='f_prog.png', show_shapes=True) f_args = [] for ai in range(1, IntegerArguments.max_arg_num+1): f_arg = Sequential(name='f_arg%s' % ai) f_arg.add(f_lstm) f_arg.add(Dense(IntegerArguments.depth, W_regularizer=l2(0.0001))) f_arg.add(Activation('softmax', name='softmax_arg%s' % ai)) f_args.append(f_arg) # plot(f_arg, to_file='f_arg.png', show_shapes=True) self.model = Model([input_enc.input, input_arg.input, input_prg.input], [f_end.output, f_prog.output] + [fa.output for fa in f_args], name="npi") self.compile_model() plot(self.model, to_file='model.png', show_shapes=True)
def presave(self, model_directory): """ Save the model architecture to the given directory. :param model_directory: Directory to save model and weights. :return: """ try: open(os.path.join(model_directory, self.__architecture_name), 'w').write(self.model.to_json(indent=2)) except Exception as e: self.logger.warn("Model structure is not saved due to: %s" % repr(e)) plot(self.model, to_file=os.path.join(model_directory, self.__model_graph_name))
def visualize_model(args): model = MoleculeVAE() data, charset = load_dataset(args.data, split = False) if os.path.isfile(args.model): model.load(charset, args.model) else: raise ValueError("Model file %s doesn't exist" % args.model) plot(model.autoencoder, to_file = args.outfile)
def main(): # init----------------------------------------------------------------- train_samples = dtp.sample_paths_from_list(DATA_LOC, LIST_LOC+TRAIN_LIST) eval_samples = dtp.sample_paths_from_list(DATA_LOC, LIST_LOC+EVAL_LIST) classes = open(DICT, 'r+').read().splitlines() nb_classes = len(classes) batch_size = 180 # load pretrained models---------------------------------------------------- pretrained = load_model(PRETRAINED_LOC, PRETRAINED_NAME) # generate RGB stream model------------------------------------------------------ if not model_exist(RGB_MODEL_NAME): print 'Training RGB stream model...\n' rgb_stream = eitel.create_single_stream(nb_classes, pretrained, tag='_rgb') plot(rgb_stream, 'stream_model.png') rgb_stream = train_model(rgb_stream, 0, batch_size, train_samples, eval_samples, classes) if SAVE_MODEL: save_model(rgb_stream, RGB_MODEL_NAME) del rgb_stream else: print 'RGB stream model already exists...' # generate RGB stream model------------------------------------------------------ if not model_exist(DEP_MODEL_NAME): print 'Training depth stream model...\n' dep_stream = eitel.create_single_stream(nb_classes, pretrained, tag='_dep') dep_stream = train_model(dep_stream, 1, batch_size, train_samples, eval_samples, classes) if SAVE_MODEL: save_model(dep_stream, DEP_MODEL_NAME) del dep_stream else: print 'Depth stream model already exists...' # reload the model weights---------------------------------------------------- print 'Loading weights...' rgb_stream = load_model(MODEL_LOC, RGB_MODEL_NAME) dep_stream = load_model(MODEL_LOC, DEP_MODEL_NAME) # fusion model----------------------------------------------------------- print 'Fusing stream models...' fusion_model = eitel.create_model_merge(rgb_stream, dep_stream, nb_classes) del rgb_stream del dep_stream plot(fusion_model, 'fusion_model.png') batch_size=200 fusion_model = train_model(fusion_model, 2, batch_size, train_samples, eval_samples, classes) if SAVE_MODEL: save_model(fusion_model, FUS_MODEL_NAME)
def train_network(X, Y, epochs=1, train=True, filename=None, load_model=False, finetune=False, task_id=None, independent=False): global model, history if load_model: print('Loading model') input_model = open(filename[0], 'r') model = model_from_json(input_model.read()) input_model.close() model.compile(optimizer='rmsprop', loss='categorical_crossentropy') model.load_weights(filename[1]) print('Loaded(probably)') if finetune: lastLayer = None print(model.layers[0].__dict__) for layer in model.layers: if (layer.name == 'dense_1'): nn.conv = layer lastLayer = layer import h5py if not load_model or finetune: X, Y, _ = transform_data(X, Y, task_id) print('Labels shape: ' + str(Y.shape)) print('Labels look like this : ') print(Y[0]) if not finetune: nn.construct_model(X[0].shape) nn.add_new_task(len(Y[0]), independent) model = nn.get_model().model if train: print('Training started') input_model = open(filename[0], 'w') input_model.write(model.to_json()) input_model.close() # model.summary() from keras.utils.visualize_util import plot plot(model, to_file='model.png') print('Fitting') history = nn.get_model().fit(X, Y, epoch=epochs) task_dims.append(Y.shape[1]) print('Training end') if filename is not None: input_model = open(filename[0], 'w') input_model.write(model.to_json()) input_model.close() model.save_weights(filename[1], overwrite=True)
def save_network(model, problem_name, operation_name, network_name): """ saves the given network as a PNG image. Args: model: The Keras Suequential model. problem_name: The name of target problem. operation_name: The name of arithmetic operation. network_name: The name of the network. """ model_name = problem_name + "_" + operation_name + network_name plot(model, to_file=model_name + ".png", show_shapes=True)
def SA_sst(): ((x_train_idx_data, y_train_valence, y_train_labels, x_test_idx_data, y_test_valence, y_test_labels, x_valid_idx_data, y_valid_valence, y_valid_labels, x_train_polarity_idx_data, y_train_polarity, x_test_polarity_idx_data, y_test_polarity, x_valid_polarity_idx_data, y_valid_polarity), W) = nn_input() # build_keras_input_amended or build_keras_input maxlen = 200 # cut texts after this number of words (among top max_features most common words) batch_size = 16 (X_train, y_train), (X_test, y_test), (X_valid, y_valide) = (x_train_polarity_idx_data, y_train_polarity), ( x_test_polarity_idx_data, y_test_polarity), (x_valid_polarity_idx_data, y_valid_polarity) print(len(X_train), 'train sequences') print(len(X_test), 'test sequences') # m= 0 # for i in X_train: # if len(i) >0: # for j in i: # if j > m: # m=j # print(m) max_features = W.shape[0] # shape of W: (13631, 300) , changed to 14027 through min_df = 3 print("Pad sequences (samples x time)") X_train = sequence.pad_sequences(X_train, maxlen=maxlen) X_test = sequence.pad_sequences(X_test, maxlen=maxlen) X_valid = sequence.pad_sequences(X_valid, maxlen=maxlen) print('X_train shape:', X_train.shape) print('X_test shape:', X_test.shape) nb_classes = 2 y_train = np_utils.to_categorical(y_train, nb_classes) y_test = np_utils.to_categorical(y_test, nb_classes) y_valide = np_utils.to_categorical(y_valide, nb_classes) model = Deep_CNN(W) plot(model, to_file='./images/model.png') # try using different optimizers and different optimizer configs # model.compile(loss='binary_crossentropy', optimizer='adagrad', class_mode="binary") sgd = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer='adagrad') # adagrad print("Train...") early_stopping = EarlyStopping(monitor='val_loss', patience=5) model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=20, validation_data=(X_test, y_test), show_accuracy=True, callbacks=[early_stopping]) score, acc = model.evaluate(X_test, y_test, batch_size=batch_size, show_accuracy=True) print('Test score:', score) print('Test accuracy:', acc)
def check_print(): # Create the Model x, img_input, CONCAT_AXIS, INP_SHAPE, DIM_ORDERING = create_model() # Create a Keras Model - Functional API model = Model(input=img_input, output=[x]) model.summary() # Save a PNG of the Model Build plot(model, to_file='./Model/AlexNet.png') model.compile(optimizer='rmsprop', loss='categorical_crossentropy') print('Model Compiled')
def createModel(settings, createPlot): print("Building Model...") model = Sequential() # if (settings.depth > 1): model.add(LSTM(settings.hiddenNodes, return_sequences=True, input_shape=(settings.sequence_size, settings.N_values))) model.add(Dropout(settings.dropoutAmount)) # else: # model.add(LSTM(settings.hiddenNodes, return_sequences=False, input_shape=(settings.sequence_size, settings.N_values))) # inner_init='orthogonal' # model.add(Dropout(settings.dropoutAmount)) for i in range(1, settings.depth-1): model.add(LSTM(settings.hiddenNodes, return_sequences=True)) model.add(Dropout(settings.dropoutAmount)) model.add(LSTM(settings.hiddenNodes, return_sequences=False)) model.add(Dropout(settings.dropoutAmount)) # model.add(LSTM(settings.hiddenNodes, return_sequences=False, input_shape=(settings.sequence_size, settings.N_values))) # model.add(LSTM(settings.hiddenNodes, return_sequences=True)) # model.add(LSTM(settings.hiddenNodes, return_sequences=True)) # model.add(LSTM(settings.hiddenNodes, return_sequences=True)) # model.add(LSTM(settings.hiddenNodes, return_sequences=False)) if (settings.l1Amount > 0): model.add(Dense(settings.N_values, W_regularizer=l1(settings.l1Amount))) elif settings.l2Amount > 0: model.add(Dense(settings.N_values, W_regularizer=l2(settings.l2Amount))) else: model.add(Dense(settings.N_values)) model.add(Activation(settings.activation)) model.compile(loss=settings.lossType, optimizer=settings.optimizer) settings.filename = settings.activation + "_" + settings.trainingset + "_nodes" + str(settings.hiddenNodes) +"_depth" + str(settings.depth) + "_seq" + str(settings.sequence_size) + "_drop" + str(settings.dropoutAmount) + "_L1r" + str(settings.l1Amount) + "_L2r" + str(settings.l2Amount) save_model_scratch(model, settings.filename, 0, False) with open('/var/scratch/jvranken/models/' + settings.filename + '/model_settings.txt', 'w') as settingsFile: for (setting, value) in vars(settings).items(): settingsFile.write(setting + ': ' + str(value) + '\n') if createPlot: plot(model, to_file='/var/scratch/jvranken/models/' + settings.filename + '/model_layout.png', show_shapes=True) return model
def train(x_train, y_train, x_test, y_test, vocab_size): model = Sequential() model.add(Embedding(vocab_size, 128, input_length=maxlen, dropout=0.5, mask_zero = True)) model.add(LSTM(128, dropout_W=0.5, dropout_U=0.1)) # try using a GRU instead, for fun model.add(Dropout(0.5)) model.add(Dense(vocab_size)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') print('Train...') batch_size = 32 plot(model, to_file='model.png', show_shape = True) model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=15, validation_data=(x_test, y_test), show_accuracy=True) score, acc = model.evaluate(x_test, y_test, batch_size=batch_size, show_accuracy=True) print('Test score:', score) print('Test accuracy:', acc)
dp2 = Dropout(0.5)(fc2) output = Dense(1)(dp2) model = Model(input=[uinput, iinput], output=output) sgd = SGD(lr=0.05, decay=1e-6, momentum=0.9, nesterov=True) # model.compile(optimizer=sgd, # loss='mse') model.compile(optimizer='adam', loss='mse') model_name = 'mlp.hdf5' model_checkpoint = ModelCheckpoint(path + model_name, monitor='val_loss', save_best_only=True) plot(model, to_file=path + '%s.png' % model_name.replace('.hdf5', ''), show_shapes=True) nb_epoch = 5 batch_size = 1024 * 6 load_model = False if load_model: model.load_weights(path + model_name) model.fit([u_train, i_train], y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=True,
x[1, :, :] -= 116.779 x[2, :, :] -= 123.68 else: # 'RGB'->'BGR' x = x[:, :, ::-1] # Zero-center by mean pixel x[:, :, 0] -= 103.939 x[:, :, 1] -= 116.779 x[:, :, 2] -= 123.68 return x # create the base pre-trained model base_model = VGG16(weights='imagenet') plot(base_model, to_file='./results/modelVGG16a.png', show_shapes=True, show_layer_names=True) x = base_model.get_layer('fc2').output x = base_model.layers[-2].output # x = base_model.get_layer('block5_pool').output # x = Flatten(name='flat')(x) # x = Dense(4096, activation='relu', name='fc')(x) x = Dense(8, activation='softmax', name='predictions')(x) model = Model(input=base_model.input, output=x) plot(model, to_file='./results/modelVGG16b.png', show_shapes=True, show_layer_names=True) for layer in base_model.layers:
def train(self, max_sent_len, train_inputs, train_labels, num_epochs=20, mlp_size=1024, mlp_activation='relu', dropout=None, embedding_file=None, tune_embedding=True, num_mlp_layers=2, batch=None, patience=5): ''' train_inputs (list(numpy_array)): The two sentence inputs train_labels (numpy_array): One-hot matrix indicating labels num_epochs (int): Maximum number of epochs to run mlp_size (int): Dimensionality of each layer in the MLP dropout (dict(str->float)): Probabilities in Dropout layers after "embedding" and "encoder" (lstm) embedding (numpy): Optional pretrained embedding tune_embedding (bool): If pretrained embedding is given, tune it. patience (int): Early stopping patience ''' if dropout is None: dropout = {} num_label_types = train_labels.shape[ 1] # train_labels is of shape (num_samples, num_label_types) sent1_input_layer = Input(name='sent1', shape=train_inputs[0].shape[1:], dtype='int32') sent2_input_layer = Input(name='sent2', shape=train_inputs[1].shape[1:], dtype='int32') encoded_sent1, encoded_sent2 = self._get_encoded_sentence_variables( max_sent_len, sent1_input_layer, sent2_input_layer, dropout, embedding_file, tune_embedding, batch=32 if batch == None else batch) concat_sent_rep = merge([encoded_sent1, encoded_sent2], mode='concat') mul_sent_rep = merge([encoded_sent1, encoded_sent2], mode='mul') diff_sent_rep = merge([encoded_sent1, encoded_sent2], mode=lambda l: l[0] - l[1], output_shape=lambda l: l[0]) # Use heuristic from Mou et al. (2015) to get final merged representation merged_sent_rep = merge([concat_sent_rep, mul_sent_rep, diff_sent_rep], mode='concat') current_projection = merged_sent_rep for i in range(num_mlp_layers): mlp_layer_i = Dense(output_dim=mlp_size, activation=mlp_activation, name="%s_layer_%d" % (mlp_activation, i)) current_projection = mlp_layer_i(current_projection) if dropout is not None: if "output" in dropout: current_projection = Dropout( dropout["output"])(current_projection) softmax = Dense(output_dim=num_label_types, activation='softmax', name='softmax_layer') label_probs = softmax(current_projection) model = Model(input=[sent1_input_layer, sent2_input_layer], output=label_probs) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) self.model = model print >> sys.stderr, "Entailment model summary:" model.summary() plot(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True) best_accuracy = 0.0 num_worse_epochs = 0 for epoch_id in range(num_epochs): print >> sys.stderr, "Epoch: %d" % epoch_id history = model.fit(train_inputs, train_labels, validation_split=0.1, nb_epoch=1) validation_accuracy = history.history['val_acc'][ 0] # history['val_acc'] is a list of size nb_epoch if validation_accuracy > best_accuracy: self.save_model(epoch_id) self.best_epoch = epoch_id num_worse_epochs = 0 best_accuracy = validation_accuracy elif validation_accuracy < best_accuracy: num_worse_epochs += 1 if num_worse_epochs >= patience: print >> sys.stderr, "Stopping training." break self.save_best_model()
import argparse from keras.models import model_from_json from keras.utils.visualize_util import plot if __name__ == '__main__': parser = argparse.ArgumentParser(description='Network visualization') parser.add_argument( 'model', type=str, help= 'Path to model definition json. Model weights should be on the same path.' ) args = parser.parse_args() with open(args.model, 'r') as jfile: # NOTE: if you saved the file by calling json.dump(model.to_json(), ...) # then you will have to call: # # model = model_from_json(json.loads(jfile.read()))\ # # instead. model = model_from_json(jfile.read()) model.compile("adam", "mse") plot(model, show_shapes=True, to_file='img/model.png')
def main(): emotion_classifier = load_model(model_path) emotion_classifier.summary() plot(emotion_classifier, to_file='model.png')
model.add(Permute((2,1,3,4))) print(model.layers[6].output_shape) model.add(Reshape((100,16*5*4))) model.add(LSTM(128,return_sequences=True)) model.add(LSTM(128,return_sequences=True)) model.add(Flatten()) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.summary() modelname = 'cube_cnn_2l_tmr_filtered' plot(model, to_file='/media/kong/9A8821088820E48B/Xcat/experiment/BCI2008/ds1a/model/arange_pole/'+modelname+'.png', show_shapes=True) opt = Adam() model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) checkpointer = ModelCheckpoint(filepath='/media/kong/9A8821088820E48B/Xcat/experiment/BCI2008/ds1a/model/arange_pole/'+modelname+'.h5',verbose=1,save_best_only=True, monitor='val_acc') model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(X_test, Y_test), callbacks=[checkpointer]) #model.save('/home/xcat/MasterPaper/model/' + modelname + '.h5') score = model.evaluate(X_test, Y_test, verbose=0) print('Test score:', score[0]) print('Test accuracy:', score[1])
border_mode='valid', input_shape=(1, img_rows, img_cols), # W_regularizer = l1l2ld(l1 = 0., l2 = 0., ld = 0.), W_regularizer=l2(l=0.), b_regularizer=l2(l=0.))) # model.add(AveragePooling2D(pool_size=(5, 5))) # model.add(Dropout(0.25)) model.add(Flatten()) # model.add(Dense(128)) # model.add(Activation('relu')) # model.add(Dropout(0.5)) model.add(Dense(nb_classes, W_regularizer=l2(l=0.), b_regularizer=l2(l=0.))) model.add(Activation('softmax')) plot(model, to_file="./mnist.png", show_shapes=True) # sys.exit() for i in range(len(model.layers)): print("i: ", i) print(model.layers[i].get_config()) # sys.exit() model.compile(loss='categorical_crossentropy', optimizer='adadelta', metrics=['accuracy']) model.fit(X_train, Y_train, batch_size=batch_size,
def build_resnet_152(input_shape, num_outputs): return ResNetBuilder.build(input_shape, num_outputs, bottleneck, [3, 8, 36, 3]) # Define resnet model between 18, 34, 50, 101 or 152 model = ResNetBuilder.build_resnet_18((3, img_width, img_height), 1) print('-'*30) print('Model summary...') print('-'*30) model.summary() if(PRINT_MODEL): print('-'*30) print('Printing model...') print('-'*30) plot(model, to_file='resnet50_keras_model.png') model.compile(loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) # this is the augmentation configuration we will use for training train_datagen = ImageDataGenerator( rescale=1./255, shear_range=0, rotation_range=40, # randomly rotate images in the range (degrees, 0 to 180) width_shift_range=0.2, # randomly shift images horizontally (fraction of total width) height_shift_range=0.2, # randomly shift images vertically (fraction of total height) zoom_range=0.2, horizontal_flip=True, # randomly flip images vertical_flip=False) # randomly flip images
net['conv8_2_mbox_priorbox'], net['pool6_mbox_priorbox'] ], mode='concat', concat_axis=1, name='mbox_priorbox') if hasattr(net['mbox_loc'], '_keras_shape'): num_boxes = net['mbox_loc']._keras_shape[-1] // 4 elif hasattr(net['mbox_loc'], 'int_shape'): num_boxes = K.int_shape(net['mbox_loc'])[-1] // 4 net['mbox_loc'] = Reshape((num_boxes, 4), name='mbox_loc_final')(net['mbox_loc']) net['mbox_conf'] = Reshape((num_boxes, num_classes), name='mbox_conf_logits')(net['mbox_conf']) net['mbox_conf'] = Activation('softmax', name='mbox_conf_final')(net['mbox_conf']) net['predictions'] = merge( [net['mbox_loc'], net['mbox_conf'], net['mbox_priorbox']], mode='concat', concat_axis=2, name='predictions') model = Model(net['input'], net['predictions']) return model if __name__ == "__main__": ssd = SSD512((512, 512, 3)) ssd.summary() from keras.utils.visualize_util import plot plot(ssd, to_file='ssd_model.png', show_layer_names=True, show_shapes=True)
question_net = Sequential() question_net.add(q_embedding_layer) # question_net.add(LSTM(EMBEDDING_DIM, consume_less='cpu')) # question_net.add(RepeatVector(400)) # question_net.add(Dense(EMBEDDING_DIM)) # question_net.add(Bidirectional(GRU(EMBEDDING_DIM))) # question_net.add(Activation('tanh')) # question_net.add(Dropout(0.1)) question_net.add(Bidirectional(LSTM(EMBEDDING_DIM, return_sequences=True))) # question_net.add(GRU(EMBEDDING_DIM, return_sequences=True)) # question_net.add(LSTM(EMBEDDING_DIM, return_sequences=True, consume_less='mem')) print("question layer shape:", question_net.layers[-1].output_shape) # question_net.add(Dense(1, activation='sigmoid')) plot(question_net, to_file='question_net.png', show_shapes=True) merged = Merge([passage_net, question_net], mode='dot') # merged = Merge([passage_net, question_net], mode='cos') print("merged layer shape:", question_net.layers[-1].output_shape) model = Sequential() model.add(merged) # multiply passage by the dot product # add softmax here # model.add(Dropout(.5)) # model.add(TimeDistributedDense(100, activation='softmax')) model.add(Permute((2, 1)))
print "-----------------" print(hist.history.get('loss')[-1]) print "-----------------" loss=hist.history.get('loss') acc=hist.history.get('acc') model.save('Share_Weight/model_122222.h5') np.save('Share_Weight/loss_122222.npy',loss) np.save('Share_Weight/acc_122222.npy',acc) sendEmail('Modelling Done') model=load_model('Share_Weight/model_122222.h5') loss=np.load('Share_Weight/loss_122222.npy') acc=np.load('Share_Weight/acc_122222.npy') plot(model, to_file='Share_Weight/TreeModel_122222.png') rangeNum=300000 #300000(start——end)组算例 avgerr=np.zeros((rangeNum,len(opL))) preStart=200000 preNum=100000 print("predict") inputnum = len(input[0, :]) outputnumL = len(outputL[0, :]) outputnumR = len(outputR[0, :]) predictend = preStart + preNum # 真实数据作为测试输入 testinput = data[preStart:predictend, ip] # 真实数据作为输出,用来对比效果
conv2 = Convolution2D(nb_filters, kernel_size_2[0], kernel_size_2[1], border_mode='same') model.add(conv2) model.add(Activation('relu')) pool2 = MaxPooling2D(pool_size=pool_size_2) model.add(pool2) model.add(Flatten()) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.summary() modelname = '2cnn_adam_max_relu' plot(model, to_file='/home/xcat/experiment/BCI2008/ds1a/model/on-filtered-data/'+modelname+'.png', show_shapes=True) opt = Adam() model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) checkpointer = ModelCheckpoint(filepath='/home/xcat/experiment/BCI2008/ds1a/model/on-filtered-data/'+modelname+'.h5',verbose=1,save_best_only=True, monitor='val_acc') model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=2, validation_data=(X_test, Y_test), callbacks=[checkpointer]) #model.save('/home/xcat/MasterPaper/model/' + modelname + '.h5') score = model.evaluate(X_test, Y_test, verbose=0) print('Test score:', score[0]) print('Test accuracy:', score[1])
def convNet_LeNet( VERBOSE=1, # normlize NORMALIZE = True, # Network Parameters BATCH_SIZE = 128, NUM_EPOCHS = 20, # Number of convolutional filters NUM_FILTERS = 32, # side length of maxpooling square NUM_POOL = 2, # side length of convolution square NUM_CONV = 3, # dropout rate for regularization DROPOUT_RATE = 0.5, # hidden number of neurons first layer NUM_HIDDEN = 128, # validation data VALIDATION_SPLIT=0.2, # 20% # optimizer used OPTIMIZER = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True), # regularization REGULARIZER = l2(0.01) ): # Output classes, number of MINST DIGITS NUM_CLASSES = 10 # Shape of an MINST digit image SHAPE_X, SHAPE_Y = 28, 28 # Channels on MINST IMG_CHANNELS = 1 # LOAD the MINST DATA split in training and test data (X_train, Y_train), (X_test, Y_test) = mnist.load_data() X_train = X_train.reshape(X_train.shape[0], 1, SHAPE_X, SHAPE_Y) X_test = X_test.reshape(X_test.shape[0], 1, SHAPE_X, SHAPE_Y) # convert in float32 representation for GPU computation X_train = X_train.astype("float32") X_test = X_test.astype("float32") if (NORMALIZE): # NORMALIZE each pixerl by dividing by max_value=255 X_train /= 255 X_test /= 255 print('X_train shape:', X_train.shape) print(X_train.shape[0], 'train samples') print(X_test.shape[0], 'test samples') # KERAS needs to represent each output class into OHE representation Y_train = np_utils.to_categorical(Y_train, NUM_CLASSES) Y_test = np_utils.to_categorical(Y_test, NUM_CLASSES) nn = Sequential() #FIRST LAYER OF CONVNETS, POOLING, DROPOUT # apply a NUM_CONV x NUM_CONF convolution with NUM_FILTERS output # for the first layer it is also required to define the input shape # activation function is rectified linear nn.add(Convolution2D(NUM_FILTERS, NUM_CONV, NUM_CONV, input_shape=(IMG_CHANNELS, SHAPE_X, SHAPE_Y) )) nn.add(Activation('relu')) nn.add(Convolution2D(NUM_FILTERS, NUM_CONV, NUM_CONV)) nn.add(Activation('relu')) nn.add(MaxPooling2D(pool_size = (NUM_POOL, NUM_POOL))) nn.add(Dropout(DROPOUT_RATE)) #SECOND LAYER OF CONVNETS, POOLING, DROPOUT # apply a NUM_CONV x NUM_CONF convolution with NUM_FILTERS output nn.add(Convolution2D( NUM_FILTERS, NUM_CONV, NUM_CONV)) nn.add(Activation('relu')) nn.add(Convolution2D(NUM_FILTERS, NUM_CONV, NUM_CONV)) nn.add(Activation('relu')) nn.add(MaxPooling2D(pool_size = (NUM_POOL, NUM_POOL) )) nn.add(Dropout(DROPOUT_RATE)) # FLATTEN the shape for dense connections nn.add(Flatten()) # FIRST HIDDEN LAYER OF DENSE NETWORK nn.add(Dense(NUM_HIDDEN)) nn.add(Activation('relu')) nn.add(Dropout(DROPOUT_RATE)) # OUTFUT LAYER with NUM_CLASSES OUTPUTS # ACTIVATION IS SOFTMAX, REGULARIZATION IS L2 nn.add(Dense(NUM_CLASSES, W_regularizer=REGULARIZER)) nn.add(Activation('softmax') ) #summary nn.summary() #plot the model plot(nn) # set an early-stopping value early_stopping = EarlyStopping(monitor='val_loss', patience=2) # COMPILE THE MODEL # loss_function is categorical_crossentropy # optimizer is parametric nn.compile(loss='categorical_crossentropy', optimizer=OPTIMIZER, metrics=["accuracy"]) start = time.time() # FIT THE MODEL WITH VALIDATION DATA fitlog = nn.fit(X_train, Y_train, \ batch_size=BATCH_SIZE, nb_epoch=NUM_EPOCHS, \ verbose=VERBOSE, validation_split=VALIDATION_SPLIT, \ callbacks=[early_stopping]) elapsed = time.time() - start # Test the network results = nn.evaluate(X_test, Y_test, verbose=VERBOSE) print('accuracy:', results[1]) # just to get the list of input parameters and their value frame = inspect.currentframe() args, _, _, values = inspect.getargvalues(frame) # used for printing pretty arguments print_Graph(fitlog, elapsed, args, values) return fitlog
model.add(Flatten()) model.add(Dropout(0.1)) model.add(Dense(150)) model.add(Dense(50)) model.add(Dense(10)) model.add(Dense(1)) model.compile(loss='mse', optimizer='adam') history_object = model.fit_generator(train_generator, samples_per_epoch = \ len(train_samples) * 6, validation_data=validation_generator, \ nb_val_samples=len(validation_samples) * 6, nb_epoch=5) model.save('model.h5') print(history_object.history.keys()) # plot the training and validation loss for each epoch plt.plot(history_object.history['loss']) plt.plot(history_object.history['val_loss']) plt.title('model mean squared error loss') plt.grid() plt.ylabel('mean squared error loss') plt.xlabel('epoch') plt.legend(['training set', 'validation set'], loc='upper right') plt.savefig('training.png') plt.show() # plot the CNN architecture plot(model, to_file='model.png')
name="encode1") encode1_tensor = encode1_layer(raw_input_tensor) decode1_layer = Dense(output_dim=args.patch_length * 2, activation='linear', name="decode1") decode1_tensor = decode1_layer(encode1_tensor) # First model is input -> encode1 -> decode1: autoencoder1 = Model(input=raw_input_tensor, output=decode1_tensor) autoencoder1.compile(optimizer='adadelta', loss='mse') if args.net_plot: pngname = '%s/keras_autoencoder1.png' % (args.output_dir, ) epsname = '%s/keras_autoencoder1.eps' % (args.output_dir, ) print("Saving %s..." % (pngname, )) plot(autoencoder1, to_file=pngname, show_shapes=True) print("Saving %s..." % (epsname, )) plot(autoencoder1, to_file=epsname, show_shapes=True) if train_net: # Train first autoencoder on raw input. autoencoder1.fit(x_train, x_train, nb_epoch=500, batch_size=256, shuffle=True, validation_data=(x_val, x_val)) # Stack the 2nd autoencoder (connecting to encode1): encode2_layer = Dense(hidden2, activation='sigmoid',
x = MaxPooling2D((2,2))(x) for i in range(N): x = conv3_block(x, k, dropout) nb_conv += 2 x = AveragePooling2D((8,8))(x) x = Flatten()(x) x = Dense(nb_classes, activation='softmax')(x) model = Model(ip, x) if verbose: print("Wide Residual Network-%d-%d created." % (nb_conv, k)) return model if __name__ == "__main__": from keras.utils.visualize_util import plot from keras.layers import Input from keras.models import Model init = (3, 32, 32) wrn_28_10 = create_wide_residual_network(init, nb_classes=100, N=4, k=10, dropout=0.25) model = Model(init, wrn_28_10) model.summary() plot(model, "WRN-28-10.png", show_shapes=True, show_layer_names=True)
type=str, help='Path to model h5 file. Model should be on the same path.') parser.add_argument( 'image_folder', type=str, nargs='?', default='', help= 'Path to image folder. This is where the images from the run will be saved.' ) args = parser.parse_args() # check that model Keras version is same as local Keras version f = h5py.File(args.model, mode='r') model_version = f.attrs.get('keras_version') keras_version = str(keras_version).encode('utf8') if model_version != keras_version: print('You are using Keras version ', keras_version, ', but the model was built using ', model_version) model = load_model(args.model) if not pydot.find_graphiz(): raise ImportError('Install pydot and graphviz.') else: plot(model, to_file='model.png', show_shapes=True, show_layer_names=False)
x=Activation('relu')(x) seq_output=Flatten()(x) print('INFO - %s'%('building concatenate model.')) units=512 x=Merge(mode='concat',concat_axis=1)([reg_output,seq_output]) x=Dense(units,activation='relu')(x) x=Dropout(0.5,seed=42)(x) x=Dense(units,activation='relu')(x) x=Dropout(0.5,seed=42)(x) rgs_output=Dense(1,activation='linear',name='rgs_output')(x) model=Model(input=[reg_input,seq_input],output=[rgs_output]) model.compile(loss={'rgs_output':'mean_squared_error'},optimizer='sgd') plot(model, show_shapes=True,to_file='%s/model.eps'%(fig_dir)) print('INFO - %s'%('loading data.')) train,val,test=input_data.read_data_sets(train_pct=80,val_pct=10,test_pct=10) print('INFO - %s'%('training model.')) reduce_lr=ReduceLROnPlateau(verbose=1,factor=0.5, patience=5) early_stopping=EarlyStopping(monitor='val_loss',patience=10) checkpoint=ModelCheckpoint(filepath="%s/model.{epoch:02d}-{val_loss:.4f}.hdf5"%(log_dir), monitor='val_loss') batchhistory=BatchHistory(val_data=val,loss_function='mse',every_n_batch=1000) history=model.fit({'seq_input':train['seq'],'reg_input':train['reg']},{'rgs_output':train['expr']}, validation_data=({'seq_input':val['seq'],'reg_input':val['reg']},{'rgs_output':val['expr']}), nb_epoch=100, batch_size=100, callbacks=[early_stopping,checkpoint,reduce_lr,batchhistory],
def train(): X = np.load('X_train.npy') y = np.load('y_train.npy') X = np.reshape(X, (30, 512, 512, 1)) # tf dim_ordering y = np.reshape(y, (30, 512, 512, 1)) # tf dim_ordering # Extend radius radius = 64 X = np.pad(X, ((0, 0), (radius, radius), (radius, radius), (0, 0)), 'reflect') # tf dim_ordering y = np.pad(y, ((0, 0), (radius, radius), (radius, radius), (0, 0)), 'reflect') # tf dim_ordering # Preprocess the label y = y / 255 y = y.astype('float32') X = X.astype('float32') # Merging 7 times X0 = X y0 = y X1 = X[::1, ::1, ::-1, ::1] y1 = y[::1, ::1, ::-1, ::1] X2 = X[::1, ::-1, ::1, ::1] y2 = y[::1, ::-1, ::1, ::1] X3 = np.transpose(X, (0, 2, 1, 3)) y3 = np.transpose(y, (0, 2, 1, 3)) X4 = scipy.ndimage.interpolation.rotate(X, angle=90, axes=(1, 2)) y4 = scipy.ndimage.interpolation.rotate(y, angle=90, axes=(1, 2)) X5 = scipy.ndimage.interpolation.rotate(X, angle=180, axes=(1, 2)) y5 = scipy.ndimage.interpolation.rotate(y, angle=180, axes=(1, 2)) X6 = scipy.ndimage.interpolation.rotate(X, angle=270, axes=(1, 2)) y6 = scipy.ndimage.interpolation.rotate(y, angle=270, axes=(1, 2)) X = np.concatenate((X0, X1, X2, X3, X4, X5, X6), axis=0) y = np.concatenate((y0, y1, y2, y3, y4, y5, y6), axis=0) ########## print("Y median", np.median(y)) print("X shape", X.shape) print("X dtype", X.dtype) print("Y shape", y.shape) print("Y dtype", y.dtype) nb_iter = 1001 epochs_per_iter = 2 batch_size = 1 print('-' * 30) print('Creating and compiling model...') print('-' * 30) model = get_uplusnet() model.reset_states() # model.load_weights("model_300.hdf5") # graph = to_graph(model, show_shape=True) # graph.write_png("model.png") plot(model, to_file='model.png', show_shapes=True) nb_folds = 3 # kfolds = KFold(len(y), nb_folds) kfolds = KFold(nb_folds) # Perform cross validation on the data for iter in range(nb_iter): print('-' * 50) print('Iteration {0}/{1}'.format(iter + 1, nb_iter)) print('-' * 50) # Shuffle the data print('Shuffle data...') seed = np.random.randint(1, 10e6) np.random.seed(seed) np.random.shuffle(X) np.random.seed(seed) np.random.shuffle(y) f = 0 for train, valid in kfolds.split(X): # for train, valid in kfolds: print('=' * 50) print('Fold', f + 1) f += 1 # Extract train, validation set X_train = X[train] X_valid = X[valid] y_train = y[train] y_valid = y[valid] print('Augmenting data for training...') X_train, y_train = augment_data( X_train, y_train) # Data augmentation for training X_valid, y_valid = augment_data( X_valid, y_valid) # Data augmentation for training print("X_train", X_train.shape) print("y_train", y_train.shape) # Normalize # X_train = X_train/255.0 # X_valid = X_valid/255.0 from keras.preprocessing.image import ImageDataGenerator train_datagen = ImageDataGenerator( featurewise_center=False, samplewise_center=True, featurewise_std_normalization=False, samplewise_std_normalization=True, rescale=1 / 255.0) train_datagen.fit(X_train) valid_datagen = ImageDataGenerator( featurewise_center=False, samplewise_center=True, featurewise_std_normalization=False, samplewise_std_normalization=True, rescale=1 / 255.0) valid_datagen.fit(X_valid) # checkpoint the best model filepath = "model-best.hdf5" checkpoint = ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min') callbacks_list = [ TensorBoard( log_dir='/home/Pearl/quantm/isbi12_210_keras_uplus/logs/') ] # datagen = ImageDataGenerator( # samplewise_center=True, # samplewise_std_normalization=True, # zca_whitening=True) history = model.fit(X_train, y_train, verbose=1, shuffle=True, nb_epoch=epochs_per_iter, batch_size=batch_size, callbacks=callbacks_list, validation_data=(X_valid, y_valid)) # history = model.fit_generator( # train_datagen.flow(X_train, y_train, batch_size=batch_size), # verbose=1, # samples_per_epoch=len(X_train), # nb_epoch=epochs_per_iter, # callbacks=callbacks_list, # validation_data=valid_datagen.flow(X_valid, y_valid, batch_size=batch_size), # nb_val_samples=len(X_valid) # ) # list all data in history # print(history.history.keys()) # Plot # # summarize history for accuracy # plt.plot(history.history['acc']) # plt.plot(history.history['val_acc']) # plt.title('model accuracy') # plt.ylabel('accuracy') # plt.xlabel('epoch') # plt.legend(['train', 'test'], loc='upper left') # plt.show() # summarize history for loss # plt.plot(history.history['loss']) # plt.plot(history.history['val_loss']) # plt.title('model loss') # plt.ylabel('loss') # plt.xlabel('epoch') # plt.legend(['train', 'test'], loc='upper left') # plt.show() if iter % 10 == 0: fname = 'models/model_%03d.hdf5' % (iter) model.save_weights(fname, overwrite=True)
from keras.applications.vgg16 import VGG16 from keras.preprocessing import image from keras.applications.vgg19 import preprocess_input from keras.models import Model from keras import backend as K from keras.utils.visualize_util import plot import numpy as np import matplotlib.pyplot as plt #load VGG model base_model = VGG16(weights='imagenet') #visalize topology in an image plot(base_model, to_file='modelVGG16.png', show_shapes=True, show_layer_names=True) #read and process image img_path = '/data/MIT/test/coast/art1130.jpg' img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) #crop the model up to a certain layer model = Model(input=base_model.input, output=base_model.get_layer('block5_conv2').output) #get the features from images features = model.predict(x) if K.image_dim_ordering() == 'th': #theano and thensorflow deal with tensor in different order weights = base_model.get_layer('block1_conv1').get_weights()
aux_out = Flatten()(aux_out) aux_out = Dense(nb_classes, activation='softmax')(aux_out) # Reduction Resnet B x = reduction_resnet_B(x) # 5 x Inception Resnet C for i in range(5): x = inception_resnet_C(x, scale_residual=scale) # Average Pooling x = AveragePooling2D((8,8))(x) # Dropout x = Dropout(0.8)(x) x = Flatten()(x) # Output out = Dense(output_dim=nb_classes, activation='softmax')(x) model = Model(init, output=[out, aux_out], name='Inception-Resnet-v1') return model if __name__ == "__main__": from keras.utils.visualize_util import plot inception_resnet_v1 = create_inception_resnet_v1() plot(inception_resnet_v1, to_file="Inception ResNet-v1.png", show_shapes=True)
logger.info('Initializing lookup table') emb_reader = EmbReader(emb_path, emb_dim=emb_dim) model_layer_index = 0 for test in model.layers: if (test.name == 'SplusEmbedding' or test.name == 'SminusEmbedding' or test.name == 'TplusEmbedding' or test.name == 'TminusEmbedding'): model.layers[model_layer_index].W.set_value( emb_reader.get_emb_matrix_given_vocab( vocab, model.layers[model_layer_index].W.get_value())) model_layer_index += 1 model.compile(loss=loss, optimizer=optimizer, metrics=[metric]) plot(model, to_file=out_dir + '/model.png') logger.info(' Done') ############################################################################################################################### ## Save model architecture # logger.info('Saving model architecture') with open(out_dir + '/model_arch.json', 'w') as arch: arch.write(model.to_json(indent=2)) logger.info( '---------------------------------------------------------------------------------------' )
if args.train is not None: do_training = True if args.model is not None: load_model = True model_to_load = args.model if args.epochs is not None: nb_epoch = args.epochs print("command line arguments") print(args) train_indices, validation_indices, test_indices, labels, filenames = load_data(fail_data, pass_data) model = qc_model() model.summary() plot(model, to_file="model.png") reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=4, min_lr=0.001) stop_early = EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=0, mode='auto') model_checkpoint = ModelCheckpoint(images_dir + "models/best_model.hdf5", monitor="val_acc", verbose=0, save_best_only=True, save_weights_only=False, mode='auto') hist = model.fit_generator(batch(train_indices, labels, 2,True), nb_epoch=400, samples_per_epoch=len(train_indices), validation_data=batch(validation_indices, labels, 2), nb_val_samples=len(validation_indices), callbacks=[model_checkpoint], class_weight = {0:.7, 1:.3}) model.load_weights(images_dir + 'models/best_model.hdf5') test_scores = [] sensitivities = [] specificities = []
import numpy as np from keras.models import Sequential from keras.layers import Dense, Activation from keras.utils.visualize_util import plot model = Sequential() model.add(Dense(32, input_dim=500)) model.add(Activation(activation='sigmoid')) model.add(Dense(1)) model.add(Activation(activation='sigmoid')) model.compile(optimizer='rmsprop', loss='mse', metrics=['mean_squared_error']) data = np.random.random((1000, 500)) labels = np.random.randint(2, size=(1000, 1)) score = model.evaluate(data, labels, verbose=0) print "Before Training:", zip(model.metrics_names, score) model.fit(data, labels, nb_epoch=10, batch_size=32, verbose=0) score = model.evaluate(data, labels, verbose=0) print "After Training:", zip(model.metrics_names, score) plot(model, to_file='s4.png', show_shapes=True) # Before Training: [('loss', 0.26870122766494753), ('mean_squared_error', 0.26870122766494753)] # After Training: [('loss', 0.22180086207389832), ('mean_squared_error', 0.22180086207389832)]
from keras.utils.visualize_util import plot from keras.models import load_model import argparse if __name__ == '__main__': parser = argparse.ArgumentParser(description='Network Diagram') parser.add_argument('-m', '--model', type=str, help='Path to h5 model file.') args = parser.parse_args() net = load_model(args.model) print("Writing out 'model.png'.") plot(net, to_file='model.png')
model.add(pool2) model.add(Permute((2, 1, 3))) model.add(Reshape((56, 40 * 56))) model.add(LSTM(128, return_sequences=True)) model.add(LSTM(128)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.summary() modelname = 'image-method' plot(model, to_file='/home/xcat/experiment/ImageNet/model/' + modelname + '.png', show_shapes=True) opt = Adam() model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) checkpointer = ModelCheckpoint( filepath='/home/xcat/experiment/ImageNet/model/' + modelname + 'h5', verbose=1, save_best_only=True, monitor='val_acc') model.fit(X_train, Y_train, batch_size=batch_size,
def run_cifar10(batch_size, nb_epoch, depth, nb_dense_block, nb_filter, growth_rate, dropout_rate, learning_rate, weight_decay, plot_architecture): """ Run CIFAR10 experiments :param batch_size: int -- batch size :param nb_epoch: int -- number of training epochs :param depth: int -- network depth :param nb_dense_block: int -- number of dense blocks :param nb_filter: int -- initial number of conv filter :param growth_rate: int -- number of new filters added by conv layers :param dropout_rate: float -- dropout rate :param learning_rate: float -- learning rate :param weight_decay: float -- weight decay :param plot_architecture: bool -- whether to plot network architecture """ ################### # Data processing # ################### # the data, shuffled and split between train and test sets (X_train, y_train), (X_test, y_test) = cifar10.load_data() nb_classes = len(np.unique(y_train)) img_dim = X_train.shape[1:] if K.image_dim_ordering() == "th": n_channels = X_train.shape[1] else: n_channels = X_train.shape[-1] # convert class vectors to binary class matrices Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) X_train = X_train.astype('float32') X_test = X_test.astype('float32') # Normalisation X = np.vstack((X_train, X_test)) # 2 cases depending on the image ordering if K.image_dim_ordering() == "th": for i in range(n_channels): mean = np.mean(X[:, i, :, :]) std = np.std(X[:, i, :, :]) X_train[:, i, :, :] = (X_train[:, i, :, :] - mean) / std X_test[:, i, :, :] = (X_test[:, i, :, :] - mean) / std elif K.image_dim_ordering() == "tf": for i in range(n_channels): mean = np.mean(X[:, :, :, i]) std = np.std(X[:, :, :, i]) X_train[:, :, :, i] = (X_train[:, :, :, i] - mean) / std X_test[:, :, :, i] = (X_test[:, :, :, i] - mean) / std ################### # Construct model # ################### model = densenet.DenseNet(nb_classes, img_dim, depth, nb_dense_block, growth_rate, nb_filter, dropout_rate=dropout_rate, weight_decay=weight_decay) # Model output model.summary() # Build optimizer opt = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=["accuracy"]) if plot_architecture: from keras.utils.visualize_util import plot plot(model, to_file='./figures/densenet_archi.png', show_shapes=True) #################### # Network training # #################### print("Training") list_train_loss = [] list_test_loss = [] list_learning_rate = [] for e in range(nb_epoch): if e == int(0.5 * nb_epoch): K.set_value(model.optimizer.lr, np.float32(learning_rate / 10.)) if e == int(0.75 * nb_epoch): K.set_value(model.optimizer.lr, np.float32(learning_rate / 100.)) split_size = batch_size num_splits = X_train.shape[0] / split_size arr_splits = np.array_split(np.arange(X_train.shape[0]), num_splits) l_train_loss = [] start = time.time() for batch_idx in arr_splits[:10]: X_batch, Y_batch = X_train[batch_idx], Y_train[batch_idx] train_logloss, train_acc = model.train_on_batch(X_batch, Y_batch) l_train_loss.append([train_logloss, train_acc]) test_logloss, test_acc = model.evaluate(X_test, Y_test, verbose=0, batch_size=64) list_train_loss.append(np.mean(np.array(l_train_loss), 0).tolist()) list_test_loss.append([test_logloss, test_acc]) list_learning_rate.append(float(K.get_value(model.optimizer.lr))) # to convert numpy array to json serializable print('Epoch %s/%s, Time: %s' % (e + 1, nb_epoch, time.time() - start)) d_log = {} d_log["batch_size"] = batch_size d_log["nb_epoch"] = nb_epoch d_log["optimizer"] = opt.get_config() d_log["train_loss"] = list_train_loss d_log["test_loss"] = list_test_loss d_log["learning_rate"] = list_learning_rate json_file = os.path.join('./log/experiment_log_cifar10.json') with open(json_file, 'w') as fp: json.dump(d_log, fp, indent=4, sort_keys=True)
def train(): # # SaveModel is a CallBack class that we can use to save the model for each epoch # This allows us to easily test each epoch on the simulator. The simulator seems like # a better validation than just the validation data set class SaveModel(Callback): def on_epoch_end(self, epoch, logs={}): epoch += 1 if (epoch > 0): #with open ('model-' + str(epoch) + '.json', 'w') as file: # file.write (model.to_json ()) # file.close () #model.save_weights ('model-' + str(epoch) + '.h5') model.save('model-' + str(epoch) + '.h5') # # load the model # model = get_model() # Keras has a nice tool to create an image of our network from keras.utils.visualize_util import plot plot(model, to_file='car_model.png', show_shapes=True) print("Loaded model") # load the data xs, ys = data.loadTraining() # split the dataset into training and validation 80% / 20% train_xs = xs[:int(len(xs) * 0.8)] train_ys = ys[:int(len(xs) * 0.8)] val_xs = xs[-int(len(xs) * 0.2):] val_ys = ys[-int(len(xs) * 0.2):] # load the validation dataset, it is better not generate an image each time - process them once # Use the validation process function, it doesn't augment the image, just resizes it X, y = data.getValidationDataset(val_xs, val_ys, data.processImageValidation) print(model.summary()) print("Loaded validation datasetset") print("Total of", len(train_ys)) print("Training..") checkpoint_path = "weights.{epoch:02d}-{val_loss:.2f}.hdf5" checkpoint = ModelCheckpoint(checkpoint_path, verbose=1, save_best_only=False, save_weights_only=False, mode='auto') # I tried using the earlystopping callback, but now I run it for a fixed number of epochs and test to see which is best earlystopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=2, verbose=1, mode='auto') res = model.fit_generator(data.generator(train_xs, train_ys, 256), validation_data=(X, y), samples_per_epoch=100 * 256, nb_epoch=epochs, verbose=1, callbacks=[SaveModel()]) # pickle and dump the history so we can graph it in a notebook history = res.history with open('history.p', 'wb') as f: pickle.dump(history, f)
# Set the calculated weights and biases model.get_layer('h1').set_weights(W1b1) model.get_layer('h2').set_weights(W2b2) model.get_layer('h3').set_weights(W3b3) model.get_layer('h4').set_weights(W4b4) model.get_layer('h5').set_weights(W5b5) model.get_layer('h6').set_weights(W6b6) model.get_layer('out').set_weights(Wobo) # Compile model current_dir = os.path.dirname(os.path.realpath(__file__)) model_path = os.path.join(current_dir, "FullyConnectedNetworkPrelu.png") plot(model, to_file=model_path, show_shapes=True) adam=keras.optimizers.Adam(lr=0.0005, beta_1=0.9, beta_2=0.999, epsilon=1e-08) model.compile(loss='binary_crossentropy', optimizer=adam,metrics=['categorical_accuracy']) # learning schedule callback history=History() lrate = LearningRateScheduler(step_decay) callbacks_list = [lrate,history] #model Fitting print "Training..." model.fit(X_train, y_train,validation_data=(X_test,y_test),nb_epoch=2000, batch_size=X_train.shape[0], callbacks=callbacks_list, verbose=1) #model.fit(X_train, y_train,validation_data=(X_test,y_test),nb_epoch=550, batch_size=X_train.shape[0],class_weight={0:1, 1:6756.0/271}, callbacks=callbacks_list, verbose=1) #Model prediction predicted=model.predict_proba(X_test,batch_size=25)
def make_one_net_model(self, cf, in_shape, loss, metrics, optimizer): # Create the *Keras* model if cf.model_name == 'fcn8': model = build_fcn8( in_shape, cf.dataset.n_classes, cf.weight_decay, freeze_layers_from=cf.freeze_layers_from, #path_weights='weights/pascal-fcn8s-dag.mat') path_weights=None) elif cf.model_name == 'unet': model = build_unet(in_shape, cf.dataset.n_classes, cf.weight_decay, freeze_layers_from=cf.freeze_layers_from, path_weights=None) elif cf.model_name == 'segnet_basic': model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay, freeze_layers_from=cf.freeze_layers_from, path_weights=None, basic=True) elif cf.model_name == 'segnet_vgg': model = build_segnet(in_shape, cf.dataset.n_classes, cf.weight_decay, freeze_layers_from=cf.freeze_layers_from, path_weights=None, basic=False) elif cf.model_name == 'resnetFCN': model = build_resnetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay, freeze_layers_from=cf.freeze_layers_from, path_weights=None) elif cf.model_name == 'densenetFCN': model = build_densenetFCN(in_shape, cf.dataset.n_classes, cf.weight_decay, freeze_layers_from=cf.freeze_layers_from, path_weights=None) elif cf.model_name == 'lenet': model = build_lenet(in_shape, cf.dataset.n_classes, cf.weight_decay) elif cf.model_name == 'alexNet': model = build_alexNet(in_shape, cf.dataset.n_classes, cf.weight_decay) elif cf.model_name == 'vgg16': model = build_vgg(in_shape, cf.dataset.n_classes, 16, cf.weight_decay, load_pretrained=cf.load_imageNet, freeze_layers_from=cf.freeze_layers_from) elif cf.model_name == 'vgg19': model = build_vgg(in_shape, cf.dataset.n_classes, 19, cf.weight_decay, load_pretrained=cf.load_imageNet, freeze_layers_from=cf.freeze_layers_from) elif cf.model_name == 'resnet50': model = build_resnet50(in_shape, cf.dataset.n_classes, cf.weight_decay, load_pretrained=cf.load_imageNet, freeze_layers_from=cf.freeze_layers_from) elif cf.model_name == 'InceptionV3': model = build_inceptionV3(in_shape, cf.dataset.n_classes, cf.weight_decay, load_pretrained=cf.load_imageNet, freeze_layers_from=cf.freeze_layers_from) elif cf.model_name == 'yolo': model = build_yolo(in_shape, cf.dataset.n_classes, cf.dataset.n_priors, load_pretrained=cf.load_imageNet, freeze_layers_from=cf.freeze_layers_from) else: raise ValueError('Unknown model') # Load pretrained weights if cf.load_pretrained: print(' loading model weights from: ' + cf.weights_file + '...') model.load_weights(cf.weights_file, by_name=True) # Compile model model.compile(loss=loss, metrics=metrics, optimizer=optimizer) # Show model structure if cf.show_model: model.summary() plot(model, to_file=os.path.join(cf.savepath, 'model.png')) # Output the model print(' Model: ' + cf.model_name) # model is a keras model, Model is a class wrapper so that we can have # other models (like GANs) made of a pair of keras models, with their # own ways to train, test and predict return One_Net_Model(model, cf, optimizer)