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(
