def create_xception_model(self): #vgg16_model = VGG16(include_top=self.vgg16_include_top, weights='imagenet')#包含最上层的连接层,imagenet表示加载imagenet与训练的网络权重. xception_model=Xception(include_top=True, weights='imagenet', input_tensor=None) xception_model.compile(optimizer=SGD(), loss='categorical_crossentropy', metrics=['accuracy']) xception_model.summary() plot_model(xception_model, to_file='xception_model.png', show_shapes=True) return xception_model
def create_model(self, weights_filename=None): model = Xception(weights=None, input_shape=[self.height, self.width, self.depth], include_top=True, classes=self.n_classes) if weights_filename is not None: model.load_weights(weights_filename) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=self.metrics) return model
def Make_Model(modelConfig, datasetConfig): strModelType = modelConfig.MODEL_TYPE strPretrained = modelConfig.PRETRAINED_MODEL im_Shape = datasetConfig.IMG_SHAPE strOptimizer = modelConfig.OPTIMIZER num_Classes = datasetConfig.NUM_CLASS learingRate = modelConfig.LEARNING_RATE decay = modelConfig.DECAY momentum = modelConfig.MOMENTUM loss = modelConfig.LOSS optimizer = None if(strOptimizer == "SGD"): optimizer = SGD(lr=learingRate, decay=decay, momentum=momentum, nesterov=True) # decay = 1e-4 elif(strOptimizer == "ADAM"): optimizer = Adam(lr=learingRate, decay=decay) else: print("No Such a Optimizer") return None model = None if(strModelType == "VGG16"): model = VGG16(weights=strPretrained, include_top=True, input_shape=im_Shape,classes = num_Classes) elif(strModelType == "RESNET50"): model = ResNet50(weights=strPretrained, include_top=True, input_shape=im_Shape,classes = num_Classes) elif(strModelType == "RESNET152"): model = build_Resnet152_Model(im_Shape, num_Classes, strPretrained) elif(strModelType == "INCEPTIONV3"): model = InceptionV3(weights=strPretrained, include_top=True, input_shape=im_Shape,classes = num_Classes) elif(strModelType == "INCEPTIONRESV2"): model = InceptionResNetV2(weights=strPretrained, include_top=True, input_shape=im_Shape,classes = num_Classes) elif(strModelType == "SEINCEPTIONRESV2"): model = SEInceptionResNetV2(weights=strPretrained, include_top=True, input_shape=im_Shape,classes = num_Classes) elif(strModelType == "XCEPTION"): model = Xception(weights=strPretrained, include_top=True, input_shape=im_Shape,classes = num_Classes) #basemodel = Xception(weights="imagenet", include_top=True, input_shape=(299,299,3), classes = 1000) #x = Dense(num_Classes, activation='softmax', name='predictions')(basemodel.layers[-2].output) #model = Model(basemodel.input, x) elif(strModelType == "UNET2D"): model = build_UNet2D_4L(im_Shape, strPretrained) elif(strModelType == "CNN6Layers"): model = build_CNN_6layers(im_Shape, num_classes = num_Classes) else: print("No Such Model Type") return None model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy']) #model.summary() return model
def uResNet34Xceptionregr(input_size=None, unet_weights=None, weights=None, n_classes=4, freeze_unet=False): assert any([unet_weights is None, weights is None]) # do not load both weights # U-Net if K.image_data_format() == "channels_last": input_shape = input_size + (3, ) else: input_shape = (3, ) + input_size model_unet = uResNet34(input_size=input_size, encoder_weights=None, weights=unet_weights, n_classes=n_classes) if freeze_unet: print("Freeze U-Net") for layer in model_unet.layers: layer.trainable = False img_input = Input(shape=input_shape) model_unet(img_input) # Regression if K.image_data_format() == "channels_last": input_shape = input_size + (n_classes, ) else: input_shape = (n_classes, ) + input_size model = Xception(input_shape=input_shape, include_top=False, weights=None, pooling="avg") x = model(model_unet.get_output_at(0)) x = Dense(1, activation="linear", name="predictions")(x) # Create model. model = Model(model_unet.get_input_at(0), x, name="uResNet34Xceptionregr") if weights is not None: print("Load weights from", weights) model.load_weights(weights) optimizer = Adam(decay=1e-4) # optimizer = SGD(momentum=0.95, decay=0.0005, nesterov=True) model.compile(loss="mse", optimizer=optimizer, metrics=["mse"]) return model
def main(data_dir='../data', scripts_dir='./', use_adv=True): file = File(path.join(data_dir, 'sample.h5')) x_data = file['x_data_adv'][:] if int(use_adv) else file['x_data'][:] y_data = file['y_data'][:] inc = InceptionV3() inc.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) xc = Xception() xc.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) inc_adv = load_model(path.join(scripts_dir, 'inception_adv.h5')) inc_adv.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) xc_adv = load_model(path.join(scripts_dir, 'xception_adv.h5')) xc_adv.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) for net_name, net in (('inception', inc), ('inception_adv', inc_adv), ('xception', xc), ('xception_adv', xc_adv)): for f in (filter_median, partial(denoise_nl_means, multichannel=True), partial(denoise_wavelet, multichannel=True), partial(denoise_bilateral, multichannel=True), partial(denoise_tv_chambolle, multichannel=True), partial(gaussian, multichannel=True), nofilter): try: imgs = apply_filter(x_data, f) imgs = preprocess_input(imgs.astype('float32')) loss, acc = net.evaluate(imgs, y_data, batch_size=64, verbose=0) fname = f.func.__name__ if hasattr(f, 'func') else f.__name__ logger.info( f'{net_name} with {fname}: loss {loss:.3f}, accuracy {acc:.3f}' ) except: logger.exception(f'{f} failed')
def Xception_model(): input_tensor = Input(shape=(dimension, dimension, number_of_channels)) model = Xception(input_tensor=input_tensor, weights='imagenet', include_top=True) model.layers.pop() model.outputs = [model.layers[-1].output] model.layers[-1].outbound_nodes = [] x = Dense(number_of_classes, activation='softmax')(model.output) model = Model(model.input, x) # the first 24 layers are not trained for layer in model.layers[:24]: layer.trainable = False lrate = 0.001 decay = 0.000001 adam = Adam(lr=lrate, decay=decay) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy']) print(model.summary()) return model
def main(): # Parameters if len(sys.argv) == 4: superclass = sys.argv[1] imgmove = sys.argv[2] if imgmove == 'False': imgmove = False else: imgmove = True lr = float(sys.argv[3]) else: print('Parameters error') exit() # The constants classNum = {'A': 40, 'F': 40, 'V': 40, 'E': 40, 'H': 24} testName = {'A': 'a', 'F': 'a', 'V': 'b', 'E': 'b', 'H': 'b'} date = '20180321' trainpath = 'trainval_' + superclass + '/train' valpath = 'trainval_' + superclass + '/val' if not os.path.exists('model'): os.mkdir('model') # Train/validation data preparation if imgmove: os.mkdir('trainval_' + superclass) os.mkdir(trainpath) os.mkdir(valpath) sourcepath = '../zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_'+date+'_crop'\ +'/zsl_'+testName[superclass[0]]+'_'+str(superclass).lower()+'_train_images_'+date categories = os.listdir(sourcepath) for eachclass in categories: if eachclass[0] == superclass[0]: print(eachclass) os.mkdir(trainpath + '/' + eachclass) os.mkdir(valpath + '/' + eachclass) imgs = os.listdir(sourcepath + '/' + eachclass) idx = 0 for im in imgs: if idx % 8 == 0: shutil.copyfile( sourcepath + '/' + eachclass + '/' + im, valpath + '/' + eachclass + '/' + im) else: shutil.copyfile( sourcepath + '/' + eachclass + '/' + im, trainpath + '/' + eachclass + '/' + im) idx += 1 # Train and validation ImageDataGenerator batchsize = 32 train_datagen = ImageDataGenerator(rescale=1. / 255, rotation_range=15, width_shift_range=5, height_shift_range=5, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory(trainpath, target_size=(72, 72), batch_size=batchsize) valid_generator = test_datagen.flow_from_directory(valpath, target_size=(72, 72), batch_size=batchsize) # Train MobileNet model = Xception(include_top=True, weights=None, input_tensor=None, input_shape=(72, 72, 3), pooling=None, classes=classNum[superclass[0]]) model.summary() model.compile(optimizer=SGD(lr=lr, momentum=0.9), loss='categorical_crossentropy', metrics=['accuracy']) steps_per_epoch = int(train_generator.n / batchsize) validation_steps = int(valid_generator.n / batchsize) weightname = 'model/mobile_' + superclass + '_wgt.h5' if os.path.exists(weightname): model.load_weights(weightname) checkpointer = ModelCheckpoint(weightname, monitor='val_loss', verbose=0, save_best_only=True, save_weights_only=True, mode='auto', period=1) model.fit_generator(train_generator, steps_per_epoch=steps_per_epoch, epochs=100, validation_data=valid_generator, validation_steps=validation_steps, callbacks=[checkpointer])
drop = 0.94 epochs_drop = 2 if epoch%epochs_drop == 0: lrate = initial_lrate * (drop ** np.floor(epoch/epochs_drop)) else: lrate = initial_lrate * (drop ** np.floor((epoch-1)/epochs_drop)) print(lrate) return lrate lrate = LearningRateScheduler(step_decay) Adam(lr=0.005, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0, amsgrad=False) model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy']) csv_logger = CSVLogger('./training_Xception.log', append=True) checkpointer = ModelCheckpoint(filepath='./weights_Xception.hdf5', verbose=1, save_best_only=True, monitor = 'val_acc') callbacks_list = [checkpointer,csv_logger,lrate] model.fit_generator(traning_set, epochs=100, steps_per_epoch=len(x_train) / 50, validation_steps=len(x_valid) / 50, verbose=1, validation_data=validation_set,callbacks=callbacks_list) score = model.evaluate(x_valid, y_valid, verbose=0) print(score)
prediction = Dense(3,activation='softmax',name='new_dene_2')(x) model_1 = Model(inputs=inception_model_1.input,outputs=prediction) layers = ['new_pool_1','new_batch_1','new_dense_1','new_batch_2','new_drop_2','new_dene_2'] for layer in layers: lr_dict[layer] = 0.0002*10 !pip install keras-lr-multiplier from keras_lr_multiplier import LRMultiplier model_1.summary() model_1.compile(loss='categorical_crossentropy',optimizer=LRMultiplier('adam', lr_dict),metrics=['accuracy']) train_set_1 = preprocess_input(preprocess_initial(train_files)) test_set_1 = preprocess_input(preprocess_initial(test_files)) valid_set_1 = preprocess_input(preprocess_initial(valid_files)) layers = ['new_pool_1','new_batch_1','new_dense_1','new_batch_2','new_drop_2','new_dene_2'] model_1.get_layer('new_dene_2').set_weights([np.array(weights[10],dtype=np.float32),np.zeros([3],dtype=np.float32)]) model_1.get_layer('new_dense_1').set_weights([np.array(weights[4],dtype=np.float32),np.zeros([512],dtype=np.float32)]) # the first 249 layers and unfreeze the rest: for layer in model_1.layers[:249]: layer.trainable = False for layer in model_1.layers[249:]:
x = base_model.output x = Dense(units=1024, activation="relu")(x) x = Dense(units=2, activation="softmax")(x) model = Model(base_model.input, x) model.summary() for layer in base_model.layers: layer.trainable = False model.summary() model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=['accuracy']) model.fit_generator(train_gen, validation_data=test_gen, steps_per_epoch=947 // 64, validation_steps=406 // 64, epochs=2) ################################################################### from matplotlib.image import imread train_arr = [] label_arr = [] for path, subdirs, files in os.walk(root):
input_shape=(299, 299, 3)) x = model.get_layer(index=len(model.layers) - 2).output print(x) x = Dense(1)(x) model = Model(inputs=model.input, outputs=x) model.summary() # **Using RMSprop optimizer, mean absolute error with metrics, and mean square erro with loss** # In[ ]: opt = RMSprop(lr=0.0001) model.compile(loss='mean_squared_error', optimizer=opt, metrics=['mae']) # **Puting the model for fit** # # **NOTE: The number of epochs is set to 100** # In[ ]: network_history = model.fit(x_train, y_train, batch_size=32, epochs=100, verbose=1, validation_data=(x_val, y_val)) # ### Save the Model Trained
def train_with_sift_features(batch_size, input_shape, x_train, y_train, x_valid, y_valid, sift_features_train, sift_features_valid, model_name, num_workers, resume): print('Found {} images belonging to {} classes'.format(len(x_train), 128)) print('Found {} images belonging to {} classes'.format(len(x_valid), 128)) train_generator = AugmentedDatasetWithSiftFeatures(x_train, y_train, sift_features_train, batch_size=batch_size, input_shape=input_shape) valid_generator = DatasetWithSiftFeatures(x_valid, y_valid, sift_features_valid, batch_size=batch_size, input_shape=input_shape) class_weight = compute_class_weight('balanced', np.unique(y_train), y_train) class_weight_dict = dict.fromkeys(np.unique(y_train)) for key in class_weight_dict.keys(): class_weight_dict.update({key: class_weight[key]}) filepath = 'checkpoint/{}/sift_iter1.hdf5'.format(model_name) save_best = ModelCheckpoint(filepath=filepath, verbose=1, monitor='val_acc', save_best_only=True, mode='max') save_on_train_end = ModelCheckpoint(filepath=filepath, verbose=1, monitor='val_acc', period=args.epochs) reduce_lr = ReduceLROnPlateau(monitor='val_acc', factor=0.2, patience=2, verbose=1) callbacks = [save_best, save_on_train_end, reduce_lr] if resume == 'True': print('\nResume training from the last checkpoint') model = load_model(filepath) trainable_count = int( np.sum([K.count_params(p) for p in set(model.trainable_weights)])) print('Trainable params: {:,}'.format(trainable_count)) model.fit_generator(generator=train_generator, epochs=args.epochs, callbacks=callbacks, validation_data=valid_generator, class_weight=class_weight_dict, workers=num_workers) else: model = Xception(include_top=False, pooling='max') sift_features = Input(shape=(512, )) x = Concatenate()([model.layers[-1].output, sift_features]) x = Dense(units=128, activation='linear', name='predictions', kernel_regularizer=regularizers.l2(0.0001))(x) model = Model([model.layers[0].input, sift_features], x) for layer in model.layers[:-1]: layer.trainable = False model.compile(optimizer=Adam(lr=0.001), loss='categorical_hinge', metrics=['acc']) model.fit_generator(generator=train_generator, epochs=5, callbacks=callbacks, validation_data=valid_generator, class_weight=class_weight_dict, workers=num_workers) K.clear_session() print("\nFine-tune the network") model = load_model(filepath) for layer in model.layers: layer.trainable = True trainable_count = int( np.sum([K.count_params(p) for p in set(model.trainable_weights)])) print('Trainable params: {:,}'.format(trainable_count)) model.compile(optimizer=SGD(lr=0.0001, momentum=0.9), loss='categorical_hinge', metrics=['acc']) model.fit_generator(generator=train_generator, epochs=30, callbacks=callbacks, validation_data=valid_generator, class_weight=class_weight_dict, workers=num_workers) K.clear_session()
def main(args): # hyper parameters batch_size = 16 num_classes = 102 epochs = 100 # Instantiate model model = Xception(include_top=True, weights=None, classes=num_classes) # prepare data x_train = np.load(os.path.join(current_directory, 'x_train.npy')) y_train = np.load(os.path.join(current_directory, 'y_train.npy')) x_test = np.load(os.path.join(current_directory, 'x_test.npy')) y_test = np.load(os.path.join(current_directory, 'y_test.npy')) # summary of the model model.summary() # compile model model.compile( loss=categorical_crossentropy, optimizer=Adadelta(), metrics=['accuracy'] ) # learning section hist = model.fit( x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test) ) # evaluation section score = model.evaluate(x_test, y_test, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) # save graphs acc = hist.history['acc'] val_acc = hist.history['val_acc'] loss = hist.history['loss'] val_loss = hist.history['val_loss'] plt.plot(range(epochs), loss, marker='.', label='acc') plt.plot(range(epochs), val_loss, marker='.', label='val_acc') plt.legend(loc='best') plt.grid() plt.xlabel('epoch') plt.ylabel('acc') plt.savefig(os.path.join(current_directory, 'acc_xception.png')) plt.clf() plt.plot(range(epochs), acc, marker='.', label='loss') plt.plot(range(epochs), val_acc, marker='.', label='val_loss') plt.legend(loc='best') plt.grid() plt.xlabel('epoch') plt.ylabel('loss') plt.savefig(os.path.join(current_directory, 'loss_xception.png')) plt.clf()
def train(epochs): image_size = (299, 299) # variables to hold features and labels features = [] labels = [] # default setting in keras models class_count = 1000 X_test = [] name_test = [] trainData = np.loadtxt("./train.txt", dtype="str", delimiter=' ') for k in range(len(trainData)): aLine = trainData[k] image_path = aLine[0] label = int(aLine[1]) ground_truth = np.zeros(class_count, dtype=np.float32) ground_truth[label] = 1 img = image.load_img(image_path, target_size=image_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) labels.append(ground_truth) features.append(x[0]) trainData = np.loadtxt("./val.txt", dtype="str", delimiter=' ') for k in range(len(trainData)): aLine = trainData[k] image_path = aLine[0] label = int(aLine[1]) ground_truth = np.zeros(class_count, dtype=np.float32) ground_truth[label] = 1 img = image.load_img(image_path, target_size=image_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) labels.append(ground_truth) features.append(x[0]) testData = np.loadtxt("./test.txt", dtype="str", delimiter=' ') for k in range(len(testData)): aLine = testData[k] image_path = aLine img = image.load_img(image_path, target_size=image_size) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) X_test.append(x[0]) name_test.append(image_path) X_train = features y_train = labels X_train = np.array(X_train) Y_train = np.array(y_train) # test image X_test = np.array(X_test) # Use Xception model = Xception(include_top=True, weights='imagenet', classes=class_count) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X_train, Y_train, epochs=epochs, verbose=1, validation_split=0.3) Y_pred = model.predict(X_test) f = open('project2_08573584.txt', 'w') for i in range(len(name_test)): predict = Y_pred[i].argmax(axis=0) f.write(str(predict) + '\n') f.close()
def fine_tune(name, name_ext, lr=1e-4, reduce_lr_factor=0.1, reduce_lr_patience=3, epochs=10, batch_size=32, l2_reg=0, dropout_p=0.5, num_freeze_layers=0, save_best_only=True, loss_stop_val=0.00001): data_info = load_organized_data_info(imgs_dim=HEIGHT, name=name) tr_datagen = ImageDataGenerator( preprocessing_function=preprocess_input, rotation_range=180, vertical_flip=True, horizontal_flip=True, # width_shift_range=0.1, # height_shift_range=0.1, # zoom_range=0.1, # shear_range=0.3, # fill_mode='reflect' ) val_datagen = ImageDataGenerator(preprocessing_function=preprocess_input) batch_size = 32 def dir_datagen(dir_, gen): return gen.flow_from_directory(directory=dir_, target_size=(HEIGHT, WIDTH), class_mode='categorical', batch_size=batch_size, shuffle=True) dir_tr, num_tr = data_info['dir_tr'], data_info['num_tr'] dir_val, num_val = data_info['dir_val'], data_info['num_val'] top_classifier_file = join(MODELS_DIR, TOP_CLASSIFIER_FILE.format(name)) model_file = join(MODELS_DIR, MODEL_FILE.format(name, name_ext)) model = Xception(weights='imagenet', include_top=False, pooling='avg') top_classifier = _top_classifier(l2_reg=l2_reg, dropout_p=dropout_p, input_shape=(2048, )) top_classifier.load_weights(top_classifier_file) model = Model(inputs=model.input, outputs=top_classifier(model.output)) model.compile(Adam(lr=lr), loss='categorical_crossentropy') # model has 134 layers for layer in model.layers[:num_freeze_layers]: layer.trainable = False log_dir = join(EXPERIMENTS_DIR, 'xception_fine_tuned_{:s}'.format(name)) callbacks = [ EarlyStoppingByLoss(monitor='loss', value=loss_stop_val), ReduceLROnPlateau(factor=reduce_lr_factor, patience=reduce_lr_patience), ModelCheckpoint(model_file, save_best_only=save_best_only), TensorBoard(log_dir=log_dir, write_graph=False) ] model.fit_generator(generator=dir_datagen(dir_tr, tr_datagen), steps_per_epoch=ceil(num_tr / batch_size), epochs=epochs, validation_data=dir_datagen(dir_val, val_datagen), validation_steps=ceil(num_val / batch_size), callbacks=callbacks)
total_samples_test = getNumSamples(variants[num_variant][1][0:4] + '.h5') x_test = np.zeros( (total_samples_test, INPUT_FRAME_SIZE, INPUT_FRAME_SIZE, 3), dtype='float16') y_test = np.zeros((total_samples_test, 1), dtype='float16') print('Test dataset loaded') print('Testing dataset size = ', x_test.shape) print('Loading model') model = Xception(weights=None, include_top=True, classes=NUMBER_OF_CLASSES) rms_prop = optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0) model.compile(loss='categorical_crossentropy', optimizer=rms_prop, metrics=['accuracy', 'mse']) print("Model loaded") # autosave best Model best_model_file = '{}_{}_{}_B{}_E{}_F{}.h5'.format(NET_NAME, TRAIN_SET[-11:-7], TEST_SET[-11:-7], BATCH_SIZE, EPOCHS, INPUT_FRAME_SIZE) best_model = ModelCheckpoint(best_model_file, monitor='val_loss', verbose=1, save_best_only=True) print("*************************************")
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['categorical_accuracy']) bind_model(model) model = NASNetLarge(input_shape=(h, w, 3), include_top=True, classes = 4, weights=None) adam = optimizers.Adam(lr=learning_rate, decay=1e-5) # optional optimization sgd = optimizers.SGD(lr=learning_rate, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['categorical_accuracy']) bind_model(model) """ ## model = Xception(input_shape=(h, w, 3), include_top=True, classes = 4, weights=None) adam = optimizers.Adam(lr=learning_rate, decay=1e-5) # optional optimization sgd = optimizers.SGD(lr=learning_rate, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['categorical_accuracy']) bind_model(model) """ model = cnn_sample(in_shape=(h, w, 3), num_classes=4) adam = optimizers.Adam(lr=learning_rate, decay=1e-5) model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['categorical_accuracy']) bind_model(model) """ if config.pause: ## test mode일 때 print('Inferring Start...') nsml.paused(scope=locals()) if config.mode == 'train': ### training mode일 때 print('Training Start...')
# from keras.utils import multi_gpu_model # from keras.models import import numpy as np import datetime num_samples = 100 height = 71 width = 71 num_classes = 100 start = datetime.datetime.now() with tf.device('/gpu:0'): model = Xception(weights=None, input_shape=(height, width, 3), classes=num_classes) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') # Generate dummy data. x = np.random.random((num_samples, height, width, 3)) y = np.random.random((num_samples, num_classes)) model.fit(x, y, epochs=3, batch_size=16) model.save('my_model.h5') end = datetime.datetime.now() time_delta = end - start print('GPU 처리시간 : ', time_delta) start = datetime.datetime.now() with tf.device('/cpu:0'):