def generate_second_model(num_classes, batch_size, epochs, x_train, y_train):
model = Sequential()
# 1st convolution layer
model.add(
Conv2D(64, (5, 5),
input_shape=(48, 48, 1),
activation='softmax',
padding='same'))
model.add(MaxPooling2D(pool_size=(5, 5)))
# 2nd convolution layer
model.add(Conv2D(128, (5, 5), activation='softmax', padding='same'))
model.add(Conv2D(128, (5, 5), activation='softmax', padding='same'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1024, activation='softmax'))
model.add(Dropout(0.2))
model.add(Dense(1024, activation='softmax'))
model.add(Dropout(0.2))
model.add(Dense(num_classes, activation='softmax'))
# ------------------------------
# batch process
gen = ImageDataGenerator()
train_generator = gen.flow(x_train, y_train, batch_size=batch_size)
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
model.fit_generator(train_generator,
steps_per_epoch=batch_size,
epochs=epochs)
return model
def train(data_set, steps_per_epoch):
model = Sequential()
model.add(Conv2D(8, (3, 3),
activation='relu',
input_shape=(816, 816, 3)))
model.add(Conv2D(8, (3, 3),
activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(rate=0.5))
model.add(Flatten())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(lables_size, activation='softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.categorical_crossentropy,
metrics=['accuracy'])
model.fit_generator(batch_generator(data_set, batch_size, img_w, img_h, channels),
steps_per_epoch=steps_per_epoch,
epochs=3,
verbose=1)
# score = model.evaluate(x_test, y_test)
model.save(model_path)
def run_state_model(state_name, batch_size = 5, n_input = 5, num_epochs=25, num_per_epoch=100, qverbose=2, graph=0, base_path="Models/"):
# path = f"{base_path}{state_name}"
path = str(base_path) + str(state_name)
model = None
#This try catch block either gets a preexisting model or creates a new one
try:
model = load_model(path)
print("Model {} found, continuing training".format(path))
except:
#print("python 2.7?")
print("Path {} not found, training new model for {}".format(path, state_name))
if (model == None):
model = Sequential()
model.add(LSTM(100, activation='relu', input_shape=(n_input,1), return_sequences=True))
model.add(LSTM(100, activation='relu', input_shape=(1, n_input)))
model.add(Dropout(0.3))
model.add(Dense(1))
model.compile(loss="mse", optimizer="adam")
#Data preprocessing block
phase_time, cases, scaler = get_cases(state_name)
# plt.plot(phase_time, cases)
print(max(scaler.inverse_transform(cases)))
phase_time = phase_time.reshape((len(phase_time), 1))
cases = cases.reshape((len(cases), 1))
print(len(cases), len(phase_time))
#print(cases)
data_gen = TimeseriesGenerator(phase_time, cases,
length=n_input, batch_size=5)
print("RUNNING TRAINING FOR {}".format(state_name))
model.fit_generator(data_gen, steps_per_epoch=100, epochs=15, verbose=0)
# filename = f"{state_name}"
filename = str(state_name)
print("TRAINING FOR {} FINISHED, WRITING OUT MODEL TO FILE".format(state_name))
model.save(str(base_path) + str(filename)) #f"{base_path}{filename}")
delt = abs(phase_time[1]-phase_time[0])
if (graph == 1):
graph_cases(model, phase_time, cases, delt, scaler)
predictslist = scaler.inverse_transform([single_predict(i, model, delt, scaler) for i in np.arange(phase_time[0],phase_time[0]+(len(cases)+30)*delt,delt)])
# new_data[f'{state_name} Predict'] = np.squeeze(predictslist)
new_data[state_name + ' Predict'] = np.squeeze(predictslist)
class ModelFive():
def __init__(self, train_loc, val_loc, batch_size):
self.train_loc = train_loc
self.val_loc = val_loc
self.batch_size = batch_size
def load_and_prep_data(self):
with open(self.train_loc, 'rb') as f:
self.t_data = pickle.load(f)
with open(self.val_loc, 'rb') as f:
self.v_data = pickle.load(f)
global train_step, val_step
train_step = 0
val_step = 0
for t in self.t_data.X_list:
train_step += int(len(t) / self.batch_size) + 1
for t in self.v_data.X_list:
val_step += int(len(t) / self.batch_size) + 1
def data_generator(self, mode):
while True:
if mode == 'train':
data = self.t_data
elif mode == 'validation':
data = self.v_data
for X, Y in zip(data.X_list, data.Y_list):
i = 0
j = self.batch_size
x, y = X[i:j], Y[i:j]
yield (x, y)
length = len(X)
while j < length:
i += self.batch_size
j += self.batch_size
x, y = X[i:j], Y[i:j]
yield (x, y)
def define_model(self, hidden_size):
input_size = self.t_data.X_list[0].shape[2]
self.model = Sequential()
self.model.add(Masking(input_shape=(None, input_size)))
self.model.add(Bidirectional(LSTM(hidden_size, return_sequences=True)))
self.model.add(Bidirectional(LSTM(hidden_size, return_sequences=True)))
self.model.add(TimeDistributed(Dense(12, activation='sigmoid')))
print('compiling')
self.model.compile(loss='mean_squared_error',
optimizer='rmsprop',
metrics=['mse'])
def train(self, num_epochs):
train_gen = self.data_generator('train')
val_gen = self.data_generator('validation')
self.model.fit_generator(train_gen,
steps_per_epoch=train_step,
validation_data=val_gen,
validation_steps=val_step,
epochs=num_epochs)
def train_features_integration_layer(train_features_path, test_features_path, model_path):
tr_data = h5py.File(train_features_path, 'r+')
te_data = h5py.File(test_features_path, 'r+')
labels = meta.get_train_labels_list()
class_weights = compute_class_weight('balanced', np.unique(labels), labels)
batch_size = 64
epochs = 200
create_folder(os.path.dirname(model_path))
mc_top = ModelCheckpoint(model_path, monitor='val_loss', verbose=1, save_best_only=True,
save_weights_only=False, mode='auto', period=1)
input_shape = tr_data['x'].shape[1:]
model = Sequential([
BatchNormalization(input_shape=input_shape),
Dropout(0.5),
#Dense(2048, activation='tanh'),
#BatchNormalization(),
#Dropout(0.5),
Dense(1024, activation='tanh'),
BatchNormalization(),
Dropout(0.5),
Dense(512, activation='tanh'),
BatchNormalization(),
Dropout(0.5),
Dense(256, activation='tanh'),
BatchNormalization(),
Dropout(0.5),
# Dense(256, activation='relu'),
# BatchNormalization(),
# Dropout(0.6),
Dense(128, activation='tanh'),
BatchNormalization(),
Dropout(0.5),
# Dense(32, activation='relu'),
# BatchNormalization(),
# Dropout(0.6),
Dense(17, activation='sigmoid')
])
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
gen = RatioDataGenerator(batch_size=batch_size, type='train')
model.fit_generator(generator=gen.generate(tr_data),
steps_per_epoch= 100,
epochs=epochs,
verbose=1,
callbacks=[mc_top],
validation_data=(te_data['x'], te_data['y']),
class_weight=class_weights)
def train():
print('Training started...')
maxsize = (100, 100)
# train_labels_data = prepare_label_data('/Users/mehrdad/Documents/Dev/TheGreenBots/data/labels.json')
(train_images,
train_labels) = load_image_dataset(os.path.join(PROJECT_PATH, 'images/'),
maxsize)
# display_images(train_images, train_labels, class_names)
# plt.show()
# Setting up the layers.
classifier = Sequential()
classifier.add(
keras.layers.Conv2D(32, (3, 3),
input_shape=(100, 100, 3),
activation='relu'))
classifier.add(keras.layers.MaxPooling2D(pool_size=(2, 2)))
classifier.add(keras.layers.Flatten())
classifier.add(keras.layers.Dense(units=128, activation='relu'))
classifier.add(keras.layers.Dense(units=1, activation='sigmoid'))
classifier.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
train_datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
training_set = train_datagen.flow_from_directory(os.path.join(
PROJECT_PATH, 'images/'),
batch_size=32,
class_mode='binary',
color_mode='rgb')
test_set = test_datagen.flow_from_directory(os.path.join(
PROJECT_PATH, 'straight/'),
batch_size=32,
class_mode='binary',
color_mode='rgb')
classifier.fit_generator(
training_set,
steps_per_epoch=10, # 8000
epochs=5,
validation_data=test_set,
validation_steps=20 # 2000
)
return classifier
def network(train_generator, validation_generator, test_generator,
callback_list):
model = Sequential()
model.add(
layers.Deconv2D(32, (3, 3),
activation="relu",
input_shape=(150, 150, 3)))
model.add(layers.MaxPooling2D(pool_size=(2, 2)))
model.add(layers.Deconv2D(64, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D(pool_size=(2, 2)))
model.add(layers.Deconv2D(128, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D(pool_size=(2, 2)))
model.add(layers.Deconv2D(128, (3, 3), activation="relu"))
model.add(layers.MaxPooling2D(pool_size=(2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(512, activation="relu"))
model.add(layers.Dense(1, activation="sigmoid"))
model.compile(optimizer=optimizers.RMSprop(lr=1e-4),
loss='binary_crossentropy',
metrics=['acc'])
history = model.fit_generator(train_generator,
steps_per_epoch=50,
epochs=50,
callbacks=callback_list,
validation_data=validation_generator,
validation_steps=50)
model.save('cats_and_dogs_small_2.h5')
return history
def main():
# Name of this script
script_name = os.path.basename(__file__)[0:-3]
# Construct folder name using name of this script
output_path_name = '_{}_outputs'.format(script_name)
# Try to create a new folder
try:
# Make the output folder
os.mkdir(output_path_name)
except FileExistsError:
pass
# Model below this line ================================================
custom_callback = get_custom_callback('multi_label', './{}'.format(output_path_name))
callbacks_list = [custom_callback]
x_train, y_train, x_test, y_test = get_values()
y_train = to_categorical(y_train, NUM_CLASSES)
y_test = to_categorical(y_test, NUM_CLASSES)
datagen = ImageDataGenerator(
horizontal_flip=True,
vertical_flip=True,
rotation_range=360
)
model = Sequential()
densenet = DenseNet121(
weights='./DenseNet-BC-121-32-no-top.h5',
include_top=False,
input_shape=(IMG_SIZE, IMG_SIZE, 3)
)
model.add(densenet)
model.add(layers.GlobalAveragePooling2D())
model.add(layers.Dropout(0.5))
# model.add(layers.Dense(NUM_CLASSES, activation='softmax'))
model.add(layers.Dense(NUM_CLASSES, activation='sigmoid'))
model.summary()
model.compile(loss='binary_crossentropy',
# optimizer=optimizers.Adam(lr=0.0001,decay=1e-6),
optimizer=optimizers.SGD(lr=0.0001, momentum=0.9),
metrics=['accuracy'])
# fits the model on batches with real-time data augmentation:
history = model.fit_generator(
datagen.flow(x_train, y_train, batch_size=BATCH_SIZE, seed=1),
steps_per_epoch=len(x_train) // BATCH_SIZE,
epochs=NUM_EPOCHS,
validation_data=(x_test, y_test),
callbacks=callbacks_list,
max_queue_size=2
)
class Model():
def __init__(self):
self.X_train = []
self.Y_train = []
self.model = Sequential()
def add_training_files(self, path):
with open(path, 'r') as f:
training_files = f.readlines()
pattern = re.compile('mngu0_s1_(\d{4})\n')
for filename in training_files:
num = int(pattern.match(filename).group(1))
self.X_train.append(self.lsfs[num])
self.Y_train.append(self.emas[num])
def load_lsf_data(self, path):
self.lsfs = get_all_data(path, 'lsf')
def load_ema_data(self, path):
self.emas = get_all_data(path, 'ema')
def define_model(self, hidden_size, input_size):
self.model.add(
LSTM(hidden_size,
return_sequences=True,
input_shape=(None, input_size)))
self.model.add(Activation('sigmoid'))
print('compiling')
self.model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=['accuracy'])
def data_generator(self, test=False):
while True:
if test:
x_list, y_list = self.X_test, self.Y_test
else:
x_list, y_list = self.X_train, self.Y_train
for x, y in zip(x_list, y_list):
yield (x.reshape(1, len(x),
len(x[0])), y.reshape(1, len(y), len(y[0])))
def train_model(self):
data_gen = self.data_generator()
self.model.fit_generator(data_gen, steps_per_epoch=100, epochs=1)
def generate_first_model(num_classes, batch_size, epochs, x_train, y_train):
model = Sequential()
# 1st convolution layer
model.add(Conv2D(64, (5, 5), activation='relu', input_shape=(48, 48, 1)))
model.add(MaxPooling2D(pool_size=(5, 5), strides=(2, 2)))
# 2nd convolution layer
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
# 3rd convolution layer
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(AveragePooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Flatten())
# fully connected neural networks
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(num_classes, activation='softmax'))
# ------------------------------
# batch process
gen = ImageDataGenerator()
train_generator = gen.flow(x_train, y_train, batch_size=batch_size)
# ------------------------------
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
# model.fit_generator(x_train, y_train, epochs=epochs) #train for all trainset
model.fit_generator(train_generator,
steps_per_epoch=batch_size,
epochs=epochs) # train for randomly selected one
return model
def get_basic_gru_model():
model = Sequential()
model.add(layers.GRU(32, input_shape=(None, float_data.shape[-1])))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
steps_per_epoch=500,
epochs=20,
validation_data=val_gen,
validation_steps=val_steps)
return history
def get_basic_ml_model():
model = Sequential()
model.add(
layers.Flatten(input_shape=(lookback // step, float_data.shape[-1])))
model.add(layers.Dense(32, activation='relu'))
model.add(layers.Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
steps_per_epoch=500,
epochs=20,
validation_data=val_gen,
validation_steps=val_steps)
return history
def train(self):
rnn_type = LSTM
rnn_dropout = 0.0
rnn_units = 128
rnn_timesteps = 128
rnn_features = 32
output_size = 1
batch_size = 512
epochs = 10000000
input_shape = (rnn_timesteps, rnn_features)
if os.path.isfile(self.model_path):
profiler = Profiler()
model = load_model(self.model_path,
custom_objects={
'root_mean_squared_error':
root_mean_squared_error
})
profiler.stop(f'Loaded model from "{self.model_path}".')
else:
model = Sequential()
model.add(
rnn_type(rnn_units,
dropout=rnn_dropout,
return_sequences=False,
input_shape=input_shape))
model.add(Dense(output_size))
model.add(Activation('tanh'))
optimizer = Adam(lr=0.01)
model.compile(optimizer=optimizer, loss=root_mean_squared_error)
training_generator = SlidingWindowGenerator(self.x_training_wav,
self.y_training_wav,
input_shape, output_size,
batch_size)
validation_generator = SlidingWindowGenerator(self.x_validation_wav,
self.y_validation_wav,
input_shape, output_size,
batch_size)
save_callback = SaveCallback(self.model_path)
history = model.fit_generator(generator=training_generator,
epochs=epochs,
verbose=1,
validation_data=validation_generator,
callbacks=[save_callback])
def training():
train_generator, validation_generator = prepare_data()
# train_generator, validation_generator, test_generator = prepare_data()
resnet50_network = ResNet50(include_top=False,
weights='imagenet',
input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3))
for layer in resnet50_network.layers[:-3]:
layer.trainable = False
model = Sequential()
model.add(resnet50_network)
model.add(AveragePooling2D((7, 7), name='avg_pool'))
model.add(Flatten())
model.add(
Dense(train_generator.class_indices.items().__len__(),
activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.001),
metrics=['accuracy'])
early_stopping = EarlyStopping(patience=10)
checkpointer = ModelCheckpoint(filepath='car_resNet50_best.h5',
verbose=0,
save_best_only=True)
csv_logger = CSVLogger('ResNet50_training_log.csv',
append=True,
separator=';')
history = model.fit_generator(
train_generator,
steps_per_epoch=train_generator.samples / train_generator.batch_size,
epochs=EPOCHS,
callbacks=[early_stopping, checkpointer, csv_logger],
validation_data=validation_generator,
validation_steps=validation_generator.samples /
validation_generator.batch_size)
# evaluate_scores = model.evaluate_generator(generator=test_generator)
model.save('car_resNet50_final.h5')
model.sample_weights('resNet50_weights')
show_history(history)
def get_1d_convnet_model():
model = Sequential()
model.add(layers.Conv1D(32, 5, input_shape=(None, float_data.shape[-1])))
model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32, 5, activation='relu'))
model.add(layers.MaxPooling1D(3))
model.add(layers.Conv1D(32, 5, activation='relu'))
model.add(layers.GlobalMaxPooling1D())
model.add(layers.Dense(1))
model.summary()
model.compile(optimizer=RMSprop(), loss='mae')
history = model.fit_generator(train_gen,
steps_per_epoch=500,
epochs=20,
validation_data=val_gen,
validation_steps=val_steps)
return history
def get_rec_stacked_model():
model = Sequential()
model.add(
layers.GRU(32,
input_shape=(None, float_data.shape[-1]),
dropout=0.1,
recurrent_dropout=0.5,
return_sequences=True))
model.add(
layers.GRU(64,
input_shape=(None, float_data.shape[-1]),
dropout=0.1,
recurrent_dropout=0.5,
activation='relu'))
model.add(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=val_steps)
return history
learner.summary()
learner.compile(loss=keras.losses.categorical_crossentropy,
optimizer=Adam(amsgrad=True),
metrics=['accuracy'])
checkpoint = ModelCheckpoint(filepath='fashion_learner.hdf5',
verbose=1,
save_best_only=True,
monitor='val_acc')
for i in range(0, 20):
learner.fit(x_train,
y_train,
batch_size=batch_size,
epochs=25,
shuffle=True,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[checkpoint, reduce_lr])
learner.fit_generator(data_gen.flow(x_train,
y_train,
batch_size=batch_size),
steps_per_epoch=len(x_train) / batch_size,
epochs=25,
shuffle=True,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[checkpoint, reduce_lr])
top_model.add(Dense(256, activation='relu'))
top_model.add(Dense(64, activation='relu'))
top_model.add(Dense(1))
top_model.compile(loss='mean_squared_error', optimizer='adam', metrics=[rmse])
filepath = ('resnet50-freeze-{epoch:02d}-{val_loss:.2f}.h5')
checkpoint = ModelCheckpoint(filepath,
monitor='val_loss',
save_best_only=True,
verbose=1,
period=2)
train_df = label_file.iloc[:int(np.floor(label_file.shape[0] * 0.7)), :]
valid_df = label_file.iloc[int(np.floor(label_file.shape[0] * 0.7)):, :]
train_gen = generator_from_df(train_df, batch_size, target_size)
valid_gen = generator_from_df(valid_df, batch_size, target_size)
nbatches_train, mod = divmod(train_df.shape[0], batch_size)
nbatches_valid, mod = divmod(valid_df.shape[0], batch_size)
nworkers = 8
print("Training model...")
top_model.fit_generator(train_gen,
steps_per_epoch=nbatches_train,
epochs=epochs,
validation_data=valid_gen,
validation_steps=nbatches_valid,
workers=nworkers,
verbose=2)
class ImageClassifier(object):
"""
Image classifier class
"""
def __init__(self, args):
"""
Initializes the required variables
"""
self.args = args
self.model = None
self.data = None
self.df = None
self.x = None
self.y = None
self.xTrain = None
self.xTest = None
self.yTrain = None
self.yTest = None
self.numClasses = 3
self.activation = 'relu'
self.tensorBoard = TensorBoard(log_dir='./tenosorboard',
histogram_freq=0,
write_graph=True,
write_images=True)
self.trainDataGen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
self.testDataGen = ImageDataGenerator(rescale=1. / 255)
def createModel(self):
"""
Creates a Conv2D sequential Keras model
One can play with the numbers of conv layers and others except input shape.
I've optimized below numbers considering my HW limitations
"""
self.model = Sequential()
self.model.add(
Conv2D(16,
kernel_size=5,
padding='same',
input_shape=(
250,
250,
3,
),
activation=self.activation))
self.model.add(MaxPool2D(pool_size=(2, 2)))
self.model.add(
Conv2D(8,
kernel_size=5,
padding='same',
activation=self.activation))
self.model.add(MaxPool2D(pool_size=(2, 2)))
self.model.add(Dropout(0.3))
self.model.add(Flatten())
self.model.add(Dense(300, activation=self.activation))
self.model.add(Dense(self.numClasses, activation='softmax'))
self.model.summary()
self.model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=0.001),
metrics=['accuracy'])
def loadAndPrepareData(self):
"""
Loads the data from npz file and prepares it for feeding it to network
"""
#I've used data file as npz. And images are stored in (250 * 250 * 1) i.e, GRAY format of CV2
self.data = np.load(self.args.data)
# Loading the data in dataFrame of pandas
self.df = pd.DataFrame(self.data.items()[0][1])
# Normalizing the data by dividing the individual element by 255
self.x = np.array([np.divide(item, 255) for item in self.df[0]])
# Loading the xData in x
self.y = np.array([item for item in self.df[1]])
# Reshaping it for accomodation on model. New shape = (250, 250, 1, 1)
self.x = self.x.reshape(self.x.shape[0], self.x.shape[1],
self.x.shape[2], 1)
# Splitting the xTrain, xTest, yTrain and yTest from x and y
self.xTrain, self.xTest, self.yTrain, self.yTest = train_test_split(
self.x, self.y, test_size=0.2)
# Number of classes are
# 1. Myself (Siddhesh)
# 2. My beautiful wife (Ketaki)
# 3. Unknown (None of us or ppl whom the model had never seen)
self.numClasses = self.y.shape[1]
def dataGenerator(self):
self.trainGenerator = self.trainDataGen.flow_from_directory(
directory=self.args.data,
target_size=(250, 250),
color_mode='rgb',
batch_size=30,
class_mode='categorical',
shuffle=True)
def train(self):
#history = self.model.fit(self.xTrain, self.yTrain, batch_size=self.args.batchSize, epochs=self.args.epochs, verbose=1, callbacks=[self.tensorBoard])
history = self.model.fit_generator(self.trainGenerator,
steps_per_epoch=50,
epochs=self.args.epochs,
callbacks=[self.tensorBoard])
if self.args.save:
print('Saving the model to {}'.format(self.args.save))
self.model.save(self.args.save)
print(history)
fig1, ax_acc = plt.subplots()
plt.plot(history.history['acc'])
plt.plot(history.history['loss'])
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
# This is a blocking call, user will have to manually close the window opened by matplotlib showing accuracy vs loss data.
plt.show()
def evaluate(self):
score = self.model.evaluate(self.xTest, self.yTest)
print(score)
# trim image to only see section with road
X_train = np.array(images)
y_train = np.array(angles)
yield sklearn.utils.shuffle(X_train, y_train)
# compile and train the model using the generator function
train_generator = generator(train_samples, batch_size=32)
validation_generator = generator(validation_samples, batch_size=32)
ch, row, col = 3, 80, 320 # Trimmed image format
model = Sequential()
# Preprocess incoming data, centered around zero with small standard deviation
model.add(
Lambda(lambda x: x / 127.5 - 1.,
input_shape=(ch, row, col),
output_shape=(ch, row, col)))
model.add() # ... finish defining the rest of your model architecture here ...
model.compile(loss='mse', optimizer='adam')
model.fit_generator(train_generator,
samples_per_epoch=len(train_samples),
validation_data=validation_generator,
nb_val_samples=len(validation_samples),
nb_epoch=3)
"""
If the above code throw exceptions, try
model.fit_generator(train_generator, steps_per_epoch= len(train_samples),
validation_data=validation_generator, validation_steps=len(validation_samples), epochs=5, verbose = 1)
"""
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dir',
default='../data/FIDS30/',
help='Root folder for the (unprocessed) data set.')
parser.add_argument(
'--log_dir',
default=
'C:\\Users\\Patrick\\Documents\\TU\\2019S\\ML\\ML_Exercise3\\ML_Exercise3',
help='Root folder for TensorBoard logging.')
dir = parser.parse_args().dir
log_dir = parser.parse_args().log_dir
os.chdir(dir)
fileNames = glob.glob("*/*.jpg")
targetLabels = []
imageList = []
for fileName in fileNames:
pathSepIndex = fileName.index(os.path.sep)
targetLabels.append(fileName[:pathSepIndex])
# print(np.array(Image.open(fileName)).shape)
image = cv2.resize(np.array(Image.open(fileName)), image_size)
imageList.append(np.array(image))
toDelete = np.where(np.array([x.shape for x in imageList]) == 4)[0][0]
del imageList[toDelete]
imageArr = np.array(imageList)
#imageArr = imageArr / 255.0
le = preprocessing.LabelEncoder()
le.fit(targetLabels)
target = le.transform(targetLabels)
target = np.delete(target, toDelete, 0)
target_C = to_categorical(target)
# imageArr = np.array(imageList)
X_train, X_test, y_train, y_test = train_test_split(imageArr,
target_C,
random_state=42)
datagen_train = ImageDataGenerator(
rescale=1. / 255,
featurewise_center=True,
featurewise_std_normalization=True,
rotation_range=10,
#width_shift_range=0.1,
#height_shift_range=0.1,
#shear_range=0.1,
#zoom_range=0.1,
horizontal_flip=True,
#vertical_flip=True
)
datagen_train.fit(X_train)
generator_train = datagen_train.flow(X_train,
y_train,
batch_size=batch_size)
datagen_test = ImageDataGenerator(rescale=1. / 255,
featurewise_center=True,
featurewise_std_normalization=True)
datagen_test.fit(X_train)
generator_test = datagen_test.flow(X_test, y_test, batch_size=batch_size)
# Instantiate an empty model
model = Sequential()
# 1st Convolutional Layer
model.add(
Conv2D(filters=96,
input_shape=(224, 224, 3),
kernel_size=(11, 11),
strides=(4, 4),
padding='valid'))
model.add(Activation('relu'))
# Max Pooling
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# 2nd Convolutional Layer
model.add(
Conv2D(filters=256,
kernel_size=(11, 11),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# Max Pooling
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# 3rd Convolutional Layer
model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# 4th Convolutional Layer
model.add(
Conv2D(filters=384,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# 5th Convolutional Layer
model.add(
Conv2D(filters=256,
kernel_size=(3, 3),
strides=(1, 1),
padding='valid'))
model.add(Activation('relu'))
# Max Pooling
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid'))
# Passing it to a Fully Connected layer
model.add(Flatten())
# 1st Fully Connected Layer
model.add(Dense(4096, input_shape=(224 * 224 * 3, )))
model.add(Activation('relu'))
# Add Dropout to prevent overfitting
# model.add(Dropout(0.2))
# 2nd Fully Connected Layer
model.add(Dense(4096))
model.add(Activation('relu'))
# Add Dropout
# model.add(Dropout(0.2))
# 3rd Fully Connected Layer
model.add(Dense(1000))
model.add(Activation('relu'))
# Add Dropout
# model.add(Dropout(0.2))
# Output Layer
model.add(Dense(30))
model.add(Activation('softmax'))
model.summary()
# Compile the model
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
now = time.strftime("%b%d_%H-%M")
model.fit_generator(generator_train,
steps_per_epoch=512 // batch_size,
epochs=50,
validation_data=generator_test,
validation_steps=500 // batch_size,
callbacks=[
TensorBoard(histogram_freq=0,
log_dir=os.path.join(
log_dir, 'logs', now + '-' + NAME),
write_graph=True)
])
class Model(object):
def __init__(self, Config):
self.config = Config
self.model = None
self.word2numF, self.num2word, \
self.words, self.poems \
= prepare_data()
self.poem = self.poems.split(']')
self.poem_num = len(self.poem)
if os.path.exists(self.config.model_path):
self.model = load_model(self.config.model_path)
else:
self.train()
def sample(self, preds, diversity=1.0):
preds = np.asarray(preds).astype('float64')
exp_preds = np.power(preds, 1. / diversity)
preds = exp_preds / np.sum(exp_preds)
pro = np.random.choice(range(len(preds)), 1, p=preds)
return int(pro.squeeze())
def _preds(self, sentence, length=18, diversity=1.0):
'''生成长度为length的字符串'''
sentence = sentence[:self.config.max_len]
generate = ''
for i in range(length):
pred = self._pred(sentence, diversity)
generate += pred
sentence = sentence[1:] + pred
return generate
def _pred(self, sentence, diversity=1.0):
'''预测下一个字符'''
sentence = sentence[-self.config.max_len:]
x_pred = np.zeros(shape=(1, self.config.max_len), dtype=np.int32)
for t, char in enumerate(sentence):
x_pred[0, t] = self.word2numF(char)
preds = self.model.predict(x_pred)[0]
next_index = self.sample(preds, diversity=diversity)
next_char = self.num2word[next_index]
return next_char
def predict_sen(self, sen, diversity=1.0):
'''给定第一句（前6个字符）'''
sentence = sen[-self.config.max_len:]
generate = str(sentence)
generate += self._preds(sentence,
length=self.config.poem_len -
self.config.max_len,
diversity=diversity)
return generate
def predict_random(self, diversity=1.0):
'''随机生成，此处随机取第一句'''
index = random.randint(0, self.poem_num)
sentence = self.poem[index][:self.config.max_len]
generate = self.predict_sen(sentence, diversity=diversity)
return generate
def generate_sample(self, epoch, logs):
if epoch % 10 != 0:
return
with open(self.config.output_path, 'a', encoding='utf-8') as file:
file.write('=============Epoch {}============='.format(epoch))
print('\n=============Epoch {}============='.format(epoch) + '\n')
for diversity in [0.5, 1.0, 1.5]:
print('-------------Diversity {}-------------'.format(diversity))
generate = self.predict_random(diversity=diversity)
print(generate)
with open(self.config.output_path, 'a', encoding='utf-8') as file:
file.write(generate + '\n')
def data_generator(self):
i = 0
while 1:
x = self.poems[i:i + self.config.max_len]
y = self.poems[i + self.config.max_len]
if ']' in x or ']' in y:
i += 1
continue
x_vec = np.zeros(shape=(1, self.config.max_len), dtype=np.int32)
for t, char in enumerate(x):
x_vec[0, t] = self.word2numF(char)
y_vec = np.zeros(shape=(1, len(self.words)), dtype=np.bool)
y_vec[0, self.word2numF(y)] = 1
yield x_vec, y_vec
i += 1
def train(self):
epoch_num = len(self.poems) // self.config.batch_size
if not self.model:
print('building model...')
self.model = Sequential()
self.model.add(
Embedding(len(self.words) + 2,
300,
input_length=self.config.max_len))
self.model.add(LSTM(512, return_sequences=True))
self.model.add(Dropout(0.6))
self.model.add(LSTM(256))
self.model.add(Dropout(0.6))
self.model.add(Dense(len(self.words), activation='softmax'))
optimizer = Adam(lr=self.config.learning_rate)
self.model.compile(optimizer=optimizer,
loss='categorical_crossentropy')
self.model.summary()
print('training model...')
self.model.fit_generator(
generator=self.data_generator(),
verbose=True,
steps_per_epoch=self.config.batch_size,
epochs=self.config.epoch_num,
callbacks=[
ModelCheckpoint(self.config.model_path,
save_weights_only=False),
LambdaCallback(on_epoch_end=self.generate_sample)
])
class myModel(object):
def __init__(self):
self.model = Sequential()
self.model.add(Conv2D(32, (3, 3), input_shape=(100, 100, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(32, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(64, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Conv2D(64, (3, 3)))
self.model.add(Activation('relu'))
self.model.add(MaxPooling2D(pool_size=(2, 2)))
self.model.add(Flatten())
self.model.add(Dense(64))
self.model.add(Activation('relu'))
self.model.add(Dropout(0.85))
self.model.add(Dense(2))
self.model.add(Activation('sigmoid'))
def train(self, dataset):
batch_size = dataset.batch_size
nb_epoch = dataset.nb_epoch
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
self.model.fit_generator(
dataset.train_data_generate(),
steps_per_epoch=dataset.total_train // batch_size,
epochs=nb_epoch,
validation_data=dataset.val_data_generate(),
validation_steps=dataset.total_val // batch_size)
def save(self, file_path="model.h5"):
print('Model Saved.')
self.model.save_weights(file_path)
def load(self, file_path="model.h5"):
print('Model Loaded.')
self.model.load_weights(file_path)
def predict(self, image):
# 预测样本分类
img = image.resize((1, IMAGE_SIZE, IMAGE_SIZE, 3))
img = image.astype('float32')
img /= 255
#归一化
result = self.model.predict(img)
print(result)
# 概率
result = self.model.predict_classes(img)
print(result)
# 0/1
return result[0]
def evaluate(self, dataset):
# 测试样本准确率
score = self.model.evaluate_generator(dataset.valid, steps=2)
print("样本准确率%s: %.2f%%" %
(self.model.metrics_names[1], score[1] * 100))
zoom_range=0.2)
train_image_data_flow = train_image_data_generator.flow_from_directory(
"./Images/Training",
target_size=(dimensions[0], dimensions[1]),
batch_size=batch_size,
class_mode="categorical")
validation_image_data_generator = ImageDataGenerator(rescale=1. / 255)
validation_image_data_flow = validation_image_data_generator.flow_from_directory(
"./Images/Validation",
target_size=(dimensions[0], dimensions[1]),
batch_size=batch_size,
class_mode="categorical")
sample_amount = 3399
validation_sample_amount = 1021
epochs = 50
epoch_steps = sample_amount // batch_size
validation_steps = validation_sample_amount // batch_size
history = model.fit_generator(train_image_data_flow,
steps_per_epoch=epoch_steps,
epochs=epochs,
validation_data=validation_image_data_flow,
validation_steps=validation_steps)
print(history.history)
model.save("cnn_model_v10_50epoch.h5")
print('TESTING DATASET IS PREPARED')
tb_callback = TensorBoard(log_dir=TF_LOG_PATH,
histogram_freq=0,
write_graph=True,
write_images=True)
cp_callback = ModelCheckpoint(monitor='val_accuracy',
save_best_only=True,
filepath=os.path.join(
CHECK_DIR,
'model_{epoch:02d}_{val_accuracy:.3f}.h5'))
model.fit_generator(train_generator,
epochs=12,
steps_per_epoch=1024,
validation_data=test_generator,
validation_steps=64,
callbacks=[tb_callback, cp_callback])
print('TRAINING COMPLETE')
model.save(MODEL_STRUCT_PATH)
for dp in glob(os.path.join(TEST_DATA_PATH, '*')):
for fp in glob(os.path.join(TEST_DATA_PATH, dp, '*')):
(fn, _) = os.path.splitext(fp)
arr = numpy.array(
load_img(fp,
target_size=(SIGN_IMG_HEIGHT, SIGN_IMG_WIDTH),
grayscale=False,
color_mode='rgb',
interpolation='nearest'))
# -eg. flip horizontally/vertically, rotate, zoom in/out, vary color, crop
# may reduce overfitting
# insert code-block
"""---------------------------------------------------------------------------------------------------------------------------------------------
# Train the new vgg16 model
"""
# compile the new model using Adam optimization function with learning rate 0.0001 and provided functions and metrics
model.compile(Adam(lr=.0001), loss='categorical_crossentropy', metrics=['accuracy'])
# passing in images from image data generator(code block missing) in training set, steps_per_epoch= (images in dataset)/(batch size), valid set generated from image generator(missing code block),
# ..., verbose set to level 2
model.fit_generator(train_batches, steps_per_epoch=7,
validation_data=valid_batches, validation_steps=4, epochs=9, verbose =2)
# observe metrics from training- compare with 3X64 node CNN created previously- use the better one
# also check for overfitting
"""# Predictions"""
#
test_imgs, test_labels = next(test_batches)
plots(test_imgs, titles=test_labels)
# 0th index so that empty/occupied gets values 0/1 or vice versa
test_labels = test_labels[:,0]
# set steps according to : test set image count (eg. 10) and batch size: (eg. 10), so it takes 1 step to run through the batch of imgs
predictions = model.predict_generator(test_batches, steps=1, verbose=0)
model.add(Dense(units=500, \
kernel_regularizer=regularizers.l2(1e-4)))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(Dropout(0.5))
model.add(Dense(units=len(TrainLabl[0])))
model.add(Activation('softmax'))
ADAM = optimizers.adam(lr=0.001)
model.compile(loss='categorical_crossentropy', \
optimizer=ADAM, metrics=['accuracy'])
history = model.fit_generator(
datagen.flow(TrainFeat, TrainLabl, batch_size=128), \
validation_data=(ValiFeat, ValiLabl), \
steps_per_epoch=(len(TrainFeat) * 10 / 128), \
epochs=40, verbose=1)
print('End of fitting!!')
score = model.evaluate(ValiFeat, ValiLabl)
print('Total loss on Testing Set: ', score[0])
print('Accuracy of Testing Set: ', score[1])
model.summary()
model.save('CNN.h5')
def ResNet_fineturning(aug, trainX, trainY, testX, testY):
from keras.applications.resnet50 import ResNet50
from keras.preprocessing import image
from keras.models import Model
from keras import Sequential
from keras.layers import Dense, GlobalAveragePooling2D, Softmax, Dropout
from keras import backend as K
# 构建不带分类器的预训练模型
base_model = ResNet50(weights='imagenet', include_top=False)
model = Sequential([
base_model,
GlobalAveragePooling2D(),
Dropout(rate=0.5),
Dense(1024, activation="relu"),
Dropout(rate=0.5),
Dense(5),
Softmax()
])
# 我们只训练顶部的几层（随机初始化的层）
# 锁住所有卷积层
for layer in base_model.layers:
layer.trainable = False
# 编译模型（一定要在锁层以后操作）
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=["accuracy"])
# 加载之前训练的权重
checkpoint_path = './save_weights/ResNet.ckpt'
# model.load_weights(checkpoint_path)
checkpoint = ModelCheckpoint(checkpoint_path,
monitor='acc',
save_weights_only=True,
verbose=1,
save_best_only=True,
period=1)
# 在新的数据集上训练几代
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
validation_data=(testX, testY),
steps_per_epoch=len(trainX) // BS,
epochs=EPOCHS,
verbose=1,
callbacks=[checkpoint])
# save the model to disk
print("[INFO] serializing network...")
model.save_weights("./save_weights/ResNet.ckpt")
# plot the training loss and accuracy
plt.style.use("ggplot")
plt.figure()
N = EPOCHS
plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, N), H.history["acc"], label="train_acc")
plt.plot(np.arange(0, N), H.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy on traffic-sign classifier")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend(loc="lower left")
plt.savefig("plot.png")
model.add(Dense(128, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.3))
model.add(Dense(64, activation='relu'))
model.add(BatchNormalization())
model.add(Dropout(0.3))
model.add(Dense(10, activation='softmax'))
#3. Compile, Train
model.compile(loss='sparse_categorical_crossentropy',
optimizer=Adam(lr=0.002, epsilon=None),
metrics=['acc'])
# epsilon : 0으로 나눠지는 것을 피하기 위함
learning_hist = model.fit_generator(train_generator,
epochs=1000,
validation_data=valid_generator,
callbacks=[es, mc, reLR])
# model.load_weights('../data/DACON_vision1/cp/0203_4_cp.hdf5')
#4. Evaluate, Predict
loss, acc = model.evaluate(test_generator)
print("loss : ", loss)
print("acc : ", acc)
result += model.predict_generator(pred_generator, verbose=True) / 40
# save val_loss
hist = pd.DataFrame(learning_hist.history)
val_loss_min.append(hist['val_loss'].min())
val_acc_max.append(hist['val_acc'].max())
class CNNmodel7:
def __init__(self, img_size=(256, 256), dump_path='dump/'):
# Random parameters
conv1_filters = np.random.randint(1, 65)
conv2_filters = np.random.randint(1, 65)
conv3_filters = np.random.randint(1, 65)
conv1_kernel = np.random.randint(2, 10)
conv2_kernel = np.random.randint(2, 10)
conv3_kernel = np.random.randint(2, 10)
conv1_strides = np.random.randint(1, conv1_kernel / 2 + 1)
conv2_strides = np.random.randint(1, conv2_kernel / 2 + 1)
conv3_strides = np.random.randint(1, conv3_kernel / 2 + 1)
maxpool1_size = np.random.randint(2, 8)
maxpool2_size = np.random.randint(2, 8)
maxpool3_size = np.random.randint(2, 8)
fc1_units = 2**np.random.randint(6, 11)
fc2_units = 2**np.random.randint(6, 11)
# Model architecture
self.model = Sequential()
self.model.add(
Conv2D(filters=conv1_filters,
kernel_size=(conv1_kernel, conv1_kernel),
strides=(conv1_strides, conv1_strides),
activation='relu',
input_shape=(img_size[0], img_size[1], 3),
name='conv1'))
self.model.add(
MaxPooling2D(pool_size=(maxpool1_size, maxpool1_size),
strides=None,
name='maxpool1'))
self.model.add(
Conv2D(filters=conv2_filters,
kernel_size=(conv2_kernel, conv2_kernel),
strides=(conv2_strides, conv2_strides),
activation='relu',
name='conv2'))
self.model.add(
MaxPooling2D(pool_size=(maxpool2_size, maxpool2_size),
strides=None,
name='maxpool2'))
self.model.add(
Conv2D(filters=conv3_filters,
kernel_size=(conv3_kernel, conv3_kernel),
strides=(conv3_strides, conv3_strides),
activation='relu',
name='conv3'))
self.model.add(
MaxPooling2D(pool_size=(maxpool3_size, maxpool3_size),
strides=None,
name='maxpool3'))
self.model.add(Flatten())
self.model.add(Dense(units=fc1_units, activation='relu', name='fc1'))
self.model.add(Dense(units=fc2_units, activation='relu', name='fc2'))
self.model.add(Dense(units=8, activation='softmax', name='classif'))
# Optimizer
optimizer = Adam()
# Compile
self.model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
# Parameters
self.born_time = time.strftime('%Y%m%d%H%M%S', time.gmtime())
self.identifier = str(hash(str(self.model.get_config())))
self.dump_path = os.path.join(
dump_path,
str(self.born_time) + '_' + self.identifier)
self.input_img_size = img_size
# Print
if not os.path.exists(self.dump_path):
os.makedirs(self.dump_path)
self.model.summary()
print('Current model: ' + self.identifier)
plot_model(self.model,
show_shapes=True,
show_layer_names=True,
to_file=os.path.join(self.dump_path,
self.identifier + '.png'))
def _train_generator(self, path, batch_size):
datagen = ImageDataGenerator(
preprocessing_function=self._preprocess_input,
rotation_range=0,
width_shift_range=0.,
height_shift_range=0.,
shear_range=0.,
zoom_range=0.,
channel_shift_range=0.,
fill_mode='reflect',
cval=0.,
horizontal_flip=False,
vertical_flip=False)
return datagen.flow_from_directory(path,
target_size=self.input_img_size,
batch_size=batch_size,
class_mode='categorical')
def _test_val_generator(self, path, batch_size):
datagen = ImageDataGenerator(
preprocessing_function=self._preprocess_input)
return datagen.flow_from_directory(path,
target_size=self.input_img_size,
batch_size=batch_size,
class_mode='categorical',
shuffle=False)
def fit_directory(self,
path,
batch_size,
epochs,
val_path=None,
save_weights=False):
train_generator = self._train_generator(path, batch_size)
if val_path is None:
validation_generator = None
validation_steps = None
else:
validation_generator = self._test_val_generator(
val_path, batch_size)
validation_steps = validation_generator.samples / batch_size
history = self.model.fit_generator(
train_generator,
steps_per_epoch=train_generator.samples / batch_size,
epochs=epochs,
validation_data=validation_generator,
validation_steps=validation_steps)
utils.plot_history(history,
self.dump_path,
identifier='e' + str(epochs) + '_b' +
str(batch_size))
with open(
os.path.join(
self.dump_path, 'e' + str(epochs) + '_b' +
str(batch_size) + '_history.pklz'), 'wb') as f:
cPickle.dump((history.epoch, history.history, history.params,
history.validation_data, self.model.get_config()), f,
cPickle.HIGHEST_PROTOCOL)
if save_weights:
self.model.save_weights(
os.path.join(
self.dump_path, 'e' + str(epochs) + '_b' +
str(batch_size) + '_weights.h5'))
return history
def evaluate(self, path):
test_generator = self._test_val_generator(path, batch_size=32)
return self.model.evaluate_generator(test_generator)
def _preprocess_input(self, x, dim_ordering='default'):
if dim_ordering == 'default':
dim_ordering = K.image_dim_ordering()
assert dim_ordering in {'tf', 'th'}
mean = [109.07621812, 115.45609435, 114.70990406]
std = [56.91689916, 55.4694083, 59.14847488]
if dim_ordering == 'th':
# Zero-center by mean pixel
x[0, :, :] -= mean[0]
x[1, :, :] -= mean[1]
x[2, :, :] -= mean[2]
# Normalize by std
x[0, :, :] /= std[0]
x[1, :, :] /= std[1]
x[2, :, :] /= std[2]
else:
# Zero-center by mean pixel
x[:, :, 0] -= mean[0]
x[:, :, 1] -= mean[1]
x[:, :, 2] -= mean[2]
# Normalize by std
x[:, :, 0] /= std[0]
x[:, :, 1] /= std[1]
x[:, :, 2] /= std[2]
return x
