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]