def obj_det(image, yolo_model, anchors, class_names, sess, font, thickness,
bsc, input_image_shape, colors, output_size):
image_data = np.array(image, dtype='float32')
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
[boxes, scores, classes] = bsc
out_boxes, out_scores, out_classes = sess.run(
[boxes, scores, classes],
feed_dict={
yolo_model.input: image_data,
input_image_shape: [image.shape[1], image.shape[0]],
K.learning_phase(): 0
})
for i, c in reversed(list(enumerate(out_classes))):
# if (c != 0 and c != 1 and c != 2 and c != 3 and c != 5 and c != 7 and c!= 9 and c!= 11):
if (c != 1 and c != 5 and c != 6 and c != 13 and c != 14):
continue
predicted_class = class_names[c]
box = out_boxes[i]
score = out_scores[i]
label = '{} {:.2f}'.format(predicted_class, score)
imagex = Image.frombytes('RGB', (416, 416), image.tobytes())
image = imagex
draw = ImageDraw.Draw(image)
label_size = draw.textsize(label, font)
top, left, bottom, right = box
top = max(0, np.floor(top + 0.5).astype('int32'))
left = max(0, np.floor(left + 0.5).astype('int32'))
bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
# print(label, (left, top), (right, bottom))
if top - label_size[1] >= 0:
text_origin = np.array([left, top - label_size[1]])
else:
text_origin = np.array([left, top + 1])
# My kingdom for a good redistributable image drawing library.
for i in range(thickness):
draw.rectangle([left + i, top + i, right - i, bottom - i],
outline=colors[c])
draw.rectangle([tuple(text_origin),
tuple(text_origin + label_size)],
fill=colors[c])
draw.text(text_origin, label, fill=(0, 0, 0), font=font)
del draw
return cv2.resize(np.asarray(image),
output_size,
interpolation=cv2.INTER_CUBIC)
def get_logs(model, data, kdelayer, noiselayer, max_entropy_calc_N=None):
logs = {}
modelobj = model.model
inputs = modelobj.inputs + modelobj.targets + modelobj.sample_weights + [ K.learning_phase(),]
lossfunc = K.function(inputs, [modelobj.total_loss])
sampleweightstrn = np.ones(len(data.train.X))
sampleweightstst = np.ones(len(data.test.X))
noreglosstrn = lambda: lossfunc([data.train.X, data.train.Y, sampleweightstrn, 0])[0]
noreglosstst = lambda: lossfunc([data.test.X , data.test.Y , sampleweightstst, 0])[0]
if kdelayer is not None:
lv1 = K.get_value(kdelayer.logvar)
logs['kdeLV'] = lv1
print 'kdeLV=%.5f,' % lv1,
if noiselayer is not None:
lv2 = K.get_value(noiselayer.logvar)
logs['noiseLV'] = lv2
print 'noiseLV=%.5f' % lv2
if kdelayer is not None and noiselayer is not None:
if max_entropy_calc_N is None:
mitrn = data.train.X
mitst = data.test.X
else:
mitrn = randsample(data.train.X, max_entropy_calc_N)
mitst = randsample(data.test.X, max_entropy_calc_N)
mi_obj_trn = MIComputer(noiselayer.get_noise_input_func(mitrn), kdelayer=kdelayer, noiselayer=noiselayer)
mi_obj_tst = MIComputer(noiselayer.get_noise_input_func(mitst), kdelayer=kdelayer, noiselayer=noiselayer)
if True:
mivals_trn = map(lambda x: float(K.eval(x)), [mi_obj_trn.get_mi(), mi_obj_trn.get_h(), mi_obj_trn.get_hcond()]) # [data.train.X,]))
logs['mi_trn'] = mivals_trn[0]
mivals_tst = map(lambda x: float(K.eval(x)), [mi_obj_tst.get_mi(), mi_obj_tst.get_h(), mi_obj_tst.get_hcond()]) # [data.train.X,]))
logs['mi_tst'] = mivals_tst[0]
logs['kl_trn'] = noreglosstrn()
logs['kl_tst'] = noreglosstst()
print ', mitrn=%s, mitst=%s, kltrn=%.3f, kltst=%.3f' % (mivals_trn, mivals_tst, logs['kl_trn'], logs['kl_tst'])
else:
print
return logs
#logs['tstloss'] = self.totalloss([self.xX_test,0])
def extractFeatures(X, model):
"""
Extract the features of X using the activation layer of the model
Inputs:
- X: data sample to extract features for
- model: model to use to get the features
Returns: the np array of features (output from the last layer of the model)
"""
# https://keras.io/getting-started/faq/#how-can-i-visualize-the-output-of-an-intermediate-layer
# https://github.com/fchollet/keras/issues/1641
# extract layer
get_last_layer_output = K.function(
[model.layers[0].input, K.learning_phase()], [model.layers[-4].output])
layer_output = get_last_layer_output([X, 0])[0]
return layer_output
def extractLearnedFeatures(model, newData):
"""
Using the previously trained model, extract a learned set of features for the new
data from the second to last layer of the model.
Inputs:
- model: the trained model
- newData: the new data to extract features from
Returns:
- learnedFeats: features extracted from the model
"""
# https://keras.io/getting-started/faq/#how-can-i-visualize-the-output-of-an-intermediate-layer
# https://github.com/fchollet/keras/issues/1641
# extract layer
get_last_layer_output = K.function(
[model.layers[0].input, K.learning_phase()], [model.layers[-4].output])
learnedFeats = get_last_layer_output([newData, 0])[0]
return learnedFeats
def on_train_begin(self, logs={}):
modelobj = self.model.model
inputs = modelobj.inputs + modelobj.targets + modelobj.sample_weights + [ K.learning_phase(),]
lossfunc = K.function(inputs, [modelobj.total_loss])
jacfunc = K.function(inputs, K.gradients(modelobj.total_loss, self.noiselayer.logvar))
sampleweights = np.ones(len(self.traindata.X))
def obj(logvar):
v = K.get_value(self.noiselayer.logvar)
K.set_value(self.noiselayer.logvar, logvar.flat[0])
r = lossfunc([self.traindata.X, self.traindata.Y, sampleweights, 1])[0]
K.set_value(self.noiselayer.logvar, v)
return r
def jac(logvar):
v = K.get_value(self.noiselayer.logvar)
K.set_value(self.noiselayer.logvar, logvar.flat[0])
r = np.atleast_2d(np.array(jacfunc([self.traindata.X, self.traindata.Y, sampleweights, 1])))[0]
K.set_value(self.noiselayer.logvar, v)
return r
self.obj = obj # lambda logvar: lossfunc([self.traindata.X_train, self.traindata.Y_train, self.sampleweights, logvar[0], 1])[0]
self.jac = jac # lambda logvar: np.array(jacfunc([self.traindata.X_train, self.traindata.Y_train, self.sampleweights, logvar[0], 1]))
def generateTest():
words_to_generate = 30
testSeed = np.random.randint(low=1,
high=(len(data2) - words_to_read),
size=1)
testSeed = int(testSeed)
tx = []
for t in range(testSeed, testSeed + words_to_read, 1):
tx.append(int2word[data2[t]])
actualY = data2[testSeed + words_to_read]
actualY = one_hot(int(actualY))
actualY = np.reshape(actualY, (1, vocab_size))
# tx = ["came", "back", "from", "those", "strange", "streets","\n","any","day","of","those","lame","dreams","\n","move","with","the","same","speed","\n"]
print(tx)
for i in range(len(tx)):
try:
tx[i] = word2int[tx[i]]
except:
tx[i] = word2int['UNK']
# tx = [word2int[tx_i] for tx_i in tx]
tx = [embeddings[tx_i] for tx_i in tx]
for j in range(words_to_generate):
tx = np.reshape(tx, (1, words_to_read, embedding_size))
if (j == 0):
print(
"loss : ",
sess.run([loss],
feed_dict={
X: tx,
Y: actualY,
K.learning_phase(): 0
}))
predictedWord = model.predict(tx)
'''
predictedWord = closestEmbedding(predictedWord)
predictedWord2 = embeddings[predictedWord]
predictedWord2 = np.reshape(predictedWord2,[1,embedding_size])
'''
predictedWord = np.asarray(predictedWord).astype('float64')
predictedWord = np.reshape(predictedWord, (vocab_size))
# temperate
# temperature = 0.6
# predictedWord = np.log(predictedWord) / temperature
# pw = np.exp(predictedWord)
# predictedWord = pw / np.sum(pw)
# pm = np.random.multinomial(1, predictedWord, 1)
# pm = np.reshape(pm,(vocab_size))
pm = predictedWord # either this or temp
pw = np.exp(pm)
pm = pw / np.sum(pw)
predictedWord = np.argmax(pm)
#
# to not get UNK as prediction
if (predictedWord == 0):
predictedWord = np.argsort(pm)[-2]
#
predictedWord2 = one_hot(predictedWord)
predictedWord2 = np.reshape(predictedWord2, (1, vocab_size))
tx = np.reshape(tx, (words_to_read, embedding_size))
e = embeddings[predictedWord]
e = np.reshape(e, (1, embedding_size))
tx = np.append(tx, e, axis=0)
tx = tx[1:]
print(int2word[predictedWord], ' ', end='')
# tx = np.reshape(tx,(1,words_to_read,embedding_size))
# print (len(data2)) # - 106989 ...106932 106983
batch_size = int(len(data2) / 213)
with sess.as_default():
sess.run(tf.global_variables_initializer())
for epoch in range(1, 51):
print("\n\n Epoch ", epoch, "/500")
for i in range(0, (len(data2) - words_to_read) - batch_size,
batch_size):
x = np.array([])
y = np.array([])
for j in range(i, i + batch_size, 1):
# print ('error at ?',i,j)
x_, y_ = newXY(j)
x = np.append(x, x_)
y = np.append(y, y_)
# X = tf.reshape(X,[1,words_to_read,embedding_size])
x = np.reshape(x, (batch_size, words_to_read, embedding_size))
y = np.reshape(y, (batch_size, vocab_size))
train_step.run(feed_dict={X: x, Y: y, K.learning_phase(): 1})
# model.fit(x, y, batch_size=batch_size)
# if (i%1000==0):
# test model
generateTest()
model.save_weights("rapWeights.h5")
print("Training Finished..........")
def train(epoch_num=None, name=MODEL_NAME):
input_tensor = Input(name='the_input',
shape=(width, height, 3),
dtype='float32') #Input((width, height, 1))
x = input_tensor
for i in range(2):
# x = Conv2D(filters=2 ** (3+i), kernel_size=(3, 3), padding="same", activation='relu', kernel_initializer='he_normal')(x)
x = Conv2D(filters=16 * (i + 1),
kernel_size=(3, 3),
padding="same",
activation='relu',
kernel_initializer='he_normal')(x)
x = Conv2D(filters=16 * (i + 1),
kernel_size=(3, 3),
padding="same",
activation='relu',
kernel_initializer='he_normal')(x)
# x = Conv2D(filters=32, kernel_size=(3, 3), activation='relu')(x)
x = MaxPool2D(pool_size=(2, 2))(x)
conv_shape = x.get_shape()
# conv_to_rnn_dims = (width // (2 ** 3),
# (height // (2 ** 3)) * 32)
x = Reshape(target_shape=(int(conv_shape[1]),
int(conv_shape[2] * conv_shape[3])))(x)
x = Dense(dense_size, activation='relu')(x)
# (batch_size, 20, 8 )
gru_1 = GRU(rnn_size,
return_sequences=True,
kernel_initializer='he_normal',
name='gru1')(x)
gru_1b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='gru1_b')(x)
gru1_merged = Add()([gru_1, gru_1b]) #sum
gru_2 = GRU(rnn_size,
return_sequences=True,
kernel_initializer='he_normal',
name='gru2')(gru1_merged)
gru_2b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='gru2_b')(gru1_merged)
gru_2 = TimeDistributed(BatchNormalization())(gru_2)
gru_2b = TimeDistributed(BatchNormalization())(gru_2b)
x = Concatenate()([gru_2, gru_2b]) #concat
# x = Dropout(0.25)(x)
"""
最后结果是[batch_size, 最大时间序列, 分类总数+1位空白符+1位CTC校验位]，使用softmax函数，将所有结果的概率分布在（0，1）之间，激活用在每一帧时间序列上，求最大概率的分类，得出该帧的预测结果。
因此，此处dense层设置 分类总数的数量为结果，并采用softmax多分类激活函数
"""
x = Dense(n_class, kernel_initializer='he_normal', activation='softmax')(x)
# Model(inputs=input_tensor, outputs=x).summary()
# base_model = Model(inputs=input_tensor, outputs=x)
# 评估回调函数
evaluator_func = K.function([input_tensor, K.learning_phase()], [x])
# evaluator_func.
# base_model.summary()
evaluator = Evaluate(validation_func=evaluator_func,
val_seq=val_obj,
name="keras_cnn_gru_add_batch")
labels = Input(name='the_labels', shape=[n_len], dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
loss_out = Lambda(ctc_lambda_func, output_shape=(1, ),
name='ctc')([x, labels, input_length, label_length])
model = Model(inputs=[input_tensor, labels, input_length, label_length],
outputs=[loss_out]) #.summary()
model.summary()
model.compile(loss={
'ctc': lambda y_true, y_pred: y_pred
},
optimizer='adadelta')
if epoch_num is not None:
weight_file = os.path.join(
OUTPUT_DIR, os.path.join(name, 'epoch_%02d.h5' % (epoch_num)))
model.load_weights(weight_file)
# print(base_model == model)
# model.fit_generator(train_gen.gen_batch(n_len, 200), steps_per_epoch=100, epochs=100, max_queue_size=1, workers=1, callbacks=[evaluator])
# model.fit_generator(image_gen.next_val(), steps_per_epoch=1, epochs=100, max_queue_size=1, workers=1, callbacks=[evaluator]) #单线程,易调试
model.fit_generator(image_gen,
steps_per_epoch=200,
epochs=100,
callbacks=[evaluator],
use_multiprocessing=True,
workers=2) #多线程
def get_activations(model, layer, X_batch):
get_activations = K.function([model.layers[0].input, K.learning_phase()], [model.layers[layer].output,])
activations = get_activations([X_batch,0])
return activations
model.add(Dense(512, input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(10))
model.add(Activation('softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
history = model.fit(X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
verbose=1,
validation_data=(X_test, Y_test))
score = model.evaluate(X_test, Y_test, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])
# TESTING
get_last_layer_output = K.function(
[model.layers[0].input, K.learning_phase()], [model.layers[-2].output])
layer_output = get_last_layer_output([X_test, 0])[0]
output2 = get_last_layer_output([X_test, 0])
def evaluate_activations(model, X, layer):
from keras.layers.core import K
get_layer_output = K.function(
[model.layers[0].input, K.learning_phase()],
[model.layers[layer].output])
return get_layer_output([X, 0])[0]
