def critic_optimizer(self):
discounted_reward = K.placeholder(shape=(None, ))
value = self.critic.output
loss = K.mean(K.square(discounted_reward - value))
optimizer = RMSprop(lr=self.critic_lr, rho=0.99, epsilon=0.01)
updates = optimizer.get_updates(self.critic.trainable_weights, [], loss)
train = K.function([self.critic.input, discounted_reward], [loss], updates=updates)
return train
def optimizer(self):
a = K.placeholder(shape=(None, ), dtype='int32')
y = K.placeholder(shape=(None, ), dtype='float32')
py_x = self.model.output
a_one_hot = K.one_hot(a, self.action_size)
q_value = K.sum(py_x * a_one_hot, axis=1)
error = K.abs(y - q_value)
quadratic_part = K.clip(error, 0.0, 1.0)
linear_part = error - quadratic_part
loss = K.mean(0.5 * K.square(quadratic_part) + linear_part)
optimizer = RMSprop(lr=0.00025, epsilon=0.01)
updates = optimizer.get_updates(self.model.trainable_weights, [], loss)
train = K.function([self.model.input, a, y], [loss], updates=updates)
return train
def build_functions(self):
S = Input(shape=self.state_size)
NS = Input(shape=self.state_size)
A = Input(shape=(1,), dtype='int32')
R = Input(shape=(1,), dtype='float32')
T = Input(shape=(1,), dtype='int32')
self.build_model()
self.value_fn = K.function([S], self.model(S))
VS = self.model(S)
VNS = disconnected_grad(self.model(NS))
future_value = (1-T) * VNS.max(axis=1, keepdims=True)
discounted_future_value = self.discount * future_value
target = R + discounted_future_value
cost = ((VS[:, A] - target)**2).mean()
opt = RMSprop(0.0001)
params = self.model.trainable_weights
updates = opt.get_updates(params, [], cost)
self.train_fn = K.function([S, NS, A, R, T], cost, updates=updates)
def actor_optimizer(self):
action = K.placeholder(shape=[None, self.action_size])
advantages = K.placeholder(shape=[None, ])
policy = self.actor.output
good_prob = K.sum(action * policy, axis=1)
eligibility = K.log(good_prob + 1e-10) * advantages
actor_loss = -K.sum(eligibility)
entropy = K.sum(policy * K.log(policy + 1e-10), axis=1)
entropy = K.sum(entropy)
loss = actor_loss + 0.01*entropy
optimizer = RMSprop(lr=self.actor_lr, rho=0.99, epsilon=0.01)
updates = optimizer.get_updates(self.actor.trainable_weights, [], loss)
train = K.function([self.actor.input, action, advantages], [loss], updates=updates)
return train
def build_functions(self):
self.build_model()
S = Input(shape=(self.state_size,))
NS = Input(shape=(self.state_size,))
A = Input(shape=(1,), dtype='int32')
R = Input(shape=(1,), dtype='float32')
T = Input(shape=(1,), dtype='int32')
self.value_fn = kb.function([S], [self.model(S)])
values = self.model(S)
next_values = self.model(NS) #disconnected_grad(self.model(NS))
future_value = kb.cast((1-T), dtype='float32') * kb.max(next_values, axis=1, keepdims=True)
discounted_future_value = self.discount * future_value
target = R + discounted_future_value
cost = kb.mean(kb.pow(values - target, 2))
opt = RMSprop(0.0001)
params = self.model.trainable_weights
updates = opt.get_updates(params, [], cost)
self.train_fn = kb.function([S, NS, A, R, T], [cost], updates=updates)
print_step('Build model...')
inp = Input(shape=(maxlen, ))
x = Embedding(max_features,
embed_size,
weights=[embedding_matrix],
trainable=False)(inp)
x = Bidirectional(CuDNNGRU(64, return_sequences=True))(x)
x = Dropout(0.3)(x)
x = Bidirectional(CuDNNGRU(64, return_sequences=False))(x)
x = Dense(32, activation='relu')(x)
outp = Dense(6, activation='sigmoid')(x)
model = Model(inputs=inp, outputs=outp)
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(clipvalue=1, clipnorm=1),
metrics=['accuracy'])
model.save_weights('cache/cudnngru-model-weights.h5')
print_step('Making KFold for CV')
kf = StratifiedKFold(n_splits=5, shuffle=True, random_state=2017)
i = 1
cv_scores = []
pred_train = np.zeros((train_df.shape[0], 6))
pred_full_test = np.zeros((test_df.shape[0], 6))
for dev_index, val_index in kf.split(x_train, y_train[:, 0]):
print_step('Started fold ' + str(i))
model.load_weights('cache/cudnngru-model-weights.h5')
dev_X, val_X = x_train[dev_index], x_train[val_index]
dev_y, val_y = y_train[dev_index, :], y_train[val_index, :]
include_top=False,
input_tensor=Input(shape=(128, 128, 3)))
print("[INFO] surgering model...")
top_model = FCHeadNet.build(base_model, 17, 256)
for layer in base_model.layers:
layer.trainable = False
model = Model(inputs=base_model.input, outputs=top_model)
print("[INFO] compiling model...")
opt_name = args['optimizer_1'].lower()
if opt_name not in opts: opt_name = opts[0]
if opt_name == 'sgd': opt = SGD(lr=args['lrt_1'])
elif opt_name == 'adam': opt = Adam(lr=args['lrt_1'])
else: opt = RMSprop(lr=args['lrt_1'])
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
print("[INFO] training top layers...")
aug = ImageDataGenerator(rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True,
fill_mode="nearest")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=64),
validation_data=(testX, testY),
epochs=args['epochs_1'],
steps_per_epoch=len(trainX) // 64,
verbose=1)
import matplotlib.pyplot as plt
import keras
from keras.applications.inception_v3 import InceptionV3, preprocess_input
from keras.models import Model
from keras.layers import Dense, GlobalAveragePooling2D
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import SGD, RMSprop, Adagrad
IM_WIDTH, IM_HEIGHT = 299, 299 #Fixed size for InceptionV3
DEFAULT_EPOCHS = 100
DEFAULT_BATCHES = 10
FC_SIZE = 1024
NB_LAYERS_TO_FREEZE = 169
sgd = SGD(lr=1e-7, decay=0.5, momentum=1, nesterov=True)
rms = RMSprop(lr=1e-7, rho=0.9, epsilon=1e-08, decay=0.0)
ada = Adagrad(lr=1e-7, epsilon=1e-08, decay=0.0)
optimizer = sgd
def generate_timestamp():
timestring = time.strftime("%Y_%m_%d-%H_%M_%S")
print("Time stamp generated: " + timestring)
return timestring
timestr = generate_timestamp()
def is_valid_file(parser, arg):
if not os.path.isfile(arg):
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784, )))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
history = ImportanceTraining(model, forward_batch_size=1024).fit(
x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
2,
2,
input_shape=(imageSize, imageSize, 3),
activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
#################### Summary of the Model ###############################
model.summary()
#################### Compiling the Model ################################
optimizer = RMSprop(lr=0.0001, rho=0.9, epsilon=1e-08, decay=0.0)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
#################### Defining the Checkpoints ###########################
l_r = ReduceLROnPlateau(monitor='val_acc',
factor=0.5,
patience=3,
verbose=1,
min_lr=0.000001)
wigth = ModelCheckpoint(weightFile, monitor='val_categorical_accuracy')
callbacks = [wigth, l_r]
datagen = ImageDataGenerator(featurewise_center=True,
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.0001),
metrics=['accuracy'])
model.load_weights("model.h5")
test_data_generator = ImageDataGenerator(rescale=1. / 255)
test_generator = test_data_generator.flow_from_directory(
"./temp-spectrograms",
target_size=(IMAGE_WIDTH, IMAGE_HEIGHT),
batch_size=1,
class_mode="binary",
shuffle=False)
filenames = test_generator.filenames
nb_samples = len(filenames)
model_out_file = 'Pretrain/%s_DMF4_%s_%d.h5' % (args.dataset, args.layers, time())
# Loading data
t1 = time()
dataset = Dataset(args.path + args.dataset)
train, testRatings, testNegatives = dataset.trainMatrix, dataset.testRatings, dataset.testNegatives
num_users, num_items = train.shape
print("Load data done [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d"
% (time() - t1, num_users, num_items, train.nnz, len(testRatings)))
# Build model
model = get_model(num_users, num_items, layers, reg_layers)
if learner.lower() == "adagrad":
model.compile(optimizer=Adagrad(lr=learning_rate), loss='binary_crossentropy')
elif learner.lower() == "rmsprop":
model.compile(optimizer=RMSprop(lr=learning_rate), loss='binary_crossentropy')
elif learner.lower() == "adam":
model.compile(optimizer=Adam(lr=learning_rate), loss='binary_crossentropy')
else:
model.compile(optimizer=SGD(lr=learning_rate), loss='binary_crossentropy')
# Check Init performance
t1 = time()
(hits, ndcgs) = evaluate_model(model, testRatings, testNegatives, topK, evaluation_threads)
hr, ndcg = np.array(hits).mean(), np.array(ndcgs).mean()
print('Init: HR = %.4f, NDCG = %.4f [%.1f]' % (hr, ndcg, time() - t1))
# Train model
best_hr, best_ndcg, best_iter = hr, ndcg, -1
for epoch in range(epochs):
t1 = time()
def train_on_subjset(all_subjects, model_file_name):
print "start ----------{}-------".format(model_file_name)
parser = argparse.ArgumentParser()
parser.add_argument("-start_sub_idx",
help="first sub",
type=int,
default=0)
parser.add_argument("-end_sub_idx",
help="first sub",
type=int,
default=len(all_subjects))
# parser.add_argument("start_sub_idx", help="first sub",
# type=int, default=len(all_subjects))
# parser.add_argument("last_sub_idx", help="last sub",
# type=int, default=len(all_subjects))
args = parser.parse_args()
start_idx = args.start_sub_idx
end_idx = args.end_sub_idx
import h5py
f = h5py.File(model_file_name, 'r+')
if 'optimizer_weights' in f:
del f['optimizer_weights']
f.close()
only_p300_model_1 = keras.models.load_model(model_file_name)
original_wights = only_p300_model_1.get_weights()
for experiment_counter, subject in enumerate(
all_subjects[start_idx:end_idx]):
print "start subject:{}".format(subject)
file_name = os.path.join(data_base_dir, subject)
all_data_per_char, target_per_char, train_mode_per_block, all_data_per_char_as_matrix, target_per_char_as_matrix = create_data_rep_training(
file_name, -240, 760, downsampe_params=8)
for rep_per_sub, cross_validation_indexes in enumerate(
list(
cross_validation.KFold(len(train_mode_per_block) / 10,
n_folds=4,
random_state=42,
shuffle=True))):
train_data_all_subject = []
test_data_all_subject = []
train_tags_all_subject = []
test_tags_all_subject = []
batch_size = 20
select = 1
train_as_p300 = False
train_indexes = train_mode_per_block == 1
validation_indexes = train_mode_per_block == 2
test_indexes = train_mode_per_block != 1
if train_as_p300:
data_generator_batch = triplet_data_generator_no_dict(
all_data_per_char_as_matrix[train_indexes],
target_per_char_as_matrix[train_indexes],
batch_size=batch_size,
select=select,
debug_mode=False)
else:
# cross_validation_indexes = list(cross_validation.KFold(len(train_mode_per_block)/10, n_folds=4,
# random_state=42, shuffle=True))
def flatten_repetitions(data_to_flatten):
return np.reshape(
np.reshape(data_to_flatten.T * 10,
(-1, 1)) + np.arange(10), (-1))
train_indexes = flatten_repetitions(
cross_validation_indexes[0])
test_indexes = flatten_repetitions(cross_validation_indexes[1])
# data_generator_batch = simple_data_generator_no_dict(all_data_per_char_as_matrix[train_indexes],
# target_per_char_as_matrix[train_indexes], shuffle_data=False)
#
# test_data_generator_batch = simple_data_generator_no_dict(all_data_per_char_as_matrix[train_indexes],
# target_per_char_as_matrix[train_indexes],
# shuffle_data=False)
train_data_all_subject.append(
np.asarray(
all_data_per_char_as_matrix[train_indexes]).astype(
np.float32))
test_data_all_subject.append(
np.asarray(
all_data_per_char_as_matrix[test_indexes]).astype(
np.float32))
train_tags_all_subject.append(
target_per_char_as_matrix[train_indexes])
test_tags_all_subject.append(
target_per_char_as_matrix[test_indexes])
eeg_sample_shape = (25, 55)
# keras.models.load_model(model_file_name) #
#
only_p300_model_1.set_weights(
original_wights
) #= get_only_P300_model_LSTM_CNN(eeg_sample_shape)
only_p300_model_1.summary()
from keras.optimizers import RMSprop
only_p300_model_1.compile(
optimizer=RMSprop(),
loss='binary_crossentropy',
metrics=['accuracy'],
)
model = only_p300_model_1
print "after compile"
# model = LDA()
train_data = stats.zscore(np.vstack(train_data_all_subject),
axis=1)
train_tags = np.vstack(train_tags_all_subject).flatten()
test_data = stats.zscore(np.vstack(test_data_all_subject), axis=1)
test_tags = np.vstack(test_tags_all_subject).flatten()
accuracy_train, auc_score_train = predict_using_model(
model,
test_data.reshape(test_data.shape[0] * test_data.shape[1],
test_data.shape[2], test_data.shape[3]),
test_tags)
#
print "{} before train accuracy_test {}:{}, auc_score_test:{} ".format(
subject, rep_per_sub, accuracy_train, auc_score_train)
accuracy_train, auc_score_train = predict_using_model(
model,
train_data.reshape(train_data.shape[0] * train_data.shape[1],
train_data.shape[2], train_data.shape[3]),
train_tags)
print "{} before train accuracy_train {}:{}, auc_score_train:{} ".format(
subject, rep_per_sub, accuracy_train, auc_score_train)
# model.optimizer.lr.set_value(0.0001)
# for i in range(1):
# model.fit(train_data.reshape(train_data.shape[0] * train_data.shape[1],
# train_data.shape[2], train_data.shape[3]), train_tags,
# verbose=1, nb_epoch=2, batch_size=600, shuffle=True)
#
# accuracy_train, auc_score_train = predict_using_model(model,
# test_data.reshape(test_data.shape[0] * test_data.shape[1],
# test_data.shape[2], test_data.shape[3]),
# test_tags)
#
# print "{} after train accuracy_test {}:{}, auc_score_test:{} ".format(subject, rep_per_sub, accuracy_train, auc_score_train)
#
# accuracy_train, auc_score_train = predict_using_model(model,
# train_data.reshape(
# train_data.shape[0] * train_data.shape[1],
# train_data.shape[2], train_data.shape[3]), train_tags)
#
# print "{} after train accuracy_train {}:{}, auc_score_train:{} ".format(subject, rep_per_sub, accuracy_train, auc_score_train)
#
# # model.save(r"c:\temp\{}.h5".format(model_file_name,overwrite=True))
print "end ----------{}-------".format(file_name)
pass
def eigen_reg(weight_matrix):
eigenvalue, _ = K.tf.linalg.eigh(weight_matrix)
eigenvalue = K.variable(eigenvalue)
return K.sum(
K.cast_to_floatx(l1_lambda) *
K.abs(K.ones_like(eigenvalue) - eigenvalue))
print('Evaluate Model {}...'.format(model_name))
model = Sequential()
model.add(SimpleRNN(hidden_units, input_shape=x_train.shape[1:]))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
rmsprop = RMSprop(lr=learning_rate)
model.compile(loss='categorical_crossentropy',
optimizer=rmsprop,
metrics=['accuracy'])
train_log = keras.callbacks.CSVLogger(
os.path.join('expr', model_name, 'training.log'))
class ParamLogger(keras.callbacks.Callback):
def on_train_begin(self, logs={}):
logging.basicConfig(filename=os.path.join('expr', model_name,
'params_recorder.log'),
level=logging.INFO)
def on_batch_end(self, batch, logs={}):
train_features, train_labels = extract_features(train_dir, 2000)
validation_features, validation_labels = extract_features(validation_dir, 1000)
test_features, test_labels = extract_features(test_dir, 1000)
train_features = np.reshape(train_features, (2000, 4 * 4 * 215))
validation_features = np.reshape(validation_features, (1000, 4 * 4 * 215))
test_features = np.reshape(test_features, (1000, 4 * 4 * 215))
model = Sequential()
model.add(Dense(156, activation='relu', input_dim=4 * 4 * 512))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer=RMSprop(lr=2e-5),
loss='binary_crossentropy',
metrics=['acc'])
history = model.fit(train_features,
train_labels,
epochs=10,
batch_size=20,
validation_data=(validation_features, validation_labels))
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(1, len(acc) + 1)
# Setup environment
env = environment.env
img_rows, img_cols = 64, 64
img_channels = 4 # We stack 4 frames
state_size = (img_rows, img_cols, img_channels)
action_size = environment.action_size
value_size = 1
STEPS = 200
batch_size = 1 * STEPS
lr = 7e-4 # (7 * 10^-4) = 0.0007
optimizer = RMSprop(lr=lr, epsilon=1e-5, decay=0.99, clipvalue=0.5)
actor_model = Network.actor_network(state_size, action_size, optimizer)
critic_model = Network.critic_network(state_size, value_size, optimizer)
agent = A2CAgent(actor_model,
critic_model,
state_size,
action_size,
value_size,
observe=0,
batch_size=batch_size,
gamma=.99)
try:
agent.load_weights("savepoint/CarRacing-v0-220episode")
except Exception as error:
print(error.strerror)
def get_unet_1024(input_shape=(1024, 1024, 3), num_classes=1):
inputs = Input(shape=input_shape)
# 1024
down0b = Conv2D(8, (3, 3), padding='same')(inputs)
down0b = BatchNormalization()(down0b)
down0b = Activation('relu')(down0b)
down0b = Conv2D(8, (3, 3), padding='same')(down0b)
down0b = BatchNormalization()(down0b)
down0b = Activation('relu')(down0b)
down0b_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0b)
# 512
down0a = Conv2D(16, (3, 3), padding='same')(down0b_pool)
down0a = BatchNormalization()(down0a)
down0a = Activation('relu')(down0a)
down0a = Conv2D(16, (3, 3), padding='same')(down0a)
down0a = BatchNormalization()(down0a)
down0a = Activation('relu')(down0a)
down0a_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0a)
# 256
down0 = Conv2D(32, (3, 3), padding='same')(down0a_pool)
down0 = BatchNormalization()(down0)
down0 = Activation('relu')(down0)
down0 = Conv2D(32, (3, 3), padding='same')(down0)
down0 = BatchNormalization()(down0)
down0 = Activation('relu')(down0)
down0_pool = MaxPooling2D((2, 2), strides=(2, 2))(down0)
# 128
down1 = Conv2D(64, (3, 3), padding='same')(down0_pool)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1 = Conv2D(64, (3, 3), padding='same')(down1)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
# 64
down2 = Conv2D(128, (3, 3), padding='same')(down1_pool)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2 = Conv2D(128, (3, 3), padding='same')(down2)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2)
# 32
down3 = Conv2D(256, (3, 3), padding='same')(down2_pool)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3 = Conv2D(256, (3, 3), padding='same')(down3)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3)
# 16
down4 = Conv2D(512, (3, 3), padding='same')(down3_pool)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4 = Conv2D(512, (3, 3), padding='same')(down4)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
# 8
center = Conv2D(1024, (3, 3), padding='same')(down4_pool)
center = BatchNormalization()(center)
center = Activation('relu')(center)
center = Conv2D(1024, (3, 3), padding='same')(center)
center = BatchNormalization()(center)
center = Activation('relu')(center)
# center
up4 = UpSampling2D((2, 2))(center)
up4 = concatenate([down4, up4], axis=3)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
# 16
up3 = UpSampling2D((2, 2))(up4)
up3 = concatenate([down3, up3], axis=3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
# 32
up2 = UpSampling2D((2, 2))(up3)
up2 = concatenate([down2, up2], axis=3)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
# 64
up1 = UpSampling2D((2, 2))(up2)
up1 = concatenate([down1, up1], axis=3)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
# 128
up0 = UpSampling2D((2, 2))(up1)
up0 = concatenate([down0, up0], axis=3)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0)
up0 = Activation('relu')(up0)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0)
up0 = Activation('relu')(up0)
up0 = Conv2D(32, (3, 3), padding='same')(up0)
up0 = BatchNormalization()(up0)
up0 = Activation('relu')(up0)
# 256
up0a = UpSampling2D((2, 2))(up0)
up0a = concatenate([down0a, up0a], axis=3)
up0a = Conv2D(16, (3, 3), padding='same')(up0a)
up0a = BatchNormalization()(up0a)
up0a = Activation('relu')(up0a)
up0a = Conv2D(16, (3, 3), padding='same')(up0a)
up0a = BatchNormalization()(up0a)
up0a = Activation('relu')(up0a)
up0a = Conv2D(16, (3, 3), padding='same')(up0a)
up0a = BatchNormalization()(up0a)
up0a = Activation('relu')(up0a)
# 512
up0b = UpSampling2D((2, 2))(up0a)
up0b = concatenate([down0b, up0b], axis=3)
up0b = Conv2D(8, (3, 3), padding='same')(up0b)
up0b = BatchNormalization()(up0b)
up0b = Activation('relu')(up0b)
up0b = Conv2D(8, (3, 3), padding='same')(up0b)
up0b = BatchNormalization()(up0b)
up0b = Activation('relu')(up0b)
up0b = Conv2D(8, (3, 3), padding='same')(up0b)
up0b = BatchNormalization()(up0b)
up0b = Activation('relu')(up0b)
# 1024
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up0b)
model = Model(inputs=inputs, outputs=classify)
model.compile(optimizer=RMSprop(lr=0.0001),
loss=bce_dice_loss,
metrics=[dice_coeff])
return model
def get_unet_128(input_shape=(128, 128, 3), num_classes=1):
inputs = Input(shape=input_shape)
# 128
down1 = Conv2D(64, (3, 3), padding='same',
kernel_initializer='he_normal')(inputs)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1 = Conv2D(64, (3, 3), padding='same',
kernel_initializer='he_normal')(down1)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
# 64
down2 = Conv2D(128, (3, 3), padding='same',
kernel_initializer='he_normal')(down1_pool)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2 = Conv2D(128, (3, 3), padding='same',
kernel_initializer='he_normal')(down2)
down2 = BatchNormalization()(down2)
down2 = Activation('relu')(down2)
down2_pool = MaxPooling2D((2, 2), strides=(2, 2))(down2)
# 32
down3 = Conv2D(256, (3, 3), padding='same',
kernel_initializer='he_normal')(down2_pool)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3 = Conv2D(256, (3, 3), padding='same',
kernel_initializer='he_normal')(down3)
down3 = BatchNormalization()(down3)
down3 = Activation('relu')(down3)
down3_pool = MaxPooling2D((2, 2), strides=(2, 2))(down3)
# 16
down4 = Conv2D(512, (3, 3), padding='same',
kernel_initializer='he_normal')(down3_pool)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4 = Conv2D(512, (3, 3), padding='same',
kernel_initializer='he_normal')(down4)
down4 = BatchNormalization()(down4)
down4 = Activation('relu')(down4)
down4_pool = MaxPooling2D((2, 2), strides=(2, 2))(down4)
# 8
center = Conv2D(1024, (3, 3),
padding='same',
kernel_initializer='he_normal')(down4_pool)
center = BatchNormalization()(center)
center = Activation('relu')(center)
center = Conv2D(1024, (3, 3),
padding='same',
kernel_initializer='he_normal')(center)
center = BatchNormalization()(center)
center = Activation('relu')(center)
# center
up4 = UpSampling2D((2, 2))(center)
up4 = concatenate([down4, up4], axis=3)
up4 = Conv2D(512, (3, 3), padding='same',
kernel_initializer='he_normal')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same',
kernel_initializer='he_normal')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
up4 = Conv2D(512, (3, 3), padding='same',
kernel_initializer='he_normal')(up4)
up4 = BatchNormalization()(up4)
up4 = Activation('relu')(up4)
# 16
up3 = UpSampling2D((2, 2))(up4)
up3 = concatenate([down3, up3], axis=3)
up3 = Conv2D(256, (3, 3), padding='same',
kernel_initializer='he_normal')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same',
kernel_initializer='he_normal')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
up3 = Conv2D(256, (3, 3), padding='same',
kernel_initializer='he_normal')(up3)
up3 = BatchNormalization()(up3)
up3 = Activation('relu')(up3)
# 32
up2 = UpSampling2D((2, 2))(up3)
up2 = concatenate([down2, up2], axis=3)
up2 = Conv2D(128, (3, 3), padding='same',
kernel_initializer='he_normal')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same',
kernel_initializer='he_normal')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
up2 = Conv2D(128, (3, 3), padding='same',
kernel_initializer='he_normal')(up2)
up2 = BatchNormalization()(up2)
up2 = Activation('relu')(up2)
# 64
up1 = UpSampling2D((2, 2))(up2)
up1 = concatenate([down1, up1], axis=3)
up1 = Conv2D(64, (3, 3), padding='same',
kernel_initializer='he_normal')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(64, (3, 3), padding='same',
kernel_initializer='he_normal')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
# 128
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up1)
model = Model(inputs=inputs, outputs=classify)
model.compile(optimizer=RMSprop(lr=0.0001),
loss=bce_dice_loss,
metrics=[dice_coeff])
return model
import matplotlib.pyplot as plt
from keras.preprocessing.image import ImageDataGenerator
import numpy as np
# набор CIFAR_10 содержит 60K изображений 32x32 с 3 каналами
IMG_CHANNELS = 3
IMG_ROWS = 32
IMG_COLS = 32
# константы
BATCH_SIZE = 128
NB_EPOCH = 50
NB_CLASSES = 10
VERBOSE = 1
VALIDATION_SPLIT = 0.2
OPTIM = RMSprop()
# загрузить набор данных
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
NUM_TO_AUGMENT = 5
print('X_train shape:', X_train.shape)
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
# Теперь применим унитарное кодирование и нормируем изобра- жения:
# преобразовать к категориальному виду
Y_train = np_utils.to_categorical(y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(y_test, NB_CLASSES)
def main(argv=None):
'''
'''
main.__doc__ = __doc__
argv = sys.argv if argv is None else sys.argv.extend(argv)
desc = main.__doc__ # .format(os.path.basename(__file__))
# CLI parser
args = parser_(desc)
mgpu = 0 if getattr(args, 'mgpu', None) is None else args.mgpu
checkpt = getattr(args, 'checkpt', None)
checkpt_flag = False if checkpt is None else True
filepath = checkpt
# print('CHECKPT:', checkpt)
gdev_list = get_available_gpus(mgpu or 1)
ngpus = len(gdev_list)
batch_size_1gpu = 32
batch_size = batch_size_1gpu * ngpus
num_classes = 1000
epochs = args.epochs
data_augmentation = args.aug
logdevp = args.logdevp
datadir = getattr(args, 'datadir', None)
# The data, shuffled and split between train and test sets:
(x_train, y_train), (x_test,
y_test) = synthesize_imagenet_dataset(num_classes)
train_samples = x_train.shape[0]
test_samples = y_test.shape[0]
steps_per_epoch = train_samples // batch_size
print('train_samples:', train_samples)
print('batch_size:', batch_size)
print('steps_per_epoch:', steps_per_epoch)
# validations_steps = test_samples // batch_size
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# The capacity variable controls the maximum queue size
# allowed when prefetching data for training.
capacity = 10000
# min_after_dequeue is the minimum number elements in the queue
# after a dequeue, which ensures sufficient mixing of elements.
# min_after_dequeue = 3000
# If `enqueue_many` is `False`, `tensors` is assumed to represent a
# single example. An input tensor with shape `[x, y, z]` will be output
# as a tensor with shape `[batch_size, x, y, z]`.
#
# If `enqueue_many` is `True`, `tensors` is assumed to represent a
# batch of examples, where the first dimension is indexed by example,
# and all members of `tensors` should have the same size in the
# first dimension. If an input tensor has shape `[*, x, y, z]`, the
# output will have shape `[batch_size, x, y, z]`.
# enqueue_many = True
# Force input pipeline to CPU:0 to avoid data operations ending up on GPU
# and resulting in a slow down for multigpu case due to comm overhead.
with tf.device('/cpu:0'):
# if no augmentation can go directly from numpy arrays
# x_train_batch, y_train_batch = tf.train.shuffle_batch(
# tensors=[x_train, y_train],
# # tensors=[x_train, y_train.astype(np.int32)],
# batch_size=batch_size,
# capacity=capacity,
# min_after_dequeue=min_after_dequeue,
# enqueue_many=enqueue_many,
# num_threads=8)
# NOTE: This bakes the whole dataset into the TF graph and for larger
# datasets it fails on "ValueError: GraphDef cannot be larger than 2GB".
# TODO: Load the a large dataset via queue from RAM/disk.
input_images = tf.constant(x_train.reshape(train_samples, -1))
print('train_samples', train_samples)
print('input_images', input_images.shape)
image, label = tf.train.slice_input_producer([input_images, y_train],
shuffle=True)
# If using num_epochs=epochs have to:
# sess.run(tf.local_variables_initializer())
# and maybe also: sess.run(tf.global_variables_initializer())
image = tf.reshape(image, x_train.shape[1:])
print('image', image.shape)
test_images = tf.constant(x_test.reshape(test_samples, -1))
test_image, test_label = tf.train.slice_input_producer(
[test_images, y_test], shuffle=False)
test_image = tf.reshape(test_image, x_train.shape[1:])
if data_augmentation:
print('Using real-time data augmentation.')
# Randomly flip the image horizontally.
distorted_image = tf.image.random_flip_left_right(image)
# Because these operations are not commutative, consider
# randomizing the order their operation.
# NOTE: since per_image_standardization zeros the mean and
# makes the stddev unit, this likely has no effect see
# tensorflow#1458.
distorted_image = tf.image.random_brightness(distorted_image,
max_delta=63)
distorted_image = tf.image.random_contrast(distorted_image,
lower=0.2,
upper=1.8)
# Subtract off the mean and divide by the variance of the
# pixels.
image = tf.image.per_image_standardization(distorted_image)
# Do this for testing as well if standardizing
test_image = tf.image.per_image_standardization(test_image)
# Use tf.train.batch if slice_input_producer shuffle=True,
# otherwise use tf.train.shuffle_batch. Not sure which way is faster.
x_train_batch, y_train_batch = tf.train.batch([image, label],
batch_size=batch_size,
capacity=capacity,
num_threads=8)
print('x_train_batch:', x_train_batch.shape)
# x_train_batch, y_train_batch = tf.train.shuffle_batch(
# tensors=[image, label],
# batch_size=batch_size,
# capacity=capacity,
# min_after_dequeue=min_after_dequeue,
# num_threads=8)
x_test_batch, y_test_batch = tf.train.batch(
[test_image, test_label],
# TODO: shouldn't it be: batch_size=batch_size???
batch_size=train_samples,
capacity=capacity,
num_threads=8,
name='test_batch',
shared_name='test_batch')
x_train_input = KL.Input(tensor=x_train_batch)
print('x_train_input', x_train_input)
gauge = SamplesPerSec(batch_size)
callbacks = [gauge]
if _DEVPROF or logdevp: # or True:
# Setup Keras session using Tensorflow
config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=True)
# config.gpu_options.allow_growth = True
tfsess = tf.Session(config=config)
KB.set_session(tfsess)
model_init = make_model(x_train_input, num_classes)
x_train_out = model_init.output
# model_init.summary()
lr = 0.0001 * ngpus
if ngpus > 1:
model = make_parallel(model_init, gdev_list)
else:
# Must re-instantiate model per API below otherwise doesn't work.
model_init = Model(inputs=[x_train_input], outputs=[x_train_out])
model = model_init
opt = RMSprop(lr=lr, decay=1e-6)
# Let's train the model using RMSprop
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'],
target_tensors=[y_train_batch])
print_mgpu_modelsummary(model) # will print non-mgpu model as well
if checkpt_flag:
checkpoint = ModelCheckpoint(filepath,
monitor='acc',
verbose=1,
save_best_only=True)
callbacks = [checkpoint]
# Start the queue runners.
sess = KB.get_session()
# sess.run([tf.local_variables_initializer(),
# tf.global_variables_initializer()])
tf.train.start_queue_runners(sess=sess)
# Fit the model using data from the TFRecord data tensors.
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess, coord)
val_in_train = False # not sure how the validation part works during fit.
start_time = time.time()
model.fit(
# validation_data=(x_test_batch, y_test_batch)
# if val_in_train else None, # validation data is not used???
# validation_steps=validations_steps if val_in_train else None,
validation_steps=val_in_train,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
callbacks=callbacks)
elapsed_time = time.time() - start_time
print('[{}] finished in {} ms'.format('TRAINING',
int(elapsed_time * 1000)))
gauge.print_results()
weights_file = checkptfile # './saved_cifar10_wt.h5'
if not checkpt_flag: # empty list
model.save_weights(checkptfile)
# Clean up the TF session.
coord.request_stop()
coord.join(threads)
KB.clear_session()
# Second Session. Demonstrate that the model works
# test_model = make_model(x_test.shape[1:], num_classes,
# weights_file=weights_file)
test_model = make_model(x_test.shape[1:], num_classes)
test_model.load_weights(weights_file)
test_model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
if data_augmentation:
x_proccessed = sess.run(x_test_batch)
y_proccessed = sess.run(y_test_batch)
loss, acc = test_model.evaluate(x_proccessed, y_proccessed)
else:
loss, acc = test_model.evaluate(x_test, y_test)
print('\nTest loss: {0}'.format(loss))
print('\nTest accuracy: {0}'.format(acc))
''' from __future__ import print_function from keras.optimizers import SGD, RMSprop from cnn_functions import rate_scheduler, train_model_sample from model_zoo import feature_net_61x61 as the_model import os import datetime import numpy as np batch_size = 256 n_classes = 3 n_epoch = 25 model = the_model(n_channels = 2, n_features = 3, reg = 1e-5, drop=0.5) dataset = "HeLa_all_61x61" direc_save = "/home/nquach/DeepCell2/trained_networks/" direc_data = "/home/nquach/DeepCell2/training_data_npz/" optimizer = RMSprop(lr = 0.001, rho = 0.95, epsilon = 1e-8) lr_sched = rate_scheduler(lr = 0.001, decay = 0.95) expt = "feature_net_61x61_dropout" iterate = 3 train_model_sample(model = model, dataset = dataset, optimizer = optimizer, expt = expt, it = iterate, batch_size = batch_size, n_epoch = n_epoch, direc_save = direc_save, direc_data = direc_data, lr_sched = lr_sched, rotate = True, flip = True, shear = 0)
X_hat_One_DUDE[k_max*0+k-1,:]=x_dude_hat
### 1-D N-DUDE ###
C,Y = N_DUDE.make_data_for_One_NN_DUDE(Z[i*n:(i+1)*n],k,L_new[i*alpha_size:(i+1)*alpha_size,],nb_classes,n)
model=Sequential()
model.add(Dense(40,input_dim=2*k*nb_classes,init='he_normal'))
model.add(Activation('relu'))
model.add(Dense(40,init='he_normal'))
model.add(Activation('relu'))
model.add(Dense(40,init='he_normal'))
model.add(Activation('relu'))
model.add(Dense(3,init='he_normal'))
model.add(Activation('softmax'))
rms=RMSprop(lr=0.001, rho=0.9, epsilon=1e-06,clipnorm=1.5)
adagrad=Adagrad(clipnorm=1.5)
adam=Adam()
adadelta=Adadelta()
sgd=SGD(lr=0.01,decay=1e-6,momentum=0.95, nesterov=True, clipnorm=1.0)
model.compile(loss='poisson', optimizer=adam)
model.fit(C,Y,nb_epoch=10,batch_size=128,show_accuracy=False, verbose=0)
pred_class=model.predict_classes(C, batch_size=128, verbose=0)
s_nn_hat=hstack((zeros(k),pred_class,zeros(k)))
x_nn_hat=N_DUDE.denoise_with_s(z[i],s_nn_hat,k)
error_nn=N_DUDE.error_rate(x,x_nn_hat)
print '1-D N-DUDE Pre-trained =', error_nn
def main(config):
use_data_augmentation = True
# This is the main configuration object
training_params = {
# Name of the split created
'split': 'name_of_split',
# Label: 'verb' or 'object'
'label': 'verb',
# Execute a quick run: 1 batch for training and 2 videos for test
'toy_execution': False,
# If the evaluation is already done and saved, whether to repeat it
'redo_evaluation': False,
# Oversample minority classes
'oversampling': False,
# Warm up: do 'warmup_epochs' epochs with learnign rate 'warmup_lr'
'use_warmup': False,
'warmup_epochs': 3,
'warmup_lr': 0.01,
# From 0 to 1, percentage of offset at the beginning and end to sample
'frame_sampling_offset': 0.,
# Number of times to run the experiment (averaged at the end)
'runs': 3,
'epochs': 100,
# Skip connection from last layer before ConvLSTM to output hidden
# states of the ConvLSTM. It requires a 1x1 conv with a number of
# channels equal to the number of hidden units of the ConvLSTM
'skip_connect': False,
# Number of timesteps
'sequence_length': 25,
'learning_rate': 0.0001,
'batch_size': 16,
# Number of layers to freeze, starting from 0
# 142 to freeze everything except for the last conv block
# 0 would set all layers as trainable
# -1 to freeze all
'last_layer_to_freeze_conv': 142,
'optimizer': 'adam',
# Maximum value to clip the gradient (to avoid large changes)
'gradient_clipvalue': 0.,
# Criterion to use for early stopping and also to choose the best model
'stop_criterion': 'val_f1_metric',
# Patience for early stopping
'patience': 10,
# Number of hidden states used in the ConvLSTM, i.e., number of
# output channels
'num_convlstms': 1,
'convlstm_hidden': 256,
'convlstm_add_initial_state': False,
'apply_conv_betweenconvlstm': False,
'apply_conv_afterconvlstm': False,
'last_layer_to_freeze': 0,
'non_uniform_sampling': False,
# Normalise input to the ConvLSTM with L2 Normalisation
'convlstm_normalise_input': False,
'dropout_rate': 0.,
'convlstm_dropout_rate': 0.,
'convlstm_recurrent_dropout_rate': 0.,
'spatial_dropout_rate': 0.,
'use_average_pool': True,
'use_data_augmentation': use_data_augmentation,
'random_horizontal_flipping': True,
'random_corner_cropping': True,
'random_lighting': False,
# Apply class weighting in the loss function using the training set
# class distribution as a prior
'apply_class_weighting': True,
# Regularisation L1/L2 in the loss. If both are used then L1_L2
# regularisation is used (keras)
'l1_reg_beta': 0.,
'l2_reg_beta': 0.,
# Add a 1x1 conv after the last conv block but before the non local
# block in order to reduce the number of channels (ch)
'add_1x1conv': True,
'add_1x1conv_ch': 256,
'min_frames': -1,
# Activates debug mode: inputs to the network are saved in the folder
# pointed out by 'debug_folder' below
'debug_mode': False,
'debug_folder': 'debug_folder',
'visualisation_mode': False
}
# Name of the experiment (e.g. split_R_verb_detector)
exp_name = 'split_{}_{}_detector'.format(
training_params['split'], training_params['label']
)
root_path = config['split_path'] + training_params['split'] + '/'
if training_params['label'] == 'verb':
training_params['num_classes'] = (
len(open(root_path + config['train_verbs_file'],
'r').readlines()))
training_params['train_classes_file'] = (
root_path + config['train_verbs_file']
)
training_params['val_classes_file'] = (
root_path + config['val_verbs_file']
)
training_params['test_classes_file'] = (
root_path + config['test_verbs_file']
)
elif training_params['label'] == 'object':
training_params['num_classes'] = (
len(open(root_path + config['train_objects_file'],
'r').readlines()))
training_params['train_classes_file'] = (
root_path + config['train_objects_file']
)
training_params['val_classes_file'] = (
root_path + config['val_objects_file']
)
training_params['test_classes_file'] = (
root_path + config['test_objects_file']
)
init_time = time.time()
# For reproducibility
tf.set_random_seed(1)
os.environ['PYTHONHASHSEED'] = '1'
seed(1)
rn.seed(1)
# Path to folders to save plots and checkpoints
checkpoints_folder = (config['project_folder'] +
config['checkpoints_folder'] +
'{}/{}/'.format(training_params['split'], exp_name)
)
plots_folder = (config['project_folder'] + config['plots_folder'] +
'{}/{}/'.format(training_params['split'], exp_name)
)
# Create any necessary folder
if not os.path.exists(plots_folder):
os.makedirs(plots_folder)
if not os.path.exists(checkpoints_folder):
os.makedirs(checkpoints_folder)
# Save training parameters
with open(plots_folder + 'training_params.json', 'w') as fp:
json.dump(training_params, fp, indent=4)
# ===============================================================
# LOAD THE DATA
# ===============================================================
# Compute number of videos from each set: train, validation and test
train_file = root_path + config['train_file']
val_file = root_path + config['val_file']
test_file = root_path + config['test_file']
nb_videos_train = num_sequences(config, training_params, 'train',
'training', train_file)
nb_videos_val = num_sequences(config, training_params, 'val',
'training', val_file)
nb_videos_test = num_sequences(config, training_params, 'test',
'training', test_file)
# Compute number of mini-batches for each set
# Add an extra mini-batch in case that the number of samples
# is not divisible by the mini-batch size
nb_batches_train = nb_videos_train // training_params['batch_size']
if nb_videos_train % training_params['batch_size'] > 0:
nb_batches_train += 1
nb_batches_val = nb_videos_val // training_params['batch_size']
if nb_videos_val % training_params['batch_size'] > 0:
nb_batches_val += 1
nb_batches_test = nb_videos_test // training_params['batch_size']
if nb_videos_test % training_params['batch_size'] > 0:
nb_batches_test += 1
# Necessary to load the model
custom_objects = {'f1_metric': f1_metric}
if training_params['use_data_augmentation']:
print('train: using data augmentation')
# Instantiate the generators of batches for training and validation
train_generator = BatchGenerator(config, 'train', train_file,
training_params, nb_batches_train)
val_generator = BatchGenerator(config, 'val', val_file,
training_params, nb_batches_val)
total_videos = float(nb_videos_train+nb_videos_val+nb_videos_test)
if training_params['apply_class_weighting']:
print('Class weighting applied')
print('Number of videos to => train: {}, val: {}, test: {}'.format(
nb_videos_train, nb_videos_val, nb_videos_test)
)
print('% of videos to => train: {}, val: {}, test: {}'.format(
nb_videos_train/total_videos*100, nb_videos_val/total_videos*100,
nb_videos_test/total_videos*100)
)
if not os.path.exists(plots_folder + 'results.json'):
all_run_results = dict()
# Vectors to accumulate the results of each run
accuracy_by_input, accuracy_by_video = dict(), dict()
f1_by_input, f1_by_video = dict(), dict()
# ===============================================================
# EXECUTE THE N RUNS OF THE EXPERIMENT
# ===============================================================
verbose = 1
if training_params['runs'] > 1:
verbose = 0
classes_val, indices_val = get_classes_ordered(
training_params['val_classes_file']
)
# Compute train labels to obtain class weights (for the loss function)
labels_by_video, _ = load_labels(
config, training_params, 'val', val_file,
training_params['val_classes_file']
)
plot_class_distribution(plots_folder, labels_by_video, classes_val, 'val')
del labels_by_video
gc.collect()
classes_test, indices_test = get_classes_ordered(
training_params['test_classes_file']
)
labels_by_video, _ = load_labels(
config, training_params, 'test', test_file,
training_params['test_classes_file']
)
plot_class_distribution(plots_folder, labels_by_video, classes_test, 'test')
del labels_by_video
gc.collect()
classes_train, indices_train = get_classes_ordered(
training_params['train_classes_file']
)
labels_by_video, indices_by_video = load_labels(
config, training_params, 'train',
train_file, training_params['train_classes_file']
)
plot_class_distribution(plots_folder, labels_by_video,
classes_train, 'train')
if training_params['apply_class_weighting']:
class_weights = compute_class_weight('balanced',
np.unique(indices_by_video),
indices_by_video)
plot_weights_distribution(plots_folder, class_weights,
classes_train, 'train')
histories = []
for run in range(training_params['runs']):
print('EXECUTING RUN {} ----------------------------------'.format(run))
run_folder = plots_folder + 'run_{}/'.format(run)
if not os.path.exists(run_folder):
os.makedirs(run_folder)
save_best_weights_file = (checkpoints_folder +
'best_weights_{}.h5'.format(run)
)
if os.path.exists(plots_folder + 'results.json'):
with open(plots_folder + 'results.json', 'r') as json_file:
all_run_results = json.load(json_file)
if not 'run_{}'.format(run) in all_run_results:
all_run_results['run_{}'.format(run)] = dict()
training_skipped = False
# If this run has already been computed, skip training
if not 'training_result' in all_run_results['run_{}'.format(run)]:
model = deploy_network(config, training_params)
if training_params['epochs'] > 0:
clipvalue = None
if training_params['gradient_clipvalue'] > 0.:
clipvalue = training_params['gradient_clipvalue']
print('Clipping gradient to {}'.format(
training_params['gradient_clipvalue']
))
if training_params['optimizer'] == 'adam':
print('Using Adam optimizer')
optimizer = Adam(lr=training_params['learning_rate'],
beta_1=0.9, beta_2=0.999, epsilon=1e-08,
clipvalue=clipvalue)
elif training_params['optimizer'] == 'sgd':
print('Using SGD optimizer')
optimizer = SGD(lr=training_params['learning_rate'],
momentum=0.9, decay=1e-6, nesterov=True,
clipvalue=clipvalue)
elif training_params['optimizer'] == 'rmsprop':
print('Using RMSprop optimizer')
optimizer = RMSprop(lr=training_params['learning_rate'])
metric_list = config['metrics'][1:] + [f1_metric]
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=metric_list)
model.summary()
print('Exp {}, run {}'.format(exp_name, run))
apply_cw = training_params['apply_class_weighting']
# Optional warmup training
if training_params['use_warmup']:
warmup_epochs = training_params['warmup_epochs']
history = model.fit_generator(generator=train_generator,
validation_data=val_generator,
epochs=warmup_epochs,
max_queue_size=10,
workers=2,
verbose=1,
class_weight=(class_weights
if apply_cw
else None),
shuffle=False,
use_multiprocessing=False)
# Type of criterion for the ModelCheckpoint and EarlyStopping
# depending on the metric used for the EarlStopping
if training_params['stop_criterion'] == 'val_loss':
mode = 'min'
else:
mode = 'max'
c = ModelCheckpoint(str(save_best_weights_file),
monitor=training_params['stop_criterion'],
save_best_only=True,
save_weights_only=False,
mode=mode,
period=1)
e = EarlyStopping(monitor=training_params['stop_criterion'],
min_delta=0,
patience=training_params['patience'],
verbose=0,
mode=mode,
baseline=None)
callbacks = [c, e]
train_time = time.time()
steps = None
if training_params['toy_execution']:
steps = 1
history = model.fit_generator(generator=train_generator,
steps_per_epoch=steps,
validation_data=val_generator,
validation_steps=steps,
epochs=training_params['epochs'],
max_queue_size=10,
workers=2,
verbose=1,
class_weight=(class_weights
if apply_cw
else None),
shuffle=False,
use_multiprocessing=False,
callbacks=callbacks)
# Save the history of training
histories.append(history.history)
print('TRAINING PHASE ENDED')
metric = training_params['stop_criterion']
# Depending on the metric to stop the training, choose whether
# the minimum or maximum value must be chosen
if metric == 'val_loss':
func = np.argmin
else:
func = np.argmax
best_epoch = func(history.history[metric])
# Save results to the dictionary
k1, k2 = 'run_{}'.format(run), 'training_result'
all_run_results[k1][k2] = dict()
all_run_results[k1][k2]['best_epoch'] = best_epoch
all_run_results[k1][k2][
'best_epoch_val_loss'] = history.history[
'val_loss'][best_epoch]
all_run_results[k1][k2][
'best_epoch_val_acc'] = history.history[
'val_acc'][best_epoch]
all_run_results[k1][k2][
'best_epoch_val_f1'] = history.history[
'val_f1_metric'][best_epoch]
# Save intermediate result
with open(plots_folder + 'results.json', 'w') as f:
json.dump(all_run_results, f, indent=4)
print('Time to train for {} epochs: {}s'.format(
training_params['epochs'], time.time()-train_time))
else:
training_skipped = True
# TEST ========================
print('='*20)
print('TEST PHASE')
print('training_skipped', training_skipped)
# If training was not skipped, save the histories (loss, accuracy and
# f1 per epoch, per run)
if not training_skipped:
save_history(run_folder, history.history)
del model
# If training was skipped, load the history of this run
else:
histories.append(load_history(run_folder, run))
# Load the best model for evaluation
model = load_model(str(save_best_weights_file),
custom_objects=custom_objects)
print('Loaded the checkpoint at {}'.format(save_best_weights_file))
class_list = classes_train
print('Exp {}, run {}'.format(exp_name, run))
res_dict = dict()
for mode in ['train', 'val', 'test']:
# If the evaluation was already saved and 'redo_evaluation' is not
# set to True
if (
('evaluation_{}'.format(mode) in
all_run_results['run_{}'.format(run)]) and
not training_params['redo_evaluation']
):
if not mode in accuracy_by_video:
accuracy_by_video[mode] = []
if not mode in f1_by_video:
f1_by_video[mode] = []
k1, k2 = 'run_{}'.format(run), 'evaluation_{}'.format(mode)
_f1_by_video = all_run_results[k1][k2]['f1']
_accuracy_by_video = all_run_results[k1][k2]['accuracy']
accuracy_by_video[mode].append(_accuracy_by_video/100.)
#f1_by_input[mode].append(_f1_by_input)
f1_by_video[mode].append(_f1_by_video/100.)
print('{}: Accuracy per video: {}, '.format(
mode, _accuracy_by_video) +
'Macro-F1 per video: {}'.format( _f1_by_video)
)
continue
if training_params['use_data_augmentation']:
print('{}: using data augmentation'.format(mode))
#if not results_loaded:
if mode == 'train':
if training_params['oversampling']:
nb_videos_train = num_sequences(config, training_params,
'train', 'evaluation',
train_file)
nb_videos = nb_videos_train
generator = load_gaze_plus_sequences(config, 'train',
train_file,
training_params)
classes_train, indices_train = get_classes_ordered(
training_params['train_classes_file']
)
elif mode == 'val':
nb_videos = nb_videos_val
generator = load_gaze_plus_sequences(config, 'val',
val_file,
training_params)
classes_train, indices_train = get_classes_ordered(
training_params['train_classes_file']
)
elif mode == 'test':
nb_videos = nb_videos_test
generator = load_gaze_plus_sequences(config, 'test',
test_file,
training_params)
classes_test, indices_test = get_classes_ordered(
training_params['train_classes_file']
)
if training_params['toy_execution']:
nb_videos = 2
predictions_by_video, ground_truth_by_video = [], []
length_of_videos = dict()
predictions_by_class = []
for _ in range(training_params['num_classes']):
predictions_by_class.append([])
info = dict()
# Process video by video
print('Processing {}, {} videos'.format(mode, nb_videos))
for i in tqdm(range(nb_videos)):
batch_x, batch_y, video_name, length = generator.next()
predictions = model.predict(batch_x)[0]
# Dictionary to save results by length of video
if not length in length_of_videos:
length_of_videos[length] = []
# Save class predicted by the model and ground truth
predicted = np.argmax(predictions,0)
predictions_by_video.append(predicted)
ground_truth_by_video.append(batch_y)
# Save prediction by class
predictions_by_class[batch_y].append(predicted)
# Save results by video
info[video_name] = dict()
info[video_name]['ground_truth_index'] = batch_y
info[video_name]['ground_truth_class'] = class_list[batch_y]
info[video_name]['prediction_index'] = predicted
info[video_name]['prediction_softmax'] = predictions[0]
info[video_name]['prediction_class'] = class_list[predicted]
info[video_name]['length'] = length
info[video_name]['classes'] = class_list
ground_truth_by_video = np.squeeze(np.stack(ground_truth_by_video))
predictions_by_video = np.squeeze(np.stack(predictions_by_video))
cm_by_video = confusion_matrix(ground_truth_by_video,
predictions_by_video,
labels=range(
training_params['num_classes']
))
_accuracy_by_video = accuracy_score(ground_truth_by_video,
predictions_by_video)
_f1_by_video = f1_score(ground_truth_by_video, predictions_by_video,
average='macro')
k1, k2 = 'run_{}'.format(run), 'evaluation_{}'.format(mode)
all_run_results[k1][k2] = dict()
all_run_results[k1][k2]['num_videos'] = nb_videos
all_run_results[k1][k2]['accuracy'] = _accuracy_by_video*100.
all_run_results[k1][k2]['f1'] = _f1_by_video*100.
print('{}: Accuracy per video: {}, Macro-F1 per video: {}'.format(
mode, _accuracy_by_video, _f1_by_video)
)
plot_confusion_matrix(
cm_by_video, class_list,
run_folder + '_normalized_by_video_{}_{}_{}.pdf'.format(
mode, exp_name, run),
normalize=True,
title='Normalized confusion matrix for {} set'.format(mode),
cmap='coolwarm'
)
plot_confusion_matrix(
cm_by_video, class_list,
run_folder + '_by_video_{}_{}_{}.pdf'.format(
mode, exp_name, run),
normalize=False,
title='Confusion matrix for {} set'.format(mode),
cmap='coolwarm'
)
# Compute and save results by class
for i in range(len(predictions_by_class)):
if len(predictions_by_class[i]) > 0:
pred = predictions_by_class[i]
acc = accuracy_score([i]*len(pred),pred)
f1 = f1_score([i]*len(pred),pred, average='macro')
predictions_by_class[i] = [acc, f1,
len(predictions_by_class[i])]
else:
predictions_by_class[i] = [0., 0.,
len(predictions_by_class[i])]
save_results(run_folder, mode, predictions_by_class,
class_list, run)
# Save general info
save_in_csv(run_folder + '{}_run{}_evaluation_info.csv'.format(
mode,run), info)
if not mode in accuracy_by_video:
accuracy_by_video[mode] = []
f1_by_video[mode] = []
accuracy_by_video[mode].append(_accuracy_by_video)
f1_by_video[mode].append(_f1_by_video)
del generator
gc.collect()
with open(plots_folder + 'results.json', 'w') as f:
json.dump(all_run_results, f, indent=4)
# END OF THE EVALUATION ===========================================
del model
gc.collect()
K.clear_session()
tf.set_random_seed(1)
# END OF ALL THE RUNS ===========================================
if not training_skipped:
del val_generator, train_generator
gc.collect()
plot_training_info(plots_folder,
exp_name,
config['metrics'] + ['f1_metric'],
True,
histories)
# ===============================================================
# SHOW THE AVERAGED RESULTS
# ===============================================================
results_dict = dict()
print('='*20)
results_file = open(plots_folder + 'results.txt', 'w')
for mode in ['train', 'val', 'test']:
res_msg = '='*20 + '\n'
res_msg += '{}: AVERAGE RESULTS OF {} RUNS\n'.format(
mode, training_params['runs'])
res_msg += '='*20 + '\n'
results_dict[mode] = dict()
results_dict[mode]['accuracy_by_video'] = accuracy_by_video[mode]
results_dict[mode]['f1_by_video'] = f1_by_video[mode]
res_msg += 'ACCURACY: {:.2f} (-+{:.2f}), MACRO F1: {:.2f} (-+{:.2f})\n'.format(
np.mean(accuracy_by_video[mode])*100, np.std(accuracy_by_video[mode])*100,
np.mean(f1_by_video[mode])*100, np.std(f1_by_video[mode])*100
)
res_msg += 'RESULTS PER RUN\n'
res_msg += '----------------\n'
res_msg += '\nAccuracy by video:\n'
res_msg += ', '.join(str(x) for x in accuracy_by_video[mode])
res_msg += '\nMacro F1 by video:\n'
res_msg += ', '.join(str(x) for x in f1_by_video[mode])
res_msg += '\n'
print(res_msg)
results_file.write(res_msg)
results_file.close()
res_msg = '\n\nTime for training and evaluation of every run: {}s'.format(time.time()-init_time)
final_results = dict()
for run in range(training_params['runs']):
k1 = 'run_{}'.format(run)
final_results[k1] = dict()
for mode in ['train', 'val', 'test']:
final_results[k1][mode] = dict()
final_results[k1][mode]['accuracies'] = [x*100 for x in accuracy_by_video[mode]]
final_results[k1][mode]['f1s'] = [x*100 for x in f1_by_video[mode]]
with open(plots_folder + 'overall_results.json', 'w') as f:
json.dump(final_results, f, indent=4)
labels = []
for i, image_file in enumerate(images):
image, label = read_image(image_file)
data[i] = image.T
labels.append(label)
return data, labels
x_train, y_train = prep_data(train_images)
x_test, y_shit = prep_data(test_images)
##############
# CNN模型构造##
##############
optimizer = RMSprop(lr=1e-4)
objective = 'binary_crossentropy'
# 建造模型
model = Sequential()
model.add(
Convolution2D(32,
3,
3,
border_mode='same',
input_shape=(3, ROWS, COLS),
activation='relu'))
model.add(Convolution2D(32, 3, 3, border_mode='same', activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
#Define the model achitecture
model = Sequential()
model.add(
Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
rms = RMSprop()
#The function to optimize is the cross entropy between the true label and the output (softmax) of the model
model.compile(loss='categorical_crossentropy',
optimizer=rms,
metrics=["accuracy"])
#Make the model learn
model.fit(X, y, epochs=nb_epoch, verbose=2, validation_data=(X_test, Y_test))
#Evaluate how the model does on the test set
score = model.evaluate(X_test, Y_test, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])
epsilon = .8
gamma = .8
# Recipe of deep reinforcement learning model
model = Sequential()
model.add(
Convolution2D(16,
nb_row=3,
nb_col=3,
input_shape=(3, 480, 640),
activation='relu'))
model.add(Convolution2D(16, nb_row=3, nb_col=3, activation='relu'))
model.add(Flatten())
model.add(Dense(100, activation='relu'))
model.add(Dense(3))
model.compile(RMSprop(), 'MSE')
model.summary()
#################
# RELOAD A MODEL
#################
# model = model_from_json(open('model.json').read())
# model.load_weights('model.h5')
exp_replay = experience_replay(batch_size)
next(exp_replay) # Start experience-replay coroutine
for i in range(nb_epochs):
ep = episode()
S, reward = next(ep) # Start coroutine of single entire episode
loss = 0.
x_train_rgb[i] = get_photo_gray(x_train[i]) # 转换成灰度
x_train_rgb = x_train_rgb.reshape(x_train_rgb.shape[0], -1) / 255.0
y_train = np_utils.to_categorical(y_train, num_classes=10)
model = Sequential()
model.add(Dense(1024, input_dim=1024)) # 全连接层
model.add(Activation('relu'))
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dense(10)) # 全连接层
model.add(Activation('softmax'))
rmsprop = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0) # RMSprop 优化
model.compile(optimizer=rmsprop, loss='categorical_crossentropy', metrics=['accuracy'])
tbCallBack = TensorBoard(log_dir='./logs', # log 目录
histogram_freq=0, # 按照何等频率（epoch）来计算直方图，0为不计算
batch_size=32, # 用多大量的数据计算直方图
write_graph=True, # 是否存储网络结构图
write_grads=True, # 是否可视化梯度直方图
write_images=True, # 是否可视化参数
embeddings_freq=0,
embeddings_layer_names=None,
embeddings_metadata=None)
model.fit(x_train_rgb, y_train, epochs=12, batch_size=128, callbacks=[tbCallBack]) # 结果acc=0.1 flat后的数据acc=0.19
X_test /= 255
y_train = keras.utils.to_categorical(y_train, 512)
y_test = keras.utils.to_categorical(y_test, 512)
i_shape = 784
filt = 512
loss_func = 'categorical_crossentropy'
batch_size = 128
epochs = 20
scores = {}
for activation in [None, 'sigmoid', 'tanh', 'relu']:
model = Sequential()
model.add(Dense(filt, activation=activation, input_shape=(i_shape, )))
model.add(Flatten())
# model.add(Dense(num_classes, activation = 'softmax'))
model.compile(loss=loss_func,
optimizer=RMSprop(lr=0.04),
metrics=['accuracy'])
history = model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_test, y_test))
score = model.evaluate(X_test, y_test, verbose=100)
scores[activation] = score[1]
plt.plot(history.history['val_accuracy'])
plt.title('model loss')
plt.ylabel('loss')
_________________________________________________________________
max_pooling1d_1 (MaxPooling1 (None, None, 32) 0
_________________________________________________________________
conv1d_2 (Conv1D) (None, None, 32) 5152
_________________________________________________________________
gru_1 (GRU) (None, 32) 6240
_________________________________________________________________
dense_1 (Dense) (None, 1) 33
=================================================================
Total params: 13,697
Trainable params: 13,697
Non-trainable params: 0
_________________________________________________________________
'''
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)
# plot
import matplotlib.pyplot as plt
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(loss))
plt.figure()
params += _params
regularizers += _regularizers
constraints += _consts
updates += _updates
print('parameters:')
print(params)
print('regularizers:')
print(regularizers)
print('constrains:')
print(constraints)
print('updates:')
print(updates)
'''updates'''
optimizer = RMSprop()
_updates = optimizer.get_updates(params, constraints, train_loss)
updates += _updates
print('after RMSprop, updates:')
for update in updates:
print(update)
train_ins = [X_train, y, weights]
test_ins = [X_test, y, weights]
predict_ins = [X_test]
'''Get functions'''
_train = K.function(train_ins, [train_loss], updates=updates)
_train_with_acc = K.function(train_ins, [train_loss, train_accuracy], updates=updates)
_predict = K.function(predict_ins, [y_test], updates=state_updates)
dataset = Dataset(args.path + args.dataset)
train, testRatings, testNegatives = dataset.trainMatrix, dataset.testRatings, dataset.testNegatives
num_users, num_items = train.shape
print("Load data done [%.1f s]. #user=%d, #item=%d, #train=%d, #test=%d" %
(time() - t1, num_users, num_items, train.nnz, len(testRatings)))
# Build model
model = get_model(num_users, num_items, num_factors, regs)
for i in range(len(model.layers)):
print(model.get_layer(index=i).output)
if learner.lower() == "adagrad":
model.compile(optimizer=Adagrad(lr=learning_rate),
loss='binary_crossentropy')
elif learner.lower() == "rmsprop":
model.compile(optimizer=RMSprop(lr=learning_rate),
loss='binary_crossentropy')
elif learner.lower() == "adam":
model.compile(optimizer=Adam(lr=learning_rate),
loss='binary_crossentropy')
else:
model.compile(optimizer=SGD(lr=learning_rate),
loss='binary_crossentropy')
print(model.summary())
# Init performance
t1 = time()
(hits, ndcgs) = evaluate_model(model, testRatings, testNegatives, topK,
evaluation_threads)
hr, ndcg = np.array(hits).mean(), np.array(ndcgs).mean()
#mf_embedding_norm = np.linalg.norm(model.get_layer('user_embedding').get_weights())+np.linalg.norm(model.get_layer('item_embedding').get_weights())
def adversarial_model(self):
if self.AM:
return self.AM
optimizer = RMSprop(lr=0.0001, decay=3e-8)
# self.AM = Sequential()
# self.AM.add(self.generator())
# self.AM.add(self.discriminator())
#
#
# # self.AM.add(self.generator())
# # self.AM.add(self.discriminator_model())
#
# self.AM.compile(loss='binary_crossentropy', optimizer=optimizer,
# metrics=['accuracy'])
# return self.AM
# am = Add()(inputs=(self.generator(),self.discriminator()))
#
# am_model.compile(loss='binary_crossentropy', optimizer=optimizer,
# metrics=['accuracy'])
""" print(type(self.discriminator()(inputs)))
merge = conc()([self.generator().outputs,self.discriminator().inputs])
hidden1 = Dense(10, activation='relu')(merge)
output = Dense(1, activation='sigmoid')(hidden1)
self.AM = Model(inputs=self.generator().inputs, outputs=output)
self.AM.summary()
"""
# gen_inputs, gen_outputs = self.generator(input_output_return=True)
# dis_inputs, dis_outputs = self.discriminator(input_output_return=True)
#
# adv_input_image_dense = Dense(512, activation='relu')(gen_inputs[0])
# adv_input_label_rotation_dense = Dense(512, activation='relu')(gen_inputs[1])
# adv_input_label_lightning_dense = Dense(512, activation='relu')(gen_inputs[2])
#
# adv_merged_inputs = Add()([adv_input_image_dense, adv_input_label_rotation_dense, adv_input_label_lightning_dense])
gen = self.generator()
dis = self.discriminator()(gen.output)
# print(dis.input)
# print(type(dis.input))
#
# dis.input = gen.output
#
# print(dis.input)
# print(type(dis.input))
# adv_top_input = gen.generator_input_denses
#
# adv_top_merged_input = Add()(adv_top_input)
#
# x1 = Dense(gen.depth, activation='relu')(adv_top_merged_input)
#
# adv_medium_merged_input = Add()([x1,dis.inp])
#
# # x2 = Dense(gen.depth, activation='relu')(adv_medium_merged_input)
#
# self.AM = Model(inputs=adv_top_input, outputs=dis.outputs)
self.AM = Model(inputs=gen.inputs, outputs=dis)
self.AM.compile(loss='binary_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
return self.AM
def __init__(self):
rng = numpy.random.RandomState(23455)
self.X1 = T.tensor4('X1', dtype='float32')
self.X2 = T.tensor4('X2', dtype='float32')
self.Y = T.ivector('Y')
self.layer0 = Layer.ConvMaxPool2Layer(
rng,
input1=self.X1,
input2=self.X2,
filter_shape=[25, 3, 5, 5],
poolsize=[2, 2]
)
self.layer1 = Layer.ConvMaxPool2Layer(
rng,
input1=self.layer0.output1,
input2=self.layer0.output2,
filter_shape=[25, 25, 3, 3],
poolsize=[2, 2]
)
self.layer2 = Layer.SecretLayer(
rng,
input1=self.layer1.output1,
input2=self.layer1.output2,
filter_shape=[25, 25, 5, 5]
)
# self.layer3 = Layer.MultiConvMaxPoolLayer(
# rng,
# input=self.layer2.results,
# filter_shape=[25, 25, 3, 3],
# poolsize=(2, 2)
# )
self.layer3 = Layer.LocalCovLayerDropout(
rng,
input=self.layer2.results,
n_in=18*9*25,
n_out=200
)
self.layer4 = Layer.HiddenLayerDropout(
rng,
train_input=self.layer3.train_output,
test_input=self.layer3.test_output,
# n_in=25*24*3,
n_in=800,
n_out=200
)
# self.layer2 = Layer.ConvMaxPoolLayer(
# rng,
# input=T.abs_(self.layer1.output1 - self.layer1.output2),
# filter_shape=[25, 25, 3, 3],
# poolsize=[2, 2]
# )
#
# self.layer3 = Layer.HiddenLayer(
# rng,
# input=self.layer2.output,
# n_in=25*18*5,
# n_out=500
# )
# self.layer5 = Layer.LogisticRegression(self.layer4.output, 500, 2)
# self.cost = self.layer5.negative_log_likelihood(self.Y)
self.layer5 = Layer.LogisticRegressionDropout(
train_input=self.layer4.train_output,
test_input=self.layer4.test_output,
n_in=200,
n_out=2
)
self.cost = self.layer5.negative_log_likelihood_train(self.Y)
self.params = self.layer5.params + self.layer4.params + self.layer3.params + self.layer2.params + self.layer1.params + self.layer0.params
self.grads = T.grad(self.cost, self.params)
# learning_rate = numpy.float32(0.01)
# updates = [
# (param_i, param_i - learning_rate * grad_i)
# for param_i, grad_i in zip(params, grads)
# ]
constraints_list = []
for param in self.params:
constraints_list.append(identity())
rms = RMSprop()
self.updates = rms.get_updates(self.params, constraints_list, self.cost)
print('\ncreate model...')
model = Sequential() # stack of layers
#model.add(tf.keras.layers.Flatten())
model.add(Dense(num_hidden, activation='relu', input_shape=(num_input, )))
model.add(Dropout(0.2))
model.add(Dense(num_hidden, activation='relu'))
model.add(Dropout(0.2)) #regularization technic by removing some nodes
model.add(
Dense(num_classes, activation='softmax')
) # last layer always has softmax(except for regession problems and binary- 2 classes where sigmoid is enough)
# Prints a string summary of the neural network.')
model.summary()
model.compile(
loss=
'categorical_crossentropy', # measure how accurate the model during training
optimizer=RMSprop(
), #this is how model is updated based on data and loss function
metrics=['accuracy'])
print('\ntrain model...')
history = model.fit(
x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
verbose=1
# , callbacks=[early_stop, PrintDot()]#Early stopping is a useful technique to prevent overfitting.
)
print('\nplot_accuracy_loss_vs_time...')
history_dict = history.history
Enc = Dense(2, activation='tanh')(EncInput)
print(Enc)
encode = Model(EncInput, Enc)
##Decoder
DecInput = Input(shape=(latent_dim))
Dec = Dense(input_dim, activation='sigmoid')(DecInput)
print(Dec)
decode = Model(DecInput, Dec)
##Autoencoder
autoencoder = Model(EncInput, decode(Enc))
#Try different learning rates, batch sizes, dropout layer (?), add another layer (if more data)?
autoencoder.compile(loss='binary_crossentropy',
optimizer=RMSprop(learning_rate=0.00013))
# ==== autoencoder
#Activation functions
def sigmoid(x):
if not isinstance(x, np.ndarray):
print("Wrong parameter of sigmoid function")
return False
sigm = 1.0 / (1 + np.exp(-x))
return sigm
# def tanh(x):
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=(3, 3)))
model.add(Activation('relu'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))
#Train the model
t1 = dt.now()
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=RMSprop(lr=0.0001, decay=1e-6),
metrics=['accuracy'])
model_checkpoints = callbacks.ModelCheckpoint(
'/content/gdrive/My Drive/CNNProject/SampleOut_2018-12-03_23-22-30.624946/10_Layer6_E20_B128_F64_K55.py_weights_{epoch:02d}_{val_loss:.2f}_Proj.h5',
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
#Training
model_log = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
def main():
train = pd.read_csv(args.folds_csv)
MODEL_PATH = os.path.join(args.models_dir, args.network + args.alias)
folds = [int(f) for f in args.fold.split(',')]
print('Training Model:', args.network + args.alias)
for fold in folds:
K.clear_session()
print(
'***************************** FOLD {} *****************************'
.format(fold))
if fold == 0:
if os.path.isdir(MODEL_PATH):
raise ValueError('Such Model already exists')
os.system("mkdir {}".format(MODEL_PATH))
# Train/Validation sampling
df_train = train[train.fold != fold].copy().reset_index(drop=True)
df_valid = train[train.fold == fold].copy().reset_index(drop=True)
# Train on pseudolabels only
if args.pseudolabels_dir != '':
pseudolabels = pd.read_csv(args.pseudolabels_csv)
df_train = pseudolabels.sample(
frac=1, random_state=13).reset_index(drop=True)
# Keep only non-black images
ids_train, ids_valid = df_train[
df_train.unique_pixels > 1].id.values, df_valid[
df_valid.unique_pixels > 1].id.values
print('Training on {} samples'.format(ids_train.shape[0]))
print('Validating on {} samples'.format(ids_valid.shape[0]))
# Initialize model
weights_path = os.path.join(MODEL_PATH,
'fold_{fold}.hdf5'.format(fold=fold))
# Get the model
model, preprocess = get_model(args.network,
input_shape=(args.input_size,
args.input_size, 3),
freeze_encoder=args.freeze_encoder)
# LB metric threshold
def lb_metric(y_true, y_pred):
return Kaggle_IoU_Precision(
y_true,
y_pred,
threshold=0 if args.loss_function == 'lovasz' else 0.5)
model.compile(optimizer=RMSprop(lr=args.learning_rate),
loss=make_loss(args.loss_function),
metrics=[lb_metric])
if args.pretrain_weights is None:
print('No weights passed, training from scratch')
else:
wp = args.pretrain_weights.format(fold)
print('Loading weights from {}'.format(wp))
model.load_weights(wp, by_name=True)
# Get augmentations
augs = get_augmentations(args.augmentation_name,
p=args.augmentation_prob)
# Data generator
dg = SegmentationDataGenerator(input_shape=(args.input_size,
args.input_size),
batch_size=args.batch_size,
augs=augs,
preprocess=preprocess)
train_generator = dg.train_batch_generator(ids_train)
validation_generator = dg.evaluation_batch_generator(ids_valid)
# Get callbacks
callbacks = get_callback(args.callback,
weights_path=weights_path,
fold=fold)
# Fit the model with Generators:
model.fit_generator(
generator=ThreadsafeIter(train_generator),
steps_per_epoch=ids_train.shape[0] // args.batch_size * 2,
epochs=args.epochs,
callbacks=callbacks,
validation_data=ThreadsafeIter(validation_generator),
validation_steps=np.ceil(ids_valid.shape[0] / args.batch_size),
workers=args.num_workers)
gc.collect()
cost = layer4.negative_log_likelihood(Y)
params = layer4.params + layer3.params + layer2.params + layer1.params + layer0.params
grads = T.grad(cost, params)
# learning_rate = numpy.float32(0.01)
# updates = [
# (param_i, param_i - learning_rate * grad_i)
# for param_i, grad_i in zip(params, grads)
# ]
constraints_list = []
for param in params:
constraints_list.append(identity())
rms = RMSprop()
updates = rms.get_updates(params, constraints_list, cost)
def read_image(address):
img = Image.open(open(address))
img = numpy.asarray(img, dtype='float32') / 256.
# put image in 4D tensor of shape (1, 3, height, width)
img = img.transpose(2, 0, 1).reshape(1, 3, 128, 48)
return img
# img1 = read_image('/home/austin/Documents/Datasets/VIPeR/cam_a/001_45.bmp')
# img2 = read_image('/home/austin/Documents/Datasets/VIPeR/cam_b/091_90.bmp')
# f = theano.function([X1, X2, Y], [cost, layer2.similarity])
# y = numpy.asarray([-1], dtype='int32')
# [tmp, sim] = f(img1, img2, y)
