def train():
# extracting file saved by data_prep.py
data = np.load('face_data.npz')
x , y = data['x'], data['y']
#categorical conversion of data label
y = keras.utils.to_categorical(y, 6)
# using transfer learning to reduce the time required to train the algo
resnet = VGGFace(model='resnet50',input_shape=(224, 224, 3))
layer_name = resnet.layers[-2].name
#adding our own custom layers to make the model work on our datatset
out = resnet.get_layer(layer_name).output
out = Dense(6,activation='softmax')(out)
resnet_4 = Model(resnet.input, out)
# removing last layer of the model and adding my own layer to it
for layer in resnet_4.layers[:-1]:
layer.trainable = False
resnet_4.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
#checking the final created dataset
print (resnet_4.summary())
# training the model we have created with our own dataset
resnet_4.fit(x, y,batch_size=10,epochs=10,shuffle=True)
#saving the trained model so that it can be used afterwards
resnet_4.save("C:\\Users\\hseth\\Desktop\\face recogination\\model_save_face.h5")
# checking the accuracy of the model on training data only as i used a very small dataset
scores = resnet_4.evaluate(x, y, verbose=1)
print('Test accuracy:', scores[1])
def test_works():
a = Input(shape=(None, 4), name="input")
ls = Sort(initial_beta=np.array([1, 0, 0, 0]), name='sort')
s = ls(a)
p_ls = Perturbed_Sort(ls)
p_s = p_ls(a)
model = Model(input=[a], output=[s, p_s], name='test')
# print(Sort(nb_out=5).get_output_shape_for((1,2,3)))
inp = np.random.random((1000, 300, 4))
indicies = np.argsort(inp[:, :, 0])
# print(indicies)
target = np.array(
[np.take(inp[i], indicies[i], axis=-2) for i in range(inp.shape[0])])
# print("Input")
# print(inp)
# print("Target")
# print(target)
model.compile(optimizer=Finite_Differences(model, ls, p_ls),
loss={
'sort': 'mse',
'pert_sort': 'mse'
})
# model.fit(inp, [target, target], nb_epoch=200,batch_size=1000)
print(model.evaluate(inp, [target, target], batch_size=1000))
def embedding_binary_classification():
docs = [
'Well done!', 'Good work', 'Great effort', 'nice work', 'Excellent!',
'Weak', 'Poor effort!', 'not good', 'poor work',
'Could have done better.'
]
# define class labels
labels = [1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
vocab_size = 50
encoded_docs = [one_hot(d, vocab_size)
for d in docs] # one_hot编码到[1,n],不包括0
print(encoded_docs)
max_length = 4
padded_docs = pad_sequences(encoded_docs,
maxlen=max_length,
padding='post')
print(padded_docs)
input = Input(shape=(4, ))
x = Embedding(vocab_size, 8,
input_length=max_length)(input) # 这一步对应的参数量为50*8
x = Flatten()(x)
x = Dense(1, activation='sigmoid')(x)
model = Model(inputs=input, outputs=x)
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['acc'])
model.summary()
model.fit(padded_docs, labels, epochs=100, verbose=0)
loss, accuracy = model.evaluate(padded_docs, labels, verbose=0)
print('loss: {0},accuracy:{1}'.format(loss, accuracy))
loss_test, accuracy_test = model.evaluate(padded_docs, labels, verbose=0)
print('loss_test: {0},accuracy_test:{1}'.format(loss_test, accuracy_test))
test = one_hot('Weak', 50)
padded_test = pad_sequences([test], maxlen=max_length, padding='post')
print(model.predict(padded_test))
def train(model: Model,
x_train,
y_train,
x_test,
y_test,
batch_size=128,
epochs=20):
time = int(datetime.now().timestamp())
name = "{}_{}".format("conv", time)
chkp_path = "./checkpoints/{}".format(name)
os.makedirs(chkp_path, exist_ok=True)
model.compile(loss=K.categorical_crossentropy,
optimizer=Adam(),
metrics=[metrics.categorical_accuracy])
model.fit(
x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
callbacks=[
TensorBoard(log_dir='/tmp/tensorflow/{}'.format(name)),
ModelCheckpoint(os.path.join(
chkp_path,
"weights-improvement-{epoch:02d}-{val_categorical_accuracy:.2f}.hdf5"
),
monitor='val_categorical_accuracy',
verbose=1,
save_best_only=True,
mode='auto')
])
export_model(tf.train.Saver(), ['conv2d_1_input'], 'dense_2/Softmax', name)
score = model.evaluate(x_test, y_test)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
def test_lkrelu(self):
batch_size = 32
num_classes = 10
(x_train, y_train), (x_test, y_test) = load_cifar10()
inputs = Input(shape=x_train.shape[1:])
x = Conv2D(self.width, (3, 3))(inputs)
x = LKReLU()(x)
x = Flatten()(x)
x = Dense(num_classes, activation='softmax', name='fc1000')(x)
model = Model(inputs=inputs, outputs=x)
print(model.summary())
opt = keras.optimizers.sgd()
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=self.metrics)
log_dir = 'summaries/width-lkrelu-{}-cifar10-{}-{}'.format(
self.width, self.seed, datetime.datetime.now())
model.fit(
x_train,
y_train,
batch_size=batch_size,
epochs=self.epochs,
validation_data=(x_test, y_test),
shuffle=False,
callbacks=[
TensorBoard(log_dir=log_dir),
# ModelCheckpoint(
# 'checkpoints/width-lkrelu-cifar10-{epoch:02d}-{val_loss:.2f}.hdf5')
])
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
def main(_):
# The data, shuffled and split between train and test sets:
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print('x_train shape:', x_train.shape)
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)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
inputs = Input(shape=(32, 32, 3))
out1, out2 = simple_cnn(inputs)
model = Model(inputs=inputs, outputs=[out1, out2])
# model.summary()
opt = keras.optimizers.rmsprop(lr=0.0001, decay=1e-6)
model.compile(
optimizer=opt,
loss=['categorical_crossentropy', 'categorical_crossentropy'],
metrics=['accuracy'])
if not data_augmentation:
print('Not using data augmentation.')
model.fit(x_train, [y_train, y_train],
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, [y_test, y_test]),
shuffle=True)
else:
print('Using real-time data augmentation.')
def train_generator(x, y, batch_size):
train_datagen = ImageDataGenerator(
width_shift_range=
0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=
0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True) # randomly flip images
generator = train_datagen.flow(x, y, batch_size=batch_size)
while 1:
x_batch, y_batch = generator.next()
yield (x_batch, [y_batch, y_batch])
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(generator=train_generator(x_train, y_train,
batch_size),
steps_per_epoch=int(y_train.shape[0] / batch_size),
epochs=epochs,
validation_data=(x_test, [y_test, y_test]),
callbacks=[])
# Save model and weights
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
model_path = os.path.join(save_dir, model_name)
model.save(model_path)
print('Saved trained model at %s ' % model_path)
# Score trained model.
scores = model.evaluate(x_test, [y_test, y_test], verbose=1)
print('Test loss:', scores[0])
print('Test accuracy:', scores[1])
m = Dense(32, activation='relu')(m)
op = Dense(3, activation='softmax')(m)
model = Model(input=ip, output=op)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
history4 = model.fit(train_X_ex3,
train_y,
epochs=100,
batch_size=32,
verbose=0,
validation_data=(test_X_ex3, test_y))
plt.plot(history4.history['accuracy'], label='Train Accuracy')
plt.plot(history4.history['val_accuracy'], label='Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
corrects, wrongs = model.evaluate(train_X_ex3, train_y)
print("accuracy train: ", corrects / (corrects + wrongs))
corrects, wrongs = model.evaluate(test_X_ex3, test_y)
print("accuracy: test", corrects / (corrects + wrongs))
cm = model.confusion_matrix(train_X_ex3, train_y)
class RankNet(ObjectRanker, Tunable):
def __init__(self, n_features, n_hidden=2, n_units=8,
loss_function=binary_crossentropy, batch_normalization=True,
kernel_regularizer=l2(l=1e-4), non_linearities='relu',
optimizer="adam", metrics=[top_k_categorical_accuracy, binary_accuracy],
batch_size=256, random_state=None, **kwargs):
"""Create an instance of the RankNet architecture.
RankNet breaks the rankings into pairwise comparisons and learns a
latent utility model for the objects.
Parameters
----------
n_features : int
Number of features of the object space
n_hidden : int
Number of hidden layers used in the scoring network
n_units : int
Number of hidden units in each layer of the scoring network
loss_function : function or string
Loss function to be used for the binary decision task of the
pairwise comparisons
batch_normalization : bool
Whether to use batch normalization in each hidden layer
kernel_regularizer : function
Regularizer function applied to all the hidden weight matrices.
non_linearities : function or string
Type of activation function to use in each hidden layer
optimizer : function or string
Optimizer to use during stochastic gradient descent
metrics : list
List of metrics to evaluate during training (can be
non-differentiable)
batch_size : int
Batch size to use during training
random_state : int, RandomState instance or None
Seed of the pseudorandom generator or a RandomState instance
**kwargs
Keyword arguments for the algorithms
References
----------
.. [1] Burges, C. et al. (2005, August).
"Learning to rank using gradient descent.",
In Proceedings of the 22nd international conference on Machine
learning (pp. 89-96). ACM.
.. [2] Burges, C. J. (2010).
"From ranknet to lambdarank to lambdamart: An overview.",
Learning, 11(23-581), 81.
"""
self.logger = logging.getLogger(RankNet.__name__)
self.n_features = n_features
self.batch_normalization = batch_normalization
self.non_linearities = non_linearities
self.metrics = metrics
self.kernel_regularizer = kernel_regularizer
self.loss_function = loss_function
self.optimizer = optimizers.get(optimizer)
self.n_hidden = n_hidden
self.n_units = n_units
self._construct_layers()
self.threshold_instances = THRESHOLD
self.batch_size = batch_size
self.random_state = check_random_state(random_state)
def _construct_layers(self, **kwargs):
self.x1 = Input(shape=(self.n_features,))
self.x2 = Input(shape=(self.n_features,))
self.output_node = Dense(1, activation='sigmoid',
kernel_regularizer=self.kernel_regularizer)
self.output_layer_score = Dense(1, activation='linear')
if self.batch_normalization:
self.hidden_layers = [NormalizedDense(self.n_units, name="hidden_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities
) for x in range(self.n_hidden)]
else:
self.hidden_layers = [Dense(self.n_units, name="hidden_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities)
for x in range(self.n_hidden)]
assert len(self.hidden_layers) == self.n_hidden
def fit(self, X, Y, epochs=10, callbacks=None,
validation_split=0.1, verbose=0, **kwd):
self.logger.debug('Creating the Dataset')
garbage, X1, X2, garbage, Y_single = generate_complete_pairwise_dataset(X, Y)
del garbage
if (X1.shape[0] > self.threshold_instances):
indicies = self.random_state.choice(X1.shape[0], self.threshold_instances, replace=False)
X1 = X1[indicies, :]
X2 = X2[indicies, :]
Y_single = Y_single[indicies]
self.logger.debug('Finished the Dataset')
self.logger.debug('Creating the model')
output = self.construct_model()
# Model with input as two objects and output as probability of x1>x2
self.model = Model(inputs=[self.x1, self.x2], outputs=output)
self.model.compile(loss=self.loss_function, optimizer=self.optimizer, metrics=self.metrics)
self.logger.debug('Finished Creating the model, now fitting started')
self.model.fit([X1, X2], Y_single, batch_size=self.batch_size, epochs=epochs,
callbacks=callbacks, validation_split=validation_split,
verbose=verbose, **kwd)
self.scoring_model = self._create_scoring_model()
self.logger.debug('Fitting Complete')
def construct_model(self):
# weight sharing using same hidden layer for two objects
enc_x1 = self.hidden_layers[0](self.x1)
enc_x2 = self.hidden_layers[0](self.x2)
neg_x2 = Lambda(lambda x: -x)(enc_x2)
for hidden_layer in self.hidden_layers[1:]:
enc_x1 = hidden_layer(enc_x1)
neg_x2 = hidden_layer(neg_x2)
merged_inputs = add([enc_x1, neg_x2])
output = self.output_node(merged_inputs)
return output
def _create_scoring_model(self):
inp = Input(shape=(self.n_features,))
x = inp
for hidden_layer in self.hidden_layers:
x = hidden_layer(x)
output_score = self.output_node(x)
model = Model(inputs=[inp], outputs=output_score)
return model
def predict(self, X, **kwargs):
return super().predict(X, **kwargs)
def _predict_scores_fixed(self, X, **kwargs):
# assert X1.shape[1] == self.n_features
n_instances, n_objects, n_features = X.shape
self.logger.info("For Test instances {} objects {} features {}".format(n_instances, n_objects, n_features))
scores = []
for X1 in X:
score = self.scoring_model.predict(X1, **kwargs)
score = score.flatten()
scores.append(score)
scores = np.array(scores)
self.logger.info("Done predicting scores")
return scores
def predict_scores(self, X, **kwargs):
return super().predict_scores(X, **kwargs)
def predict_pair(self, X1, X2, **kwargs):
pairwise = np.empty(2)
pairwise[0] = self.model.predict([X1, X2], **kwargs)
pairwise[1] = self.model.predict([X2, X1], **kwargs)
return pairwise
def evaluate(self, X1_test, X2_test, Y_test, **kwargs):
return self.model.evaluate([X1_test, X2_test], Y_test, **kwargs)
def set_tunable_parameters(self, n_hidden=32,
n_units=2,
reg_strength=1e-4,
learning_rate=1e-3,
batch_size=128, **point):
self.n_hidden = n_hidden
self.n_units = n_units
self.kernel_regularizer = l2(reg_strength)
self.batch_size = batch_size
K.set_value(self.optimizer.lr, learning_rate)
self._construct_layers()
if len(point) > 0:
self.logger.warning('This ranking algorithm does not support'
' tunable parameters'
' called: {}'.format(print_dictionary(point)))
include_top=False,
input_shape=(224, 224, 3))
print(model.layers)
last_layer = model.get_layer('avg_pool').output
x = Flatten()(last_layer)
x = Dense(target_class, name='fc1')(x)
x = Activation('softmax', name='fc1/softmax')(x)
custom_model = Model(model.input, x)
print(custom_model.layers)
for layer in custom_model.layers:
layer.trainable = True
if not RetrainAllLayers:
for layer in custom_model.layers[:-2 * (newLayers)]:
layer.trainable = False
custom_model.compile(optimizer=RMSprop(lr=1e-4),
loss='categorical_crossentropy',
metrics=['accuracy'])
custom_model.fit(x=x_train, y=y_train, epochs=20, batch_size=32)
result = custom_model.evaluate(x_test, y_test)
print("&&&")
print(result)
custom_model.save('resnet-retrained.h5')
class FETANetwork(ObjectRanker, Tunable):
def __init__(self,
n_objects,
n_features,
n_hidden=2,
n_units=8,
add_zeroth_order_model=False,
max_number_of_objects=5,
num_subsample=5,
loss_function=hinged_rank_loss,
batch_normalization=False,
kernel_regularizer=l2(l=1e-4),
non_linearities='selu',
optimizer="adam",
metrics=None,
use_early_stopping=False,
es_patience=300,
batch_size=256,
random_state=None,
**kwargs):
"""
Create a FETA-network architecture for object ranking.
Training and prediction complexity is quadratic in the number of objects.
Parameters
----------
n_objects : int
Number of objects to be ranked
n_features : int
Dimensionality of the feature space of each object
n_hidden : int
Number of hidden layers
n_units : int
Number of hidden units in each layer
add_zeroth_order_model : bool
True if the model should include a latent utility function
max_number_of_objects : int
The maximum number of objects to train from
num_subsample : int
Number of objects to subsample to
loss_function : function
Differentiable loss function for the score vector
batch_normalization : bool
Whether to use batch normalization in the hidden layers
kernel_regularizer : function
Regularizer to use in the hidden units
non_linearities : string or function
Activation function to use in the hidden units
optimizer : string or function
Stochastic gradient optimizer
metrics : list
List of evaluation metrics (can be non-differentiable)
batch_size : int
Batch size to use for training
random_state : int or object
Numpy random state
**kwargs
Keyword arguments for the hidden units
"""
self.logger = logging.getLogger(FETANetwork.__name__)
self.random_state = check_random_state(random_state)
self.kernel_regularizer = kernel_regularizer
self.batch_normalization = batch_normalization
self.non_linearities = non_linearities
self.loss_function = loss_function
self.metrics = metrics
self._n_objects = n_objects
self.max_number_of_objects = max_number_of_objects
self.num_subsample = num_subsample
self.n_features = n_features
self.batch_size = batch_size
self.optimizer = optimizers.get(optimizer)
self._use_zeroth_model = add_zeroth_order_model
self.n_hidden = n_hidden
self.n_units = n_units
self._construct_layers()
@property
def n_objects(self):
if self._n_objects > self.max_number_of_objects:
return self.max_number_of_objects
return self._n_objects
def _construct_layers(self, **kwargs):
self.input_layer = Input(shape=(self.n_objects, self.n_features))
# Todo: Variable sized input
# X = Input(shape=(None, n_features))
if self.batch_normalization:
if self._use_zeroth_model:
self.hidden_layers_zeroth = [
NormalizedDense(self.n_units,
name="hidden_zeroth_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities,
**kwargs) for x in range(self.n_hidden)
]
self.hidden_layers = [
NormalizedDense(self.n_units,
name="hidden_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities,
**kwargs) for x in range(self.n_hidden)
]
else:
if self._use_zeroth_model:
self.hidden_layers_zeroth = [
Dense(self.n_units,
name="hidden_zeroth_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities)
for x in range(self.n_hidden)
]
self.hidden_layers = [
Dense(self.n_units,
name="hidden_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities)
for x in range(self.n_hidden)
]
assert len(self.hidden_layers) == self.n_hidden
self.output_node = Dense(1,
activation='sigmoid',
kernel_regularizer=self.kernel_regularizer)
if self._use_zeroth_model:
self.output_node_zeroth = Dense(
1,
activation='sigmoid',
kernel_regularizer=self.kernel_regularizer)
def _create_zeroth_order_model(self):
inp = Input(shape=(self.n_features, ))
x = inp
for hidden in self.hidden_layers_zeroth:
x = hidden(x)
zeroth_output = self.output_node_zeroth(x)
return Model(inputs=[inp], outputs=zeroth_output)
def _create_pairwise_model(self):
x1 = Input(shape=(self.n_features, ))
x2 = Input(shape=(self.n_features, ))
x1x2 = concatenate([x1, x2])
x2x1 = concatenate([x2, x1])
for hidden in self.hidden_layers:
x1x2 = hidden(x1x2)
x2x1 = hidden(x2x1)
merged_left = concatenate([x1x2, x2x1])
merged_right = concatenate([x2x1, x1x2])
N_g = self.output_node(merged_left)
N_l = self.output_node(merged_right)
merged_output = concatenate([N_g, N_l])
return Model(inputs=[x1, x2], outputs=merged_output)
def _predict_pair(self, a, b, only_pairwise=False, **kwargs):
# TODO: Is this working correctly?
pairwise = self.pairwise_model.predict([a, b], **kwargs)
if not only_pairwise and self._use_zeroth_model:
utility_a = self.zero_order_model.predict([a])
utility_b = self.zero_order_model.predict([b])
return pairwise + (utility_a, utility_b)
return pairwise
def _predict_scores_using_pairs(self, X, **kwd):
n_instances, n_objects, n_features = X.shape
n2 = n_objects * (n_objects - 1)
pairs = np.empty((n2, 2, n_features))
scores = np.zeros((n_instances, n_objects))
for n in range(n_instances):
if self._use_zeroth_model:
scores[n] = self.zero_order_model.predict(X[n]).ravel()
for k, (i, j) in enumerate(permutations(range(n_objects), 2)):
pairs[k] = (X[n, i], X[n, j])
result = self._predict_pair(pairs[:, 0],
pairs[:, 1],
only_pairwise=True,
**kwd)[:, 0]
scores[n] += result.reshape(n_objects, n_objects - 1).mean(axis=1)
del result
del pairs
return scores
def fit(self,
X,
Y,
epochs=10,
callbacks=None,
validation_split=0.1,
verbose=0,
**kwd):
self.logger.debug('Enter fit function...')
X, Y = self.sub_sampling(X, Y)
scores = self.construct_model()
self.model = Model(inputs=self.input_layer, outputs=scores)
self.pairwise_model = self._create_pairwise_model()
if self._use_zeroth_model:
self.zero_order_model = self._create_zeroth_order_model()
self.logger.debug('Compiling complete model...')
self.model.compile(loss=self.loss_function,
optimizer=self.optimizer,
metrics=self.metrics)
self.logger.debug('Starting gradient descent...')
self.model.fit(x=X,
y=Y,
batch_size=self.batch_size,
epochs=epochs,
callbacks=callbacks,
validation_split=validation_split,
verbose=verbose,
**kwd)
def construct_model(self):
def create_input_lambda(i):
return Lambda(lambda x: x[:, i])
if self._use_zeroth_model:
self.logger.debug('Create 0th order model')
zeroth_order_outputs = []
inputs = []
for i in range(self.n_objects):
x = create_input_lambda(i)(self.input_layer)
inputs.append(x)
for hidden in self.hidden_layers_zeroth:
x = hidden(x)
zeroth_order_outputs.append(self.output_node_zeroth(x))
zeroth_order_scores = concatenate(zeroth_order_outputs)
self.logger.debug('0th order model finished')
self.logger.debug('Create 1st order model')
outputs = [list() for _ in range(self.n_objects)]
for i, j in combinations(range(self.n_objects), 2):
if self._use_zeroth_model:
x1 = inputs[i]
x2 = inputs[j]
else:
x1 = create_input_lambda(i)(self.input_layer)
x2 = create_input_lambda(j)(self.input_layer)
x1x2 = concatenate([x1, x2])
x2x1 = concatenate([x2, x1])
for hidden in self.hidden_layers:
x1x2 = hidden(x1x2)
x2x1 = hidden(x2x1)
merged_left = concatenate([x1x2, x2x1])
merged_right = concatenate([x2x1, x1x2])
N_g = self.output_node(merged_left)
N_l = self.output_node(merged_right)
outputs[i].append(N_g)
outputs[j].append(N_l)
# convert rows of pairwise matrix to keras layers:
outputs = [concatenate(x) for x in outputs]
# compute utility scores:
sum_fun = lambda s: K.mean(s, axis=1, keepdims=True)
scores = [Lambda(sum_fun)(x) for x in outputs]
scores = concatenate(scores)
self.logger.debug('1st order model finished')
if self._use_zeroth_model:
scores = add([scores, zeroth_order_scores])
return scores
def sub_sampling(self, X, Y):
if self._n_objects > self.max_number_of_objects:
bucket_size = int(self._n_objects / self.max_number_of_objects)
idx = self.random_state.randint(bucket_size,
size=(len(X), self.n_objects))
# TODO: subsampling multiple rankings
idx += np.arange(start=0, stop=self._n_objects,
step=bucket_size)[:self.n_objects]
X = X[np.arange(X.shape[0])[:, None], idx]
Y = Y[np.arange(X.shape[0])[:, None], idx]
tmp_sort = Y.argsort(axis=-1)
Y = np.empty_like(Y)
Y[np.arange(len(X))[:, None], tmp_sort] = np.arange(self.n_objects)
return X, Y
def _predict_scores_fixed(self, X, **kwargs):
n_instances, n_objects, n_features = tensorify(X).get_shape().as_list()
self.logger.info("For Test instances {} objects {} features {}".format(
n_instances, n_objects, n_features))
if self.max_number_of_objects < self._n_objects or self.n_objects != n_objects:
scores = self._predict_scores_using_pairs(X, **kwargs)
else:
scores = self.model.predict(X, **kwargs)
self.logger.info("Done predicting scores")
return scores
def evaluate(self, X, Y, **kwargs):
scores = self.model.evaluate(X, Y, **kwargs)
return scores
def predict_scores(self, X, **kwargs):
return super().predict_scores(X, **kwargs)
def predict(self, X, **kwargs):
return ObjectRanker.predict(self, X, **kwargs)
def set_tunable_parameters(self,
n_hidden=32,
n_units=2,
reg_strength=1e-4,
learning_rate=1e-3,
batch_size=128,
**point):
self.n_hidden = n_hidden
self.n_units = n_units
self.kernel_regularizer = l2(reg_strength)
self.batch_size = batch_size
K.set_value(self.optimizer.lr, learning_rate)
self._construct_layers()
if len(point) > 0:
self.logger.warning('This ranking algorithm does not support'
' tunable parameters'
' called: {}'.format(print_dictionary(point)))
from keras.layers import Dense
# extracting file saved by data_prep.py
data = np.load('face_data.npz')
x, y = data['x'], data['y']
#categorical conversion of data label
y = keras.utils.to_categorical(y, 6)
# using transfer learning to reduce the time required to train the algo
resnet = VGGFace(model='resnet50', input_shape=(224, 224, 3))
layer_name = resnet.layers[-2].name
#adding our own custom layers to make the model work on our datatset
out = resnet.get_layer(layer_name).output
out = Dense(6, activation='softmax')(out)
resnet_4 = Model(resnet.input, out)
# removing last layer of the model and adding my own layer to it
for layer in resnet_4.layers[:-1]:
layer.trainable = False
resnet_4.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#checking the final created dataset
print(resnet_4.summary())
# training the model we have created with our own dataset
resnet_4.fit(x, y, batch_size=10, epochs=10, shuffle=True)
#saving the trained model so that it can be used afterwards
resnet_4.save("/home/hardik/Desktop/model_save_face.h5")
# checking the accuracy of the model on training data only as i used a very small dataset
scores = resnet_4.evaluate(x, y, verbose=1)
print('Test accuracy:', scores[1])
def main(i, RNN_TYPE):
# TODO: change to GRU, Recurrent, and SimpleRNN
# print(i, RNN_TYPE)
RNN = recurrent.LSTM
if RNN_TYPE == "gru":
# print("Starting a GRU: ")
RNN = recurrent.GRU
file_name = "history_gru_" + str(i) + ".csv"
elif RNN_TYPE == "recurrent":
# print("Starting a Recurrent Unit: ")
RNN = recurrent.Recurrent
file_name = "history_recurrent_" + str(i) + ".csv"
elif RNN_TYPE == "simplernn":
# print("Starting a SimpleRNN: ")
RNN = recurrent.SimpleRNN
file_name = "history_simple_" + str(i) + ".csv"
else:
# print("Starting an LSTM")
file_name = "history_lstm_" + str(i) + ".csv"
EMBED_HIDDEN_SIZE = 100
SENT_HIDDEN_SIZE = 100
QUERY_HIDDEN_SIZE = 100
BATCH_SIZE = 50
EPOCHS = 100
# print('RNN / Embed / Sent / Query = {}, {}, {}, {}'.format(RNN,
# EMBED_HIDDEN_SIZE,
# SENT_HIDDEN_SIZE,
# QUERY_HIDDEN_SIZE))
# print(os.getcwd())
file_list = (os.getcwd())
base_file = os.getcwd() + "/tasks_1-20_v1-2/en/"
file_list = (os.listdir(base_file))
# print(file_list)
test_file = ""
train_file = ""
for file in file_list:
if file.startswith("qa" + str(i) + "_"):
if file.endswith("_test.txt"):
test_file = file
# print(test_file)
elif file.endswith("_train.txt"):
train_file = file
# print(train_file)
print(train_file)
print(test_file)
f_train = open(base_file + train_file)
f_test = open(base_file + test_file)
# try:
# path = get_file('babi-tasks-v1-2.tar.gz',
# origin='https://s3.amazonaws.com/text-datasets/babi_tasks_1-20_v1-2.tar.gz')
# except:
# print('Error downloading dataset, please download it manually:\n'
# '$ wget http://www.thespermwhale.com/jaseweston/babi/tasks_1-20_v1-2.tar.gz\n'
# '$ mv tasks_1-20_v1-2.tar.gz ~/.keras/datasets/babi-tasks-v1-2.tar.gz')
# raise
# tar = tarfile.open(path)
# # Default QA1 with 1000 samples
# # challenge = 'tasks_1-20_v1-2/en/qa1_single-supporting-fact_{}.txt'
# # QA1 with 10,000 samples
# # challenge = 'tasks_1-20_v1-2/en-10k/qa1_single-supporting-fact_{}.txt'
# # QA2 with 1000 samples
# challenge = 'tasks_1-20_v1-2/en/qa2_two-supporting-facts_{}.txt'
# # QA2 with 10,000 samples
# # challenge = 'tasks_1-20_v1-2/en-10k/qa2_two-supporting-facts_{}.txt'
# train = get_stories(tar.extractfile(challenge.format('train')))
# test = get_stories(tar.extractfile(challenge.format('test')))
# print("training stories:")
train = get_stories(f_train)
# print(len(train))
# print("testing stories:")
test = get_stories(f_test)
# print(len(test))
vocab = set()
for story, q, answer in train + test:
vocab |= set(story + q + [answer])
vocab = sorted(vocab)
# check_existence(vocab)
# get_word_vectors_from_pretr_embeddings(train, test, vocab)
# Reserve 0 for masking via pad_sequences
vocab_size = len(vocab) + 1
print("Vocabulary size: ", vocab_size)
word_idx = dict((c, i + 1) for i, c in enumerate(vocab))
story_maxlen = max(map(len, (x for x, _, _ in train + test)))
query_maxlen = max(map(len, (x for _, x, _ in train + test)))
x, xq, y = vectorize_stories(train, word_idx, story_maxlen, query_maxlen)
tx, txq, ty = vectorize_stories(test, word_idx,story_maxlen, query_maxlen)
print('vocab = {}'.format(vocab))
print('x.shape = {}'.format(x.shape))
print('xq.shape = {}'.format(xq.shape))
print('y.shape = {}'.format(y.shape))
print('story_maxlen, query_maxlen = {}, {}'.format(story_maxlen, query_maxlen))
print('Build model...')
pre_trained_emb_weights = get_pre_trained_emb(vocab)
sentence = layers.Input(shape=(story_maxlen,), dtype='float32')
encoded_sentence = layers.Embedding(vocab_size, EMBED_HIDDEN_SIZE)(sentence)
encoded_sentence = layers.Dropout(0.3)(encoded_sentence)
question = layers.Input(shape=(query_maxlen,), dtype='float32')
encoded_question = layers.Embedding(vocab_size, EMBED_HIDDEN_SIZE)(question)
encoded_question = layers.Dropout(0.3)(encoded_question)
encoded_question = RNN(EMBED_HIDDEN_SIZE)(encoded_question)
encoded_question = layers.RepeatVector(story_maxlen)(encoded_question)
merged = layers.add([encoded_sentence, encoded_question])
merged = RNN(EMBED_HIDDEN_SIZE)(merged)
merged = layers.Dropout(0.3)(merged)
preds = layers.Dense(vocab_size, activation='softmax')(merged)
model = Model([sentence, question], preds)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
print('Training')
history = model.fit([x, xq], y, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_split=0.05)
pandas.DataFrame(history.history).to_csv("__pre_"+file_name)
loss, acc = model.evaluate([tx, txq], ty,
batch_size=BATCH_SIZE)
pandas.DataFrame([str(loss)+"_"+ str(acc)]).to_csv("__test_"+RNN_TYPE+"_"+str(i)+".csv")
print('Test loss / test accuracy = {:.4f} / {:.4f}'.format(loss, acc))
# Freeze Layers of VGG16
for layer in model.layers[:20]:
layer.trainable = False
# Was having array issue's so this should fix
y_train = keras.utils.to_categorical(y_train - 1, num_classes=10)
y_test = keras.utils.to_categorical(y_test - 1, num_classes=10)
model.compile(optimizer=sgd, loss='binary_crossentropy', metrics=['accuracy'])
model.summary()
# Fit my training data to the model
model.fit(x_train, y_train, epochs=5, batch_size=32)
# model.fit(x_train, y_train, epochs=5, batch_size=32, validation_data = (x_train, y_train))
# Percent lost and percent correct
loss_and_metrics = model.evaluate(x_test, y_test, batch_size=32)
print("X-Test and Y-Test: ", loss_and_metrics)
# Predict the y values of the unlabeled data set
# classes = model.predict(unlabeled, batch_size=32)
# print(classes)
# Write the data to a file, to loop at later.
# f = open( 'classes.txt', 'w' )
# f.write( 'dict = ' + repr(classes) + '\n' )
# f.close()
# loss_and_metrics = model.evaluate(unlabeled, classes, batch_size = 32)
# print("Unlabeled: " , loss_and_metrics)
last = base_model.get_layer('top_activation').output
x = Flatten()(last)
x = Dense(1024, activation='relu', kernel_initializer="he_uniform")(x)
x = Dense(512, activation='relu', kernel_initializer="he_uniform")(x)
x = Dense(256, activation='relu', kernel_initializer="he_uniform")(x)
x = Dropout(0.5)(x)
output = Dense(10, activation='softmax')(x)
model = Model(base_model.input, output)
model.compile(optimizer=Adam(lr=0.001),
loss='categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(X_train,
y_train,
validation_data=(X_test, y_test),
epochs=nb_epoch,
batch_size=128,
verbose=1)
scores = model.evaluate(X_test, y_test, verbose=0)
print("loss: %.2f" % scores[0])
print("acc: %.2f" % scores[1])
# test acc : 0.88
plt.title('model accuracy')
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'])
plt.show()
0: 1.,
1: 4., # 1: 20.,
2: 1.
}
# prepare callback
histories = my_callbacks.Histories()
#
history = model.fit(X_train,
y_train,
epochs=n_epochs,
batch_size=n_batch_size,
validation_data=([X_val, y_val]),
class_weight=class_weight,
callbacks=[histories])
#
scores = model.evaluate(X_val, y_val, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1] * 100))
cvscores.append(scores[1] * 100)
#
auc_values = histories.aucs
aucs.append(auc_values)
#
loss_values = histories.losses
losses.append(loss_values)
#
y_pred_kfoldValidationSet_asNumber = model.predict([X_val])
y_preds = y_pred_kfoldValidationSet_asNumber[:, 0]
val_output = np.column_stack((X_val_IDs, y_preds))
np.savetxt("./pythonOutput/y_pred_asNumber_2param_1param_fold_" +
str(index) + "_.csv",
val_output,
def train_label_none_label_classification(label_folder,
non_label_folder,
model_file=None):
c = Config()
# Build or load model
if model_file is None:
# create model
img_input = Input(shape=(28, 28, 3))
# prediction = model_cnn_2_layer.nn_classify_label_non_label(img_input)
# prediction = model_cnn_3_layer.nn_classify_label_non_label(img_input)
prediction = nn_cnn_3_layer.nn_classify_label_non_label(img_input)
model = Model(inputs=img_input, outputs=prediction)
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
else:
model = load_model(model_file)
model.summary()
# Load and normalize data
x_train, y_train, x_test, y_test = load_train_validation_data(
label_folder, non_label_folder)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train[:, :, :, 0] -= c.img_channel_mean[0]
x_train[:, :, :, 1] -= c.img_channel_mean[1]
x_train[:, :, :, 2] -= c.img_channel_mean[2]
x_test[:, :, :, 0] -= c.img_channel_mean[0]
x_test[:, :, :, 1] -= c.img_channel_mean[1]
x_test[:, :, :, 2] -= c.img_channel_mean[2]
x_train /= 255
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# x_train.reshape(x_train.shape[0], 28, 28, 3)
# x_test.reshape(x_test.shape[0], 28, 28, 3)
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, 2)
y_test = keras.utils.to_categorical(y_test, 2)
# Checkpointing is to save the network weights only when there is an improvement in classification accuracy
# on the validation dataset (monitor=’val_acc’ and mode=’max’).
file_path = "weights-improvement-{epoch:04d}-{val_acc:.4f}.hdf5"
checkpoint = ModelCheckpoint(file_path,
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
callbacks_list = [checkpoint]
model.fit(x_train,
y_train,
batch_size=128,
epochs=100,
verbose=1,
callbacks=callbacks_list,
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])
model.save('final_model.h5')
def train(train_xy,
test_xy=None,
save_path=None,
input_shape=(224, 224, 3),
batch_size=128,
num_epochs=25,
lr=0.001,
fixed_low_level=False,
gender=False):
train_data, train_label = train_xy
print 'Training data histogram:', np.sum(train_label, axis=0)
if test_xy:
test_data, test_label = test_xy
print 'Test data histogram:', np.sum(test_label, axis=0)
num_classes = train_label.shape[1]
vgg_notop = VGGFace(include_top=False, input_shape=input_shape)
# We take the output of the last MaxPooling layer.
last_layer = vgg_notop.get_layer('pool5').output
x = Flatten(name='flatten')(last_layer)
# Put two fully-connected layers after it.
x = Dense(VGG_HIDDEN_DIM, activation='relu', name='fc6')(x)
x = Dense(VGG_HIDDEN_DIM, activation='relu', name='fc7')(x)
# Finally, a Dense layer for the output of classes.
face_probs = Dense(num_classes, name='fc8')(x)
model = Model(vgg_notop.input, face_probs)
if fixed_low_level:
# We make low-level layers untrainable.
for i in range(len(model.layers) - 3):
model.layers[i].trainable = False
# A softmax loss is used for training of this network.
def softmax(correct, predicted):
"""
The softmax loss function. For more than 2 one-hot encoded classes.
"""
return tf.nn.softmax_cross_entropy_with_logits(
labels=correct, logits=predicted)
print 'Learning rate: %f' % lr
model.compile(loss=softmax,
optimizer=SGD(lr=lr, decay=1e-6, momentum=0.9, nesterov=True),
metrics=['accuracy'])
# Training the model.
if test_xy:
# Training with validation data.
model.fit(train_data, train_label,
batch_size=batch_size,
validation_data=(test_data, test_label),
epochs=num_epochs,
shuffle=True)
else:
# We train one final time to save the model.
model.fit(train_data, train_label,
batch_size=batch_size,
epochs=num_epochs,
shuffle=True)
if save_path:
model.save(save_path)
else:
# We only return the validation accuracy.
return model.evaluate(test_data,
test_label,
batch_size=batch_size)
def train_label_none_label_classification(label_folder, non_label_folder, model_file=None):
c = Config()
# Build or load model
if model_file is None:
# create model
img_input = Input(shape=(28, 28, 3))
# prediction = model_cnn_2_layer.nn_classify_label_non_label(img_input)
# prediction = model_cnn_3_layer.nn_classify_label_non_label(img_input)
prediction = nn_cnn_3_layer.nn_classify_label_non_label(img_input)
model = Model(inputs=img_input, outputs=prediction)
model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy'])
else:
model = load_model(model_file)
model.summary()
# Load and normalize data
x_train, y_train, x_test, y_test = load_train_validation_data(label_folder, non_label_folder)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train[:, :, :, 0] -= c.img_channel_mean[0]
x_train[:, :, :, 1] -= c.img_channel_mean[1]
x_train[:, :, :, 2] -= c.img_channel_mean[2]
x_test[:, :, :, 0] -= c.img_channel_mean[0]
x_test[:, :, :, 1] -= c.img_channel_mean[1]
x_test[:, :, :, 2] -= c.img_channel_mean[2]
x_train /= 255
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# x_train.reshape(x_train.shape[0], 28, 28, 3)
# x_test.reshape(x_test.shape[0], 28, 28, 3)
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, 2)
y_test = keras.utils.to_categorical(y_test, 2)
# Checkpointing is to save the network weights only when there is an improvement in classification accuracy
# on the validation dataset (monitor=’val_acc’ and mode=’max’).
file_path = "weights-improvement-{epoch:04d}-{val_acc:.4f}.hdf5"
checkpoint = ModelCheckpoint(file_path, monitor='val_acc', verbose=1, save_best_only=True, mode='max')
callbacks_list = [checkpoint]
model.fit(x_train, y_train,
batch_size=128,
epochs=100,
verbose=1,
callbacks=callbacks_list,
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])
model.save('final_model.h5')
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
t = time.time()
hist = custom_resnet_model.fit(X_train,
y_train,
batch_size=batch_trainsize,
epochs=nb_epoch,
verbose=1,
validation_data=(X_test, y_test),
callbacks=[tb, checkpoint])
print('Training time: %s' % (time.time() - t))
(loss, accuracy) = custom_resnet_model.evaluate(X_test,
y_test,
batch_size=batch_testsize,
verbose=1)
print("[INFO] loss={:.4f}, accuracy: {:.4f}%".format(loss, accuracy * 100))
# serialize model to JSON
model_json = custom_resnet_model.to_json()
with open("./outputs/custom_resnet_model1.json", "w") as json_file:
json_file.write(model_json)
#Save model
custom_resnet_model.save('./trained_models/resnet50model1.h5')
print('model1 resaved.')
del custom_resnet_model #prevent memory leak
###########################################################################################################################
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.20, random_state=0)
y_train = keras.utils.to_categorical(y_train, 4)
y_test = keras.utils.to_categorical(y_test, 4)
resnet = VGGFace(model='resnet50',input_shape=(224, 224, 3))
layer_name = resnet.layers[-2].name
out = resnet.get_layer(layer_name).output
out = Dense(4,activation='softmax')(out)
resnet_4 = Model(resnet.input, out)
for layer in resnet_4.layers[:-1]:
layer.trainable = False
resnet_4.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print (resnet_4.summary())
resnet_4.fit(x_train, y_train,batch_size=16,epochs=5,validation_data=(x_test, y_test),shuffle=True)
scores = resnet_4.evaluate(x_test, y_test, verbose=1)
print('Test accuracy:', scores[1])
class RankNet(ObjectRanker, Tunable):
_tunable = None
_use_early_stopping = None
def __init__(self,
n_features,
n_hidden=2,
n_units=8,
loss_function=binary_crossentropy,
batch_normalization=True,
kernel_regularizer=l2(l=0.01),
non_linearities='relu',
optimizer="adam",
metrics=[top_k_categorical_accuracy, binary_accuracy],
use_early_stopping=False,
es_patience=300,
batch_size=256,
random_state=None,
**kwargs):
"""Create an instance of the RankNet architecture.
RankNet breaks the rankings into pairwise comparisons and learns a
latent utility model for the objects.
Parameters
----------
n_features : int
Number of features of the object space
n_hidden : int
Number of hidden layers used in the scoring network
n_units : int
Number of hidden units in each layer of the scoring network
loss_function : function or string
Loss function to be used for the binary decision task of the
pairwise comparisons
batch_normalization : bool
Whether to use batch normalization in each hidden layer
kernel_regularizer : function
Regularizer function applied to all the hidden weight matrices.
non_linearities : function or string
Type of activation function to use in each hidden layer
optimizer : function or string
Optimizer to use during stochastic gradient descent
metrics : list
List of metrics to evaluate during training (can be
non-differentiable)
use_early_stopping : bool
If True, stop the training early, if no progress has been made for
es_patience many iterations
es_patience : int
If early stopping is enabled, wait for this many iterations without
progress until stopping the training
batch_size : int
Batch size to use during training
random_state : int, RandomState instance or None
Seed of the pseudorandom generator or a RandomState instance
**kwargs
Keyword arguments for the algorithms
References
----------
.. [1] Burges, C. et al. (2005, August).
"Learning to rank using gradient descent.",
In Proceedings of the 22nd international conference on Machine
learning (pp. 89-96). ACM.
.. [2] Burges, C. J. (2010).
"From ranknet to lambdarank to lambdamart: An overview.",
Learning, 11(23-581), 81.
"""
self.logger = logging.getLogger("RankNet")
self.n_features = n_features
self.batch_normalization = batch_normalization
self.non_linearities = non_linearities
self.early_stopping = EarlyStoppingWithWeights(patience=es_patience)
self._use_early_stopping = use_early_stopping
self.metrics = metrics
self.kernel_regularizer = kernel_regularizer
self.loss_function = loss_function
self.optimizer = optimizers.get(optimizer)
self._construct_layers(n_hidden, n_units)
self.threshold_instances = THRESHOLD
self.batch_size = batch_size
self.random_state = check_random_state(random_state)
def _construct_layers(self, n_hidden=2, n_units=8, **kwargs):
self.x1 = Input(shape=(self.n_features, ))
self.x2 = Input(shape=(self.n_features, ))
self.output_node = Dense(1,
activation='sigmoid',
kernel_regularizer=self.kernel_regularizer)
self.output_layer_score = Dense(1, activation='linear')
if self.batch_normalization:
self.hidden_layers = [
NormalizedDense(n_units,
name="hidden_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities)
for x in range(n_hidden)
]
else:
self.hidden_layers = [
Dense(n_units,
name="hidden_{}".format(x),
kernel_regularizer=self.kernel_regularizer,
activation=self.non_linearities) for x in range(n_hidden)
]
assert len(self.hidden_layers) == n_hidden
def fit(self,
X,
Y,
epochs=10,
log_callbacks=None,
validation_split=0.1,
verbose=0,
**kwd):
self.logger.debug('Creating the Dataset')
garbage, X1, X2, garbage, Y_single = generate_complete_pairwise_dataset(
X, Y)
del garbage
if (X1.shape[0] > self.threshold_instances):
indicies = self.random_state.choice(X1.shape[0],
self.threshold_instances,
replace=False)
X1 = X1[indicies, :]
X2 = X2[indicies, :]
Y_single = Y_single[indicies]
self.logger.debug('Finished the Dataset')
self.logger.debug('Creating the model')
output = self.construct_model()
callbacks = []
if log_callbacks is None:
log_callbacks = []
callbacks.extend(log_callbacks)
callbacks = self.set_init_lr_callback(callbacks)
if self._use_early_stopping:
callbacks.append(self.early_stopping)
self.logger.info("Callbacks {}".format(', '.join(
[c.__name__ for c in callbacks])))
# Model with input as two objects and output as probability of x1>x2
self.model = Model(inputs=[self.x1, self.x2], outputs=output)
self.model.compile(loss=self.loss_function,
optimizer=self.optimizer,
metrics=self.metrics)
self.logger.debug('Finished Creating the model, now fitting started')
self.model.fit([X1, X2],
Y_single,
batch_size=self.batch_size,
epochs=epochs,
callbacks=callbacks,
validation_split=validation_split,
verbose=verbose,
**kwd)
self.scoring_model = self._create_scoring_model()
self.logger.debug('Fitting Complete')
def construct_model(self):
# weight sharing using same hidden layer for two objects
enc_x1 = self.hidden_layers[0](self.x1)
enc_x2 = self.hidden_layers[0](self.x2)
neg_x2 = Lambda(lambda x: -x)(enc_x2)
for hidden_layer in self.hidden_layers[1:]:
enc_x1 = hidden_layer(enc_x1)
neg_x2 = hidden_layer(neg_x2)
merged_inputs = add([enc_x1, neg_x2])
output = self.output_node(merged_inputs)
return output
def _create_scoring_model(self):
inp = Input(shape=(self.n_features, ))
x = inp
for hidden_layer in self.hidden_layers:
x = hidden_layer(x)
output_score = self.output_node(x)
model = Model(inputs=[inp], outputs=output_score)
return model
def predict(self, X, **kwargs):
return super().predict(X, **kwargs)
def _predict_scores_fixed(self, X, **kwargs):
# assert X1.shape[1] == self.n_features
n_instances, n_objects, n_features = X.shape
self.logger.info("For Test instances {} objects {} features {}".format(
n_instances, n_objects, n_features))
scores = []
for X1 in X:
score = self.scoring_model.predict(X1, **kwargs)
score = score.flatten()
scores.append(score)
scores = np.array(scores)
self.logger.info("Done predicting scores")
return scores
def predict_scores(self, X, **kwargs):
return super().predict_scores(X, **kwargs)
def predict_pair(self, X1, X2, **kwargs):
pairwise = np.empty(2)
pairwise[0] = self.model.predict([X1, X2], **kwargs)
pairwise[1] = self.model.predict([X2, X1], **kwargs)
return pairwise
def evaluate(self, X1_test, X2_test, Y_test, **kwargs):
return self.model.evaluate([X1_test, X2_test], Y_test, **kwargs)
@classmethod
def set_tunable_parameter_ranges(cls, param_ranges_dict):
logger = logging.getLogger('RankNet')
return tunable_parameters_ranges(cls, logger, param_ranges_dict)
def set_tunable_parameters(self, point):
named = Tunable.set_tunable_parameters(self, point)
hidden_layers_created = False
for name, param in named.items():
if name in [
N_HIDDEN_LAYERS, N_HIDDEN_UNITS, REGULARIZATION_FACTOR
]:
self.kernel_regularizer = l2(l=named[REGULARIZATION_FACTOR])
if not hidden_layers_created:
self._construct_layers(**named)
hidden_layers_created = True
elif name == LEARNING_RATE:
K.set_value(self.optimizer.lr, param)
elif name == EARLY_STOPPING_PATIENCE:
self.early_stopping.patience = param
elif name == BATCH_SIZE:
self.batch_size = param
else:
self.logger.warning(
'This ranking algorithm does not support a tunable parameter called {}'
.format(name))
@classmethod
def tunable_parameters(cls):
if cls._tunable is None:
cls._tunable = OrderedDict([
(N_HIDDEN_LAYERS, N_HIDDEN_LAYERS_DEFAULT_RANGES),
(N_HIDDEN_UNITS, N_UNITS_DEFAULT_RANGES),
(LEARNING_RATE, LR_DEFAULT_RANGE),
(REGULARIZATION_FACTOR, REGULARIZATION_FACTOR_DEFAULT_RANGE),
(BATCH_SIZE, BATCH_SIZE_DEFAULT_RANGE),
])
if cls._use_early_stopping:
cls._tunable[
EARLY_STOPPING_PATIENCE] = EARLY_STOPPING_PATIENCE_DEFAULT_RANGE
