tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64,(3,3), activation = 'relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64,(3,3), activation = 'relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64,(3,3), activation = 'relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512,activation = "relu"), # This is the last layer. You should not change this code. tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(loss='binary_crossentropy', optimizer=RMSprop(learning_rate=0.001), metrics=['accuracy']) model.fit( train_generator, steps_per_epoch=8, epochs=15, verbose=1 validation_data = validation_generator, validation_steps = 8 ) # In case of Colab, You can download h5 file model.save('mymodel.h5') files.download('mymodel.h5')
y_train = df['Score Dist'].values y_train = df.values[:, 2:] y_train = to_categorical(y_train, 3) print(x_train) print(x_train.shape) print(y_train.shape) model = Sequential() model.add(Embedding(num_words, 9, input_length=max_len)) model.add(LSTM(128, return_sequences=True, recurrent_dropout=0.5)) model.add(LSTM(128, return_sequences=True, recurrent_dropout=0.5)) model.add(LSTM(128, recurrent_dropout=0.5)) model.add(Dense(30, activation='relu')) model.add(Dense(3, activation='softmax')) opt = RMSprop(learning_rate=0.0002) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) history = model.fit(x_train, y_train, epochs=40, batch_size=128, validation_split=0.2, shuffle=True) model.save('MetacriticNet.h5') plt.plot(history.history['accuracy'],
tf.keras.layers.MaxPooling2D(2, 2), # The fifth convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # Flatten the results to feed into a DNN tf.keras.layers.Flatten(), # 512 neuron hidden layer tf.keras.layers.Dense(512, activation='relu'), # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('horses') and 1 for the other ('humans') tf.keras.layers.Dense(1, activation='sigmoid') ]) model.summary() model.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=0.001), metrics=['acc']) #DATA PREPROCESSING # All images will be rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1 / 255) validation_datagen = ImageDataGenerator(rescale=1 / 255) # Flow training images in batches of 128 using train_datagen generator train_generator = train_datagen.flow_from_directory( '/tmp/horse-or-human/', # This is the source directory for training images target_size=(150, 150), # All images will be resized to 150x150 batch_size=128, # Since we use binary_crossentropy loss, we need binary labels class_mode='binary')
def main(args): # Create data generators for feeding training and evaluation based on data provided to us # by the SageMaker TensorFlow container train_gen, test_gen, val_gen = create_data_generators() base_model = MobileNetV2(weights='imagenet', include_top=False, input_shape=(HEIGHT, WIDTH, 3)) # Here we extend the base model with additional fully connected layers, dropout for avoiding # overfitting to the training dataset, and a classification layer fully_connected_layers = [] for i in range(args.num_fully_connected_layers): fully_connected_layers.append(1024) num_classes = len(glob.glob('/opt/ml/input/data/train/*')) model = build_finetune_model(base_model, dropout=args.dropout, fc_layers=fully_connected_layers, num_classes=num_classes) opt = RMSprop(lr=args.initial_lr) model.compile(opt, loss='categorical_crossentropy', metrics=['accuracy']) print('\nBeginning training...') NUM_EPOCHS = args.fine_tuning_epochs FINE_TUNING = True num_train_images = len(train_gen.filepaths) num_val_images = len(val_gen.filepaths) if not FINE_TUNING: history = model.fit_generator(train_gen, epochs=NUM_EPOCHS, workers=8, steps_per_epoch=num_train_images // args.batch_size, validation_data=val_gen, validation_steps=num_val_images // args.batch_size, shuffle=True) else: # Train for a few epochs model.fit_generator(train_gen, epochs=args.initial_epochs, workers=8, steps_per_epoch=num_train_images // args.batch_size, validation_data=val_gen, validation_steps=num_val_images // args.batch_size, shuffle=True) # Now fine tune the last set of layers in the model for layer in model.layers[LAST_FROZEN_LAYER:]: layer.trainable = True fine_tuning_lr = args.fine_tuning_lr model.compile(optimizer=SGD(lr=fine_tuning_lr, momentum=0.9, decay=fine_tuning_lr / NUM_EPOCHS), loss='categorical_crossentropy', metrics=['accuracy']) history = model.fit_generator(train_gen, epochs=NUM_EPOCHS, workers=8, steps_per_epoch=num_train_images // args.batch_size, validation_data=val_gen, validation_steps=num_val_images // args.batch_size, shuffle=True) print('Model has been fit.') print('Saving model to /opt/ml/model...') # Note that this method of saving does produce a warning about not containing the train and evaluate graphs. # The resulting saved model works fine for inference. It will simply not support incremental training. If that # is needed, one can use model checkpoints and save those. print('Model directory files BEFORE save: {}'.format(glob.glob('/opt/ml/model/*/*'))) tf.contrib.saved_model.save_keras_model(model, '/opt/ml/model/1') print('Model directory files AFTER save: {}'.format(glob.glob('/opt/ml/model/*/*'))) print('...DONE saving model!') # Need to copy these files to the code directory, else the SageMaker endpoint will not use them. print('Copying inference source files...') if not os.path.exists('/opt/ml/model/code'): os.system('mkdir /opt/ml/model/code') os.system('cp inference.py /opt/ml/model/code') os.system('cp requirements.txt /opt/ml/model/code') print('Files after copying custom inference handler files: {}'.format(glob.glob('/opt/ml/model/code/*'))) print('\nExiting training script.\n')
model=tf.keras.Sequential([ tf.keras.layers.Conv2D(16,(3,3),activation='relu',input_shape=(300,300,3)), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(32,(3,3),activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64,(3,3),activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512,activation='relu'), tf.keras.layers.Dense(1,activation='sigmoid') ]) model.summary() from tensorflow.keras.optimizers import RMSprop model.compile(loss='binary_crossentropy',optimizer=RMSprop(lr=0.001),metrics=['acc']) from tensorflow.keras.preprocessing.image import ImageDataGenerator train_datagen=ImageDataGenerator(rescale=1/255.0) validation_dategen=ImageDataGenerator(rescale=1/255.0) train_generator=train_datagen.flow_from_directory('D:/horse-or-human/train', target_size=(300,300), batch_size=128, class_mode='binary') validation_generator=validation_dategen.flow_from_directory('D:/horse-or-human/validation', target_size=(300,300), batch_size=32, class_mode='binary')
tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(128, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 3), tf.keras.layers.Conv2D(128, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Dropout(0.5), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ]) #%% model.compile( loss='binary_crossentropy', optimizer=RMSprop(lr=1e-4), metrics=['acc'] ) #%% train_datagen = ImageDataGenerator( rescale=1./255, rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest' )
def train_happy_sad_model(): # Please write your code only where you are indicated. # please do not remove # model fitting inline comments. DESIRED_ACCURACY = 0.999 class myCallback(tf.keras.callbacks.Callback): # Your Code def on_epoch_end(self, epoch, logs={}): if (logs.get("acc") > DESIRED_ACCURACY): print("\nReached 99.8% accuracy so cancelling training!") self.model.stop_training = True callbacks = myCallback() # This Code Block should Define and Compile the Model. Please assume the images are 150 X 150 in your implementation. model = tf.keras.models.Sequential([ # Your Code Here tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(300, 300, 3)), tf.keras.layers.MaxPooling2D(2, 2), # The second convolution tf.keras.layers.Conv2D(32, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # The third convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # The fourth convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # The fifth convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # Flatten the results to feed into a DNN tf.keras.layers.Flatten(), # 512 neuron hidden layer tf.keras.layers.Dense(512, activation='relu'), # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('horses') and 1 for the other ('humans') tf.keras.layers.Dense(1, activation='sigmoid') ]) from tensorflow.keras.optimizers import RMSprop model.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=0.001), metrics=['accuracy']) # This code block should create an instance of an ImageDataGenerator called train_datagen # And a train_generator by calling train_datagen.flow_from_directory from tensorflow.keras.preprocessing.image import ImageDataGenerator train_datagen = ImageDataGenerator(rescale=1 / 255) # Please use a target_size of 150 X 150. train_generator = train_datagen.flow_from_directory( '/tmp/h-or-s/', # This is the source directory for training images target_size=(300, 300), # All images will be resized to 150x150 batch_size=16, # Since we use binary_crossentropy loss, we need binary labels class_mode='binary') # Expected output: 'Found 80 images belonging to 2 classes' # This code block should call model.fit_generator and train for # a number of epochs. # model fitting history = model.fit_generator(train_generator, steps_per_epoch=1, epochs=50, verbose=1, callbacks=[callbacks]) # model fitting return history.history['acc'][-1]
def main(): #importance of variables for analysis later: https://stackoverflow.com/questions/45361559/feature-importance-chart-in-neural-network-using-keras-in-python/61861991#61861991 #Set Variables COUNT_BINS_AGENTS = 21 COUNT_RAYS_WALLS = 15 RADIUS_FIELD_OF_VIEW_WALLS = 180 RADIUS_FIELD_OF_VIEW_AGENTS = 300 MAX_VIEW_RANGE = 709 COUNT_FISHES = 3 CLUSTER_COUNTS = (18, 17, 26) SEQUENCE_LENGTH = 70 BATCH_SIZE = 10 SUBTRACK_LENGTH = 6100 EPOCHS = 30 locomotion_paths = [ "data/locomotion_data_same1.csv", "data/locomotion_data_same3.csv", "data/locomotion_data_same4.csv", "data/locomotion_data_same5.csv", "data/locomotion_data_diff1.csv", "data/locomotion_data_diff2.csv", "data/locomotion_data_diff3.csv", "data/locomotion_data_diff4.csv" ] raycast_paths = [ "data/raycast_data_same1.csv", "data/raycast_data_same3.csv", "data/raycast_data_same4.csv", "data/raycast_data_same5.csv", "data/raycast_data_diff1.csv", "data/raycast_data_diff2.csv", "data/raycast_data_diff3.csv", "data/raycast_data_diff4.csv" ] model = Sequential() model.add( LSTM(64, input_shape=(SEQUENCE_LENGTH, COUNT_BINS_AGENTS + COUNT_RAYS_WALLS + 3))) model.add(Dropout(0.3)) model.add(Dense(32)) model.add(Dropout(0.3)) model.add(Dense(3)) model.compile(optimizer=RMSprop(), loss="mse") #model = load_model("models/2model_v0_LSTM40_DROP03_DENSE20_DROP03_10_70_10_same13") sim = Simulation(COUNT_BINS_AGENTS, COUNT_RAYS_WALLS, RADIUS_FIELD_OF_VIEW_WALLS, RADIUS_FIELD_OF_VIEW_AGENTS, MAX_VIEW_RANGE, COUNT_FISHES, None, verbose=2) sim.setModel(model) sim.trainNetworkOnce(locomotion_paths[0:4], raycast_paths[0:4], BATCH_SIZE, SEQUENCE_LENGTH, EPOCHS) # sim.trainNetwork("data/locomotion_data_same1.csv", "data/raycast_data_same1.csv", SUBTRACK_LENGTH, BATCH_SIZE, SEQUENCE_LENGTH, EPOCHS) # sim.trainNetwork("data/locomotion_data_same3.csv", "data/raycast_data_same3.csv", SUBTRACK_LENGTH, BATCH_SIZE, SEQUENCE_LENGTH, EPOCHS) # sim.trainNetwork("data/locomotion_data_same4.csv", "data/raycast_data_same4.csv", SUBTRACK_LENGTH, BATCH_SIZE, SEQUENCE_LENGTH, EPOCHS) # sim.trainNetwork("data/locomotion_data_same5.csv", "data/raycast_data_same5.csv", SUBTRACK_LENGTH, BATCH_SIZE, SEQ UENCE_LENGTH, EPOCHS) model = sim.getModel() #Naming of model files: 2model (only uses head and center) _ version _ layers (e.g. LSTM40, DROP03, DENSE20) _ batchSize _ sequenceLength _ Epochs _ data on which it is trained sim.testNetwork( timesteps=18000, save_tracks= "data/new_2model_v0_LSTM64_DROP03_DENSE32_DROP03_10_70_30_same.csv", save_start= "data/new_2model_v0_LSTM64_DROP03_DENSE32_DROP03_10_70_30_same.txt") model.save( "models/new_2model_v0_LSTM64_DROP03_DENSE32_DROP03_10_70_30_same")
# fine-tun: True, frozen: False for i in range(len(pretrained_model.layers)): pretrained_model.layers[i].trainable = False print("This is {} layer.".format(i), "\n", pretrained_model.layers[i].name) extracted_layers = pretrained_model.layers[:-1] extracted_layers.append(Activation(tf.nn.relu, name="new_act1")) extracted_layers.append(Dense(10, name="dense_3")) extracted_layers.append(Activation(tf.nn.softmax, name="new_act2")) for i in range(len(extracted_layers)): print("This is {} layer.".format(i), "\n", extracted_layers[i].name) model = Sequential(extracted_layers) optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0) loss = tf.keras.losses.categorical_crossentropy model.compile(optimizer=optimizer, loss=loss, metrics="acc") learning_rate_reduction = ReduceLROnPlateau(monitor='val_acc', patience=3, verbose=1, factor=0.5, min_lr=0.00001) early_stopper = EarlyStopping( monitor="val_loss", min_delta=0, patience=1, verbose=1, mode="auto", baseline=None, restore_best_weights=False
def puigcerver(input_size, output_size, learning_rate): """ Convolucional Recurrent Neural Network by Puigcerver et al. Reference: Puigcerver, J.: Are multidimensional recurrent layers really necessary for handwritten text recognition? In: Document Analysis and Recognition (ICDAR), 2017 14th IAPR International Conference on, vol. 1, pp. 67–72. IEEE (2017) """ input_data = Input(name="input", shape=input_size) cnn = Conv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), padding="same")(input_data) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="valid")(cnn) cnn = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="valid")(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=48, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding="valid")(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=80, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = BatchNormalization()(cnn) cnn = LeakyReLU(alpha=0.01)(cnn) shape = cnn.get_shape() blstm = Reshape((shape[1], shape[2] * shape[3]))(cnn) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Bidirectional(LSTM(units=256, return_sequences=True, dropout=0.5))(blstm) blstm = Dropout(rate=0.5)(blstm) output_data = Dense(units=output_size, activation="softmax")(blstm) if learning_rate is None: learning_rate = 3e-4 optimizer = RMSprop(learning_rate=learning_rate) return (input_data, output_data, optimizer)
def flor(input_size, output_size, learning_rate): """ Gated Convolucional Recurrent Neural Network by Flor et al. """ input_data = Input(name="input", shape=input_size) cnn = Conv2D(filters=16, kernel_size=(3, 3), strides=(2, 2), padding="same")(input_data) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=16, kernel_size=(3, 3), padding="same")(cnn) cnn = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=32, kernel_size=(3, 3), padding="same")(cnn) cnn = Conv2D(filters=40, kernel_size=(2, 4), strides=(2, 4), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=40, kernel_size=(3, 3), padding="same", kernel_constraint=MaxNorm(4, [0, 1, 2]))(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=48, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=48, kernel_size=(3, 3), padding="same", kernel_constraint=MaxNorm(4, [0, 1, 2]))(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=56, kernel_size=(2, 4), strides=(2, 4), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = FullGatedConv2D(filters=56, kernel_size=(3, 3), padding="same", kernel_constraint=MaxNorm(4, [0, 1, 2]))(cnn) cnn = Dropout(rate=0.2)(cnn) cnn = Conv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = PReLU(shared_axes=[1, 2])(cnn) cnn = BatchNormalization(renorm=True)(cnn) cnn = MaxPooling2D(pool_size=(1, 2), strides=(1, 2), padding="valid")(cnn) shape = cnn.get_shape() bgru = Reshape((shape[1], shape[2] * shape[3]))(cnn) bgru = Bidirectional(GRU(units=128, return_sequences=True, dropout=0.5))(bgru) bgru = TimeDistributed(Dense(units=128))(bgru) bgru = Bidirectional(GRU(units=128, return_sequences=True, dropout=0.5))(bgru) output_data = TimeDistributed( Dense(units=output_size, activation="softmax"))(bgru) if learning_rate is None: learning_rate = 5e-4 optimizer = RMSprop(learning_rate=learning_rate) return (input_data, output_data, optimizer)
def bluche(input_size, output_size, learning_rate): """ Gated Convolucional Recurrent Neural Network by Bluche et al. Reference: Bluche, T., Messina, R.: Gated convolutional recurrent neural networks for multilingual handwriting recognition. In: Document Analysis and Recognition (ICDAR), 2017 14th IAPR International Conference on, vol. 1, pp. 646–651, 2017. URL: https://ieeexplore.ieee.org/document/8270042 """ input_data = Input(name="input", shape=input_size) cnn = Reshape((input_size[0] // 2, input_size[1] // 2, input_size[2] * 4))(input_data) cnn = Conv2D(filters=8, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="tanh")(cnn) cnn = Conv2D(filters=16, kernel_size=(2, 4), strides=(2, 4), padding="same", activation="tanh")(cnn) cnn = GatedConv2D(filters=16, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="tanh")(cnn) cnn = GatedConv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = Conv2D(filters=64, kernel_size=(2, 4), strides=(2, 4), padding="same", activation="tanh")(cnn) cnn = GatedConv2D(filters=64, kernel_size=(3, 3), strides=(1, 1), padding="same")(cnn) cnn = Conv2D(filters=128, kernel_size=(3, 3), strides=(1, 1), padding="same", activation="tanh")(cnn) cnn = MaxPooling2D(pool_size=(1, 4), strides=(1, 4), padding="valid")(cnn) shape = cnn.get_shape() blstm = Reshape((shape[1], shape[2] * shape[3]))(cnn) blstm = Bidirectional(LSTM(units=128, return_sequences=True))(blstm) blstm = Dense(units=128, activation="tanh")(blstm) blstm = Bidirectional(LSTM(units=128, return_sequences=True))(blstm) output_data = Dense(units=output_size, activation="softmax")(blstm) if learning_rate is None: learning_rate = 4e-4 optimizer = RMSprop(learning_rate=learning_rate) return (input_data, output_data, optimizer)
def main(args): # Hyper-parameters epochs = args.epochs lr = args.learning_rate batch_size = args.batch_size momentum = args.momentum weight_decay = args.weight_decay optimizer = args.optimizer model_type = args.model_type # SageMaker options training_dir = args.train validation_dir = args.validation eval_dir = args.eval gpus = tf.config.experimental.list_physical_devices('GPU') for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) train_dataset = get_dataset(training_dir + '/train.tfrecords', batch_size) train_dataset = train_dataset.shuffle(10000) val_dataset = get_dataset(validation_dir + '/validation.tfrecords', batch_size) eval_dataset = get_dataset(eval_dir + '/eval.tfrecords', batch_size) model = get_custom_model(input_shape) if optimizer.lower() == 'adam': opt = Adam(lr=lr, decay=weight_decay) elif optimizer.lower() == 'rmsprop': opt = RMSprop(lr=lr, decay=weight_decay) else: opt = SGD(lr=lr, decay=weight_decay, momentum=momentum) loss_fn = tf.keras.losses.CategoricalCrossentropy() train_loss = tf.keras.metrics.Mean(name='train_loss') train_accuracy = tf.keras.metrics.CategoricalAccuracy( name='train_accuracy') val_loss = tf.keras.metrics.Mean(name='val_loss') val_accuracy = tf.keras.metrics.CategoricalAccuracy(name='val_accuracy') test_loss = tf.keras.metrics.Mean(name='test_loss') test_accuracy = tf.keras.metrics.CategoricalAccuracy(name='test_accuracy') @smp.step def get_grads(images, labels): train_pred = model(images, training=True) train_loss_value = loss_fn(labels, train_pred) grads = opt.get_gradients(train_loss_value, model.trainable_variables) return grads, train_loss_value, train_pred @tf.function def training_step(images, labels, first_batch): gradients, train_loss_value, train_pred = get_grads(images, labels) # SMP: Accumulate the gradients across microbatches gradients = [g.accumulate() for g in gradients] opt.apply_gradients(zip(gradients, model.trainable_variables)) # SMP: Average the loss across microbatches train_loss(train_loss_value.reduce_mean()) # SMP: Merge predictions across microbatches train_accuracy(labels, train_pred.merge()) return train_loss_value.reduce_mean() # SMP: Define the smp.step for evaluation. Optionally specify an input signature. @smp.step def val_step(images, labels): val_pred = model(images, training=False) val_loss_value = loss_fn(labels, val_pred) val_loss(val_loss_value) val_accuracy(labels, val_pred) return @smp.step def test_step(images, labels): test_pred = model(images, training=False) test_loss_value = loss_fn(labels, test_pred) test_loss(test_loss_value) test_accuracy(labels, test_pred) return for epoch in range(epochs): train_loss.reset_states() train_accuracy.reset_states() val_loss.reset_states() val_accuracy.reset_states() for batch, (images, labels) in enumerate(train_dataset): start_time = time.time() training_step(images, labels, batch == 0) epoch_time = time.time() - start_time for images, labels in val_dataset: val_step(images, labels) print( f'Epoch: {epoch + 1}, ' f'Epoch duration: {epoch_time} sec, ' f'Training loss: {train_loss.result()}, ' f'Training accuracy: {train_accuracy.result() * 100}', f'Validation Loss: {val_loss.result()}, ' f'Validation Accuracy: {val_accuracy.result() * 100}') for images, labels in eval_dataset: test_step(images, labels) print('====== Test Results ======') print(f'Test loss: {test_loss.result()}, ' f'Test accuracy: {test_accuracy.result() * 100}') print('====== End of training ======') smp.barrier()
classes_pop[i] += 1 total = classes_pop[0] + classes_pop[1] + classes_pop[2] weight_for_0 = (1 / classes_pop[0]) * (total) / 3.0 weight_for_1 = (1 / classes_pop[1]) * (total) / 3.0 weight_for_2 = (1 / classes_pop[2]) * (total) / 3.0 class_weight = {0: weight_for_0, 1: weight_for_1, 2: weight_for_2} print('Weight for class 0: {:.2f}'.format(weight_for_0)) print('Weight for class 1: {:.2f}'.format(weight_for_1)) print('Weight for class 2: {:.2f}'.format(weight_for_2)) sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) rmsprops = RMSprop() optimizer = sgd for dropout, epochs, batch_size, hidden_units in [ (d, e, bs, hu) for d in [0, 0.1, 0.25, 0.5, 0.75, 0.9] for e in [50, 100, 150, 200, 250, 300, 400, 500, 700] for bs in [100, 300, 500, 700, 1000, 1500, 2000] for hu in [50, 75, 100, 125, 150, 175, 200, 300, 400, 600] ]: model = Sequential() # Dense(hidden_units) is a fully-connected layer with hidden_units hidden units. # in the first layer, you must specify the expected input data shape: # here, 200-dimensional vectors. model.add(Dense(hidden_units, activation='relu', input_dim=200)) model.add(Dropout(dropout)) model.add(Dense(hidden_units, activation='relu'))
def build_and_train_models(): images = glob.glob('dresses/*.jpg') if len(images) == 0: print('cannot find dresses') exit(0) tags = pd.read_csv('img_attr_dresses.csv') tags.index = tags['img_path'] tags = tags.drop(columns=['img_path']) tags.head() print(len(images)) if not os.path.exists(OUTPUT_DIR): os.mkdir(OUTPUT_DIR) x_train, y_train = images, tags # reshape data for CNN as (28, 28, 1) and normalize # image_size = x_train.shape[1] # # x_train = np.reshape(x_train, [-1, image_size, image_size, 1]) # x_train = x_train.astype('float32') / 255 num_labels = LABEL image_size = WIDTH # y_train = to_categorical(y_train) model_name = "cgan_2" # network parameters # the latent or z vector is 100-dim latent_size = Z_DIM batch_size = BATCH_SIZE train_steps = EPOCHS lr = 2e-4 decay = 6e-8 input_shape = (image_size, image_size, CHANNELS) label_shape = (num_labels, ) # build discriminator model inputs = Input(shape=input_shape, name='discriminator_input') labels = Input(shape=label_shape, name='class_labels') # discriminator = build_discriminator(inputs, labels, image_size) discriminator = build_discriminator(inputs, labels, image_size) # [1] or original paper uses Adam, # but discriminator converges easily with RMSprop optimizer = RMSprop(lr=lr, decay=decay) discriminator.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) discriminator.summary() # build generator model input_shape = (latent_size, ) inputs = Input(shape=input_shape, name='z_input') # generator = build_generator(inputs, labels, image_size) generator = build_generator(inputs, labels, image_size) generator.summary() # build adversarial model = generator + discriminator optimizer = RMSprop(lr=lr*0.5, decay=decay*0.5) # freeze the weights of discriminator during adversarial training discriminator.trainable = False outputs = discriminator([generator([inputs, labels]), labels]) adversarial = Model([inputs, labels], outputs, name=model_name) adversarial.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) adversarial.summary() # train discriminator and adversarial networks models = (generator, discriminator, adversarial) data = (x_train, y_train) params = (batch_size, latent_size, train_steps, num_labels, model_name) train(models, data, params)
def trainModel(self): """ Train a new model with the specified attributes of the instantiated object """ # load data throught the provided dataset object X, y = self.dataset.load() # count number of classes unique, _ = np.unique(y, return_counts=True) # call buildDNN method model = self.buildDNN(n_classes=len(unique)) # preprocess data thorugh the dataset class X_train = self.dataset.preProcessData(X) y_train = self.dataset.labalEncoding(y, n_classes=len(unique)) # define optimizer optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0) # compile the model model.compile(optimizer=optimizer, loss="categorical_crossentropy", metrics=["accuracy"]) # set a learning rate annealer learning_rate_reduction = ReduceLROnPlateau(monitor='acc', patience=3, verbose=1, factor=0.5, min_lr=0.00001) # data augmentation in order to improve model performance datagen = ImageDataGenerator( featurewise_center=False, # set input mean to 0 over the dataset samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization= False, # divide inputs by std of the dataset samplewise_std_normalization=False, # divide each input by its std zca_whitening=False, # apply ZCA whitening rotation_range=10, # randomly rotate images zoom_range=0.1, # randomly zoom image width_shift_range= 0.1, # randomly shift images horizontally (fraction of total width) height_shift_range= 0.1, # randomly shift images vertically (fraction of total height) horizontal_flip=False, # randomly flip images vertical_flip=False) # randomly flip images datagen.fit(X_train) # fit the model history = model.fit_generator(datagen.flow(X_train, y_train, batch_size=self.batch_size), epochs=self.epochs, steps_per_epoch=X_train.shape[0] // self.batch_size, callbacks=[learning_rate_reduction]) # save the model if self.char: model.save(os.path.join(self.dirBin, 'model_char.h5')) model.save_weights( os.path.join(self.dirBin, 'model_char_weights.h5')) else: model.save(os.path.join(self.dirBin, 'model_digit.h5')) model.save_weights( os.path.join(self.dirBin, 'model_digit_weights.h5')) logging.info('Model saved in {}'.format(self.dirBin)) if self.verbose: self.plotHistory(history) return model
def createModel(self): self.model_instance += 1 clear_session() if self.checkErrors(): return features, label = self.getDataset() X_train, y_train = self.createLag(features, label) X_train = X_train[:, self.lags] learning_rate = float(self.hyperparameters["Learning_Rate"].get()) if self.hyperparameters["Optimizer"] != "Adam": momentum = float(self.hyperparameters["Momentum"].get()) optimizers = { "Adam": Adam(learning_rate=learning_rate), "SGD": SGD(learning_rate=learning_rate, momentum=momentum), "RMSprop": RMSprop(learning_rate=learning_rate, momentum=momentum) } shape = (X_train.shape[1], X_train.shape[2]) model_choice = self.model_var.get() if not self.do_optimization: model = Sequential() model.add(Input(shape=shape)) if model_choice == 0: model.add(Flatten()) layers = self.no_optimization_choice_var.get() for i in range(layers): neuron_number = self.neuron_numbers_var[i].get() activation_function = self.activation_var[i].get() if model_choice == 0: model.add(Dense(neuron_number, activation=activation_function, kernel_initializer=GlorotUniform(seed=0))) model.add(Dropout(0.2)) elif model_choice == 1: model.add(Conv1D(filters=neuron_number, kernel_size=2, activation=activation_function, kernel_initializer=GlorotUniform(seed=0))) model.add(MaxPooling1D(pool_size=2)) elif model_choice == 2: if i == layers-1: model.add(LSTM(neuron_number, activation=activation_function, return_sequences=False, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0))) model.add(Dropout(0.2)) else: model.add(LSTM(neuron_number, activation=activation_function, return_sequences=True, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0))) model.add(Dropout(0.2)) elif model_choice == 3: if i == layers-1: model.add(Bidirectional(LSTM(neuron_number, activation=activation_function, return_sequences=False, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0)))) model.add(Dropout(0.2)) else: model.add(Bidirectional(LSTM(neuron_number, activation=activation_function, return_sequences=True, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0)))) model.add(Dropout(0.2)) elif model_choice == 4: if i == layers-1: model.add(SimpleRNN(neuron_number, activation=activation_function, return_sequences=False, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0))) model.add(Dropout(0.2)) else: model.add(SimpleRNN(neuron_number, activation=activation_function, return_sequences=True, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0))) model.add(Dropout(0.2)) elif model_choice == 5: if i == layers-1: model.add(GRU(neuron_number, activation=activation_function, return_sequences=False, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0))) model.add(Dropout(0.2)) else: model.add(GRU(neuron_number, activation=activation_function, return_sequences=True, kernel_initializer=GlorotUniform(seed=0), recurrent_initializer=Orthogonal(seed=0))) model.add(Dropout(0.2)) if model_choice == 1: model.add(Flatten()) model.add(Dense(32, kernel_initializer=GlorotUniform(seed=0))) model.add(Dense(1, activation=self.output_activation.get(), kernel_initializer=GlorotUniform(seed=0))) model.compile(optimizer = optimizers[self.hyperparameters["Optimizer"].get()], loss=self.hyperparameters["Loss_Function"].get()) history = model.fit(X_train, y_train, epochs=self.hyperparameters["Epoch"].get(), batch_size=self.hyperparameters["Batch_Size"].get(), verbose=1, shuffle=False) loss = history.history["loss"][-1] self.train_loss.set(loss) model.summary() self.model = model
checkpoint_path = "training/cp.ckpt" checkpoint_dir = os.path.dirname(checkpoint_path) cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path, save_weights_only=True, verbose=1) # Load previous checkpoint if it exists if os.path.exists(checkpoint_dir): autoencoder.load_weights(checkpoint_path) print("Successfully loaded training checkpoint") # Train the model print("Epochs to train:") epochs = int(input()) if (epochs > 0): autoencoder.compile(loss='mean_squared_error', optimizer=RMSprop()) autoencoder_train = autoencoder.fit(train_X, train_ground, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(valid_X, valid_ground), callbacks=[cp_callback]) # Plot loss loss = autoencoder_train.history['loss'] val_loss = autoencoder_train.history['val_loss'] epochs = range(epochs) plt.figure() plt.plot(epochs, loss, 'bo', label='Training loss')
def training(self, X_train, X_test, y_train, y_test, preprocessing): model = Sequential() model.add(Dense(4, input_dim=8, activation=self.activation)) # inputlayer model.add(Dense(self.neuron, activation=self.activation)) # hiddenlayer model.add(Dense(1, activation='linear')) # outputlayer if 'SGD' in self.optimizer: opt = SGD(lr=0.001) if 'RMSProp' in self.optimizer: opt = RMSprop(lr=0.001) if 'Adgrad' in self.optimizer: opt = Adgrad(lr=0.001) if 'Adamax' in self.optimizer: opt = Adamax(lr=0.001) if 'Adam' in self.optimizer: opt = Adam(lr=0.001) if 'Adadelta' in self.optimizer: opt = Adadelta(lr=0.001) model.compile(loss='mean_squared_error', optimizer=opt) self.history = model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, verbose=2, validation_data=(X_test,y_test)) # save history loss_history = self.history.history["loss"] # acc_history = self.history.history["soft_acc"] testing_loss_history = self.history.history["val_loss"] # testing_acc_history = self.history.history["val_soft_acc"] loss = np.array(loss_history) np.savetxt("static/loss_history.txt", loss, delimiter=",") # acc = np.array(acc_history) # np.savetxt("static/acc_history.txt", acc, delimiter=",") tes_loss = np.array(testing_loss_history) np.savetxt("static/testing_loss_history.txt", tes_loss, delimiter=",") # tes_acc = np.array(testing_acc_history) # np.savetxt("static/testing_acc_history.txt", tes_acc, delimiter=",") model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) model.save_weights('weights.h5') testPredict = model.predict(X_test) testPredict = preprocessing.scaler.inverse_transform(testPredict) # Estimate model performance trainScore = model.evaluate(X_train, y_train, verbose=0) print('Train Score: %.5f MSE (%.5f RMSE)' % (trainScore, math.sqrt(trainScore))) testScore = model.evaluate(X_test, y_test, verbose=0) print('Test Score: %.5f MSE (%.5f RMSE)' % (testScore, math.sqrt(testScore))) self.trainScore = trainScore self.testScore = testScore self.rmseTrain = math.sqrt(trainScore) self.rmseTest = math.sqrt(testScore) score = np.array([self.trainScore,self.testScore,self.rmseTrain,self.rmseTest]); np.savetxt("static/score.txt",score, delimiter=";") # plot baseline and predictions # X_test = preprocessing.scaler.inverse_transform(X_test[:,0]) y_pred = model.predict(X_test) y_predict_sample_orig = preprocessing.scaler.inverse_transform(y_pred) y_test = preprocessing.scaler.inverse_transform(np.reshape(y_test,(-1,1))) kecamatan_asli = preprocessing.label_encoder.fit_transform(X_test[:,0]) df = pd.DataFrame({'Kecamatan': kecamatan_asli.flatten(),'Aktual': y_test.flatten(), 'Prediksi': y_predict_sample_orig.flatten()}) writer = pd.ExcelWriter('static/hasil_training.xlsx', engine='xlsxwriter') df.to_excel(writer, "Sheet1") writer.save() K.clear_session()
#%% naive_method_celcius = naive_method * std[1] print(naive_method_celcius) #%% model = tf.keras.Sequential() model.add( tf.keras.layers.LSTM(32, dropout=0.2, recurrent_dropout=0.2, input_shape=(None, float_data.shape[-1]))) model.add(tf.keras.layers.Dense(1)) model.compile(optimizer=RMSprop(), loss='mae') history = model.fit_generator(train_gen, steps_per_epoch=500, epochs=40, validation_data=val_gen, validation_steps=100) #model.save("lstm32_40epoch.h5") #%% # ['date', # 'mslp(hPa)', # 't2(C)', # 'td2(C)', # 'wind_speed(m/s)', # 'wind_dir(Deg)',
x_train = x_train.reshape(60000, 784).astype('float32') / 255. x_test = x_test.reshape(10000, 784).astype('float32') / 255. # convert class vectors to binary class matrices y_train = utils.to_categorical(y_train, num_classes) y_test = utils.to_categorical(y_test, num_classes) model = Sequential() model.add(Dense(64, activation='relu', input_shape=(784, ))) model.add(Dense(32, activation='relu')) model.add(Dense(num_classes, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy']) # The following part works partly as intended. # history.history contains the key 'val_log_loss' even though it is not printed by the ProgbarLogger # (since ProgbarLogger uses logs and CustomMetric numpy_logs) history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test), callbacks=[CustomMetric(x_test, y_test)]) print(history.history)
train_images = mnist_train_images.reshape(60000, 784) test_images = mnist_test_images.reshape(10000, 784) train_images = train_images.astype('float32') test_images = test_images.astype('float32') train_images /= 255 test_images /= 255 train_labels = keras.utils.to_categorical(mnist_train_labels, 10) test_labels = keras.utils.to_categorical(mnist_test_labels, 10) model = Sequential() model.add(Dense(512, activation='relu', input_shape=(784,))) model.add(Dense(10, activation='softmax')) model.summary() model.compile(loss='categorical_crossentropy',optimizer=RMSprop(),metrics=['accuracy']) history = model.fit(train_images, train_labels,batch_size=100,epochs=15,verbose=1,validation_data=(test_images, test_labels)) score = model.evaluate(test_images, test_labels, verbose=0) print('Test loss:', score[0]) print('Test accuracy:', score[1]) for x in range(1000): test_image = test_images[x,:].reshape(1,784) predicted_cat = model.predict(test_image).argmax() label = test_labels[x].argmax() if (predicted_cat != label): plt.title('Prediction: %d Label: %d' % (predicted_cat, label)) plt.imshow(test_image.reshape([28,28]), cmap=plt.get_cmap('gray_r')) plt.show()
def __init__(self): super(YourModel, self).__init__() # TODO: Select an optimizer for your network (see the documentation # for tf.keras.optimizers) self.optimizer = RMSprop(learning_rate=hp.learning_rate, momentum=hp.momentum) # self.architecture = [ # # Block 1 # Conv2D(32, 3, 1, padding="same", activation="relu"), # Conv2D(32, 3, 1, padding="same", activation="relu"), # MaxPool2D(2), # # Block 2 # Conv2D(64, 3, 1, padding="same", activation="relu"), # Conv2D(64, 3, 1, padding="same", activation="relu"), # MaxPool2D(2), # # Block 3 # Conv2D(128, 3, 1, padding="same", activation="relu"), # Conv2D(128, 3, 1, padding="same", activation="relu"), # MaxPool2D(2), # # Last Layers # Conv2D(256, 3, 1, padding="same", activation="relu"), # MaxPool2D(2), # Dropout(0.05), # Flatten(), # #Dense takes in num classes # Dense(128,activation="relu"), # Dense(hp.num_classes, activation = "softmax") # ] self.architecture = [ # Block 1 Conv2D(64, 3, 1, padding="same", activation="relu", name="block1_conv1"), Conv2D(64, 3, 1, padding="same", activation="relu", name="block1_conv2"), MaxPool2D(2, name="block2_pool"), Dropout(rate=0.25), # Block 2 Conv2D(128, 3, 1, padding="same", activation="relu", name="block2_conv1"), Conv2D(128, 3, 1, padding="same", activation="relu", name="block2_conv2"), MaxPool2D(2, name="block3_pool"), Dropout(rate=0.25), # Block 3 Conv2D(256, 3, 1, padding="same", activation="relu", name="block3_conv1"), Conv2D(256, 3, 1, padding="same", activation="relu", name="block3_conv2"), MaxPool2D(2, name="block4_pool"), Dropout(rate=0.25), Flatten(), Dense(64, activation="relu"), Dense(6, activation="softmax") ]
print(type(base_network)) print(type(input_a)) distance = Lambda(euclid_dis, output_shape=eucl_dist_output_shape)( [processed_a, processed_b]) print(type(processed_a)) # 跑20次 model = Model([input_a, input_b], distance) # print("start") import tensorflow.keras rms = RMSprop() opt = tensorflow.keras.optimizers.Adam(lr=0.00001) model.compile(loss=contrastive_loss, optimizer=opt, metrics=[accuracy]) train_history = model.fit([train_pairs[:, 0], train_pairs[:, 1]], tf.cast(train_y, tf.float32), batch_size=200, epochs=25, validation_data=([val_pairs[:, 0], val_pairs[:, 1]], tf.cast(val_y, tf.float32))) # compute final accuracy on training and test sets y_pred_train = model.predict([train_pairs[:, 0], train_pairs[:, 1]]) train_acc = compute_accuracy(train_y, y_pred_train) y_pred_val = model.predict([val_pairs[:, 0], val_pairs[:, 1]]) val_acc = compute_accuracy(val_y, y_pred_val)
def part5(): # !wget --no-check-certificate \ # https://storage.googleapis.com/laurencemoroney-blog.appspot.com/horse-or-human.zip \ # -O /tmp/horse-or-human.zip import os # for unzip # import zipfile # local_zip = './tmp/horse-or-human.zip' # zip_ref = zipfile.ZipFile(local_zip , 'r') # zip_ref.extractall('./tmp/horse-or-human') # zip_ref.close() #Let's define each of these directories: train_horse_dir = os.path.join('./tmp/horse-or-human/horses') train_human_dir = os.path.join('./tmp/horse-or-human/humans') train_horse_names = os.listdir(train_horse_dir) train_human_names = os.listdir(train_human_dir) # let's see what the filenames # print(train_horse_names[:10]) # print(train_human_names[:10]) # Let's find out the total number of horse print('total training horse images:', len(os.listdir(train_horse_dir))) print('total training human images:', len(os.listdir(train_human_dir))) show = False if show: # Parameters for our graph; we'll output images in a 4x4 configuration nrows = 4 ncols = 4 # Index for iterating over images pic_index = 0 # Set up matplotlib fig, and size it to fit 4x4 pics fig = plt.gcf() fig.set_size_inches(ncols * 4, nrows * 4) pic_index += 8 next_horse_pix = [ os.path.join(train_horse_dir, fname) for fname in train_horse_names[pic_index - 8:pic_index] ] next_human_pix = [ os.path.join(train_human_dir, fname) for fname in train_human_names[pic_index - 8:pic_index] ] for i, img_path in enumerate(next_horse_pix + next_human_pix): # Set up subplot; subplot indices start at 1 sp = plt.subplot(nrows, ncols, i + 1) sp.axis('Off') # Don't show axes (or gridlines) img = mpimg.imread(img_path) plt.imshow(img) plt.show() test_img = mpimg.imread( os.path.join(train_horse_dir, train_horse_names[0])) print("1 image : ", test_img.shape) #Building a Small Model from Scratch model = keras.models.Sequential([ # Note the input shape is the desired size of the image 300x300 with 3 bytes color # This is the first convolution tf.keras.layers.Conv2D(16, (3, 3), activation='relu', input_shape=(300, 300, 3)), tf.keras.layers.MaxPooling2D(2, 2), # The second convolution tf.keras.layers.Conv2D(32, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # The third convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # The fourth convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # The fifth convolution tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Flatten(), # 512 neuron hidden layer tf.keras.layers.Dense(512, activation='relu'), # OutPut layer # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('horses') and 1 for the other ('humans') # a binary classification problem, we will end our network with a sigmoid activation, tf.keras.layers.Dense(1, activation='sigmoid') ]) model.summary() ''' NOTE: In this case, using the RMSprop optimization algorithm is preferable to stochastic gradient descent (SGD), because RMSprop automates learning-rate tuning for us. (Other optimizers, such as Adam and Adagrad, also automatically adapt the learning rate during training, and would work equally well here.) ''' from tensorflow.keras.optimizers import RMSprop model.compile( optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['accuracy'], ) #Data Preprocessing ''' It is uncommon to feed raw pixels into a convnet convert them to float32 tensors In our case, we will preprocess our images by normalizing the pixel values to be in the [0, 1] range (originally all values are in the [0, 255] range). ''' from tensorflow.keras.preprocessing.image import ImageDataGenerator # All images will be rescaled by 1./255 train_datagen = ImageDataGenerator(rescale=1 / 255) # Flow training images in batches of 128 using train_datagen generator train_generator = train_datagen.flow_from_directory( './tmp/horse-or-human/', # This is the source directory for training images target_size=(300, 300), # All images will be resized to 150x150 batch_size=128, # Since we use binary_crossentropy loss, we need binary labels class_mode='binary') history = model.fit(train_generator, steps_per_epoch=8, epochs=15, verbose=1) import random from tensorflow.keras.preprocessing.image import img_to_array, load_img # Let's define a new Model that will take an image as input, and will output # intermediate representations for all layers in the previous model after # the first. successive_outputs = [layer.output for layer in model.layers[1:]] # visualization_model = Model(img_input, successive_outputs) visualization_model = tf.keras.models.Model(inputs=model.input, outputs=successive_outputs) # Let's prepare a random input image from the training set. horse_img_files = [ os.path.join(train_horse_dir, f) for f in train_horse_names ] human_img_files = [ os.path.join(train_human_dir, f) for f in train_human_names ] img_path = random.choice(horse_img_files + human_img_files) img = load_img(img_path, target_size=(300, 300)) # this is a PIL image x = img_to_array(img) # Numpy array with shape (150, 150, 3) x = x.reshape((1, ) + x.shape) # Numpy array with shape (1, 150, 150, 3) # Rescale by 1/255 x /= 255 # Let's run our image through our network, thus obtaining all # intermediate representations for this image. successive_feature_maps = visualization_model.predict(x) # These are the names of the layers, so can have them as part of our plot layer_names = [layer.name for layer in model.layers[1:]] # Now let's display our representations for layer_name, feature_map in zip(layer_names, successive_feature_maps): if len(feature_map.shape) == 4: # Just do this for the conv / maxpool layers, not the fully-connected layers n_features = feature_map.shape[ -1] # number of features in feature map # The feature map has shape (1, size, size, n_features) size = feature_map.shape[1] # We will tile our images in this matrix display_grid = np.zeros((size, size * n_features)) for i in range(n_features): # Postprocess the feature to make it visually palatable x = feature_map[0, :, :, i] x -= x.mean() x /= x.std() x *= 64 x += 128 x = np.clip(x, 0, 255).astype('uint8') # We'll tile each filter into this big horizontal grid display_grid[:, i * size:(i + 1) * size] = x # Display the grid scale = 20. / n_features plt.figure(figsize=(scale * n_features, scale)) plt.title(layer_name) plt.grid(False) plt.imshow(display_grid, aspect='auto', cmap='viridis')
def keras_model_fn(learning_rate, weight_decay, optimizer, momentum): """keras_model_fn receives hyperparameters from the training job and returns a compiled keras model. The model will be transformed into a TensorFlow Estimator before training and it will be saved in a TensorFlow Serving SavedModel at the end of training. Args: hyperparameters: The hyperparameters passed to the SageMaker TrainingJob that runs your TensorFlow training script. Returns: A compiled Keras model """ model = Sequential() model.add( Conv2D(32, (3, 3), padding='same', name='inputs', input_shape=(HEIGHT, WIDTH, DEPTH))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Conv2D(32, (3, 3))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.2)) model.add(Conv2D(64, (3, 3), padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Conv2D(64, (3, 3))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.3)) model.add(Conv2D(128, (3, 3), padding='same')) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Conv2D(128, (3, 3))) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.4)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(NUM_CLASSES)) model.add(Activation('softmax')) size = 1 if optimizer.lower() == 'sgd': opt = SGD(lr=learning_rate * size, decay=weight_decay, momentum=momentum) elif optimizer.lower() == 'rmsprop': opt = RMSprop(lr=learning_rate * size, decay=weight_decay) else: opt = Adam(lr=learning_rate * size, decay=weight_decay) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) return model
NP_PATH = "data/full_numpy_bitmap_camel.npy" GEN_DAT_PATH = "data/gen_data/" if not os.path.isdir(GEN_DAT_PATH): os.mkdir(GEN_DAT_PATH) reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.5, patience=10, verbose=1) early_stopping = EarlyStopping(monitor='loss', min_delta=0, patience=10, verbose=1) tensorboard = TensorBoard(log_dir='./Graph', histogram_freq=0, write_graph=True, write_images=True) checkpoint = ModelCheckpoint('ep{epoch:03d}-loss{loss:.3f}.h5', monitor='loss', save_weights_only=True, save_best_only=True, period=5) opt_discriminator = RMSprop(lr=0.00002) opt_gan = RMSprop(lr=0.001) discriminator = model.discriminator() discriminator.compile(optimizer=opt_discriminator, loss="binary_crossentropy", callbacks=[reduce_lr, tensorboard, checkpoint]) generator = model.generator() discriminator.trainable = False gan_input = Input((100,)) gan_output = discriminator(generator(gan_input)) gan_model = Model(gan_input, gan_output) gan_model.compile(optimizer=opt_gan, loss="binary_crossentropy", callbacks=[tensorboard, checkpoint])
def training(self, trainX, trainY, testX, testY, preprocessing): model = Sequential() model.add(Dense(2, input_dim=2, activation=self.activation)) # inputlayer model.add(Dense(self.neuron, activation=self.activation)) # hiddenlayer model.add(Dense(1, activation='linear')) # outputlayer if 'SGD' in self.optimizer: opt = SGD(lr=self.learning_rate, momentum=0.0, decay=0.0, nesterov=False) if 'RMSProp' in self.optimizer: opt = RMSprop(lr=self.learning_rate, rho=0.9, epsilon=None, decay=0.0) if 'Adgrad' in self.optimizer: opt = Adagrad(lr=self.learning_rate, epsilon=None, decay=0.0) if 'Adamax' in self.optimizer: opt = Adamax(lr=self.learning_rate, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0) if 'Adam' in self.optimizer: opt = Adam(lr=self.learning_rate, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False) if 'Adadelta' in self.optimizer: opt = Adadelta(lr=self.learning_rate, rho=0.95, epsilon=None, decay=0.0) model.compile(loss='mean_squared_error', optimizer=opt) self.history = model.fit(trainX, trainY, epochs=self.epoch, batch_size=self.batch_size, verbose=2, validation_data=(testX, testY)) # save history loss_history = self.history.history["loss"] # acc_history = self.history.history["soft_acc"] testing_loss_history = self.history.history["val_loss"] # testing_acc_history = self.history.history["val_soft_acc"] loss = np.array(loss_history) np.savetxt("static/loss_history.txt", loss, delimiter=",") # acc = np.array(acc_history) # np.savetxt("static/acc_history.txt", acc, delimiter=",") tes_loss = np.array(testing_loss_history) np.savetxt("static/testing_loss_history.txt", tes_loss, delimiter=",") # tes_acc = np.array(testing_acc_history) # np.savetxt("static/testing_acc_history.txt", tes_acc, delimiter=",") model_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) model.save_weights('weights.h5') testPredict = model.predict(testX) testPredict = preprocessing.scaler.inverse_transform(testPredict) # Estimate model performance trainScore = model.evaluate(trainX, trainY, verbose=0) print('Train Score: %.5f MSE (%.5f RMSE)' % (trainScore, math.sqrt(trainScore))) testScore = model.evaluate(testX, testY, verbose=0) print('Test Score: %.5f MSE (%.5f RMSE)' % (testScore, math.sqrt(testScore))) self.trainScore = trainScore self.testScore = testScore self.rmseTrain = math.sqrt(trainScore) self.rmseTest = math.sqrt(testScore) score = np.array( [self.trainScore, self.testScore, self.rmseTrain, self.rmseTest]) np.savetxt("static/score.txt", score, delimiter=";") # plot baseline and predictions testY = preprocessing.scaler.inverse_transform( np.reshape(testY, (-1, 1))) testX = testX.astype(int) testY = testY.astype(int) testPredict = testPredict.astype(int) obat_asli = preprocessing.label_encoder.inverse_transform(testX[:, 0]) testX = testX.astype("S100") testY = testY.astype("S100") testX[:, 0] = obat_asli simpan = np.hstack((testX, testY)) simpan = np.hstack((simpan, testPredict)) simpan = np.delete(simpan, 1, axis=1) df = pd.DataFrame(simpan) df.columns = ["Obat", "Actual", "Predicted"] writer = pd.ExcelWriter('static/hasil_training.xlsx', engine='xlsxwriter') df.to_excel(writer, "Sheet1") writer.save() K.clear_session()
tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(32, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), tf.keras.layers.Conv2D(64, (3, 3), activation='relu'), tf.keras.layers.MaxPooling2D(2, 2), # Flatten the results to feed into a DNN tf.keras.layers.Flatten(), # 512 neuron hidden layer tf.keras.layers.Dense(512, activation='relu'), # Only 1 output neuron. It will contain a value from 0-1 where 0 for 1 class ('cats') and 1 for the other ('dogs') tf.keras.layers.Dense(1, activation='sigmoid') ]) model.summary() model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['accuracy']) # 1. DATA PREPROCESSING # All images will be rescaled by 1./255. train_datagen = ImageDataGenerator(rescale=1.0 / 255.) test_datagen = ImageDataGenerator(rescale=1.0 / 255.) # -------------------- # Flow training images in batches of 20 using train_datagen generator # -------------------- train_generator = train_datagen.flow_from_directory(train_dir, batch_size=20, class_mode='binary',
# DEFINE A KERAS MODEL TO CLASSIFY CATS V DOGS # USE AT LEAST 3 CONVOLUTION LAYERS model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D(16, (3,3), activation='relu', input_shape=(150, 150, 3)), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(32, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ]) model.compile(optimizer=RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['accuracy']) TRAINING_DIR = training_dir train_datagen = ImageDataGenerator(rescale = 1.0/255.) train_generator = train_datagen.flow_from_directory( TRAINING_DIR, target_size=(150, 150), batch_size=10, class_mode='binary' ) VALIDATION_DIR = testing_dir validation_datagen = ImageDataGenerator(rescale = 1.0/255.) validation_generator = validation_datagen.flow_from_directory(