def LoadModel(where, hyper):
"""Loads a pre-trained model with n curves located at weights = path/to/weights.hdf5"""
sess = Session()
with sess.as_default():
with sess.graph.as_default():
Ss = hyper[0, :]
ks = hyper[3, :]
As = hyper[4, :]
freezeS = hyper[5, :]
model = create_model(ks, As, Ss, freezeS)
prms = [
model.layers[1].A, model.layers[1].k, model.layers[1].s,
model.layers[1].B
]
model.compile(optimizer=Adam(), loss='mse')
model.load_weights(where)
#Extract optimized weights into a dictionary
BroutePrms = model.layers[1].get_weights()
prms = ExtractParams(BroutePrms, freezeS)
return prms
def detect_face(self, Img, image_size):
minsize = 20
threshold = [0.6, 0.7, 0.7]
factor = 0.709
margin = 44
gpu_memory_fraction = 1.0
print('Creating networks and loading parameters')
with tf.Graph().as_default():
gpu_options = GPUOptions(
per_process_gpu_memory_fraction=gpu_memory_fraction)
sess = Session(config=ConfigProto(gpu_options=gpu_options,
log_device_placement=False))
with sess.as_default():
dir_model = "./align"
pnet, rnet, onet = align.detect_face.create_mtcnn(
sess, dir_model)
Img_size = np.asarray(Img.shape)[0:2]
bounding_boxes, _ = align.detect_face.detect_face(
Img, minsize, pnet, rnet, onet, threshold, factor)
faces = np.zeros(
(len(bounding_boxes), image_size, image_size, 3),
dtype="uint8")
bb = np.zeros((len(bounding_boxes), 4), dtype=np.int32)
for i in range(len(bounding_boxes)):
det = np.squeeze(bounding_boxes[i, 0:4])
bb[i, 0] = np.maximum(det[0] - margin / 2, 0)
bb[i, 1] = np.maximum(det[1] - margin / 2, 0)
bb[i, 2] = np.minimum(det[2] + margin / 2, Img_size[1])
bb[i, 3] = np.minimum(det[3] + margin / 2, Img_size[0])
cropped = Img[bb[i, 1]:bb[i, 3], bb[i, 0]:bb[i, 2], :]
img_cropped = Image.fromarray(cropped)
img_aligned = img_cropped.resize((image_size, image_size),
Image.BILINEAR)
aligned_arr = np.asarray(img_aligned)
faces[i, :, :, :] = cv2.cvtColor(aligned_arr,
cv2.COLOR_BGR2RGB)
return faces, bb
class face_utils_cls():
def __init__(self):
'''
dlib库对应的关键点模型
'''
# import pdb
# pdb.set_trace()
self.path = './face_models'
# self.face_landmark_dlib = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')
# self.face_detector_dlib = dlib.get_frontal_face_detector()
#set sess
'''如果使用gpu，按需分配'''
gpu_options = GPUOptions(allow_growth=True)
session_config = ConfigProto(allow_soft_placement=True,
log_device_placement=False,
gpu_options=gpu_options)
'''
初始化人脸特征模型, 人脸检测模型，人脸关键点模型
'''
self.face_feature_sess = Session(graph=tf.Graph(), config=session_config)
self.face_detection_sess = Session(graph=tf.Graph(), config=session_config)
self.face_landmark_sess = Session(graph=tf.Graph(), config=session_config)
self.face_attribute_sess = Session(graph=tf.Graph(), config=session_config)
self.ff_pb_path = self.path + "/face_recognition_model.pb"
self.init_feature_face()
self.detect_pb_path = self.path + "/face_detection_model.pb"
self.init_detection_face_tf()
self.landmark_pb_path = self.path + "/landmark.pb"
self.init_face_landmark_tf()
self.attribute_pb_path = self.path + "/face_attribute.pb"
self.init_face_attribute()
def init_feature_face(self):
with self.face_feature_sess.as_default():
with self.face_feature_sess.graph.as_default():
with GFile(self.ff_pb_path, 'rb') as f:
graph_def = self.face_feature_sess.graph_def
graph_def.ParseFromString(f.read())
tf.import_graph_def(graph_def, name='')
self.ff_images_placeholder = get_default_graph().get_tensor_by_name("input:0")
self.ff_train_placeholder = get_default_graph().get_tensor_by_name("phase_train:0")
self.ff_embeddings = get_default_graph().get_tensor_by_name("embeddings:0")
def init_detection_face_tf(self):
with self.face_detection_sess.as_default():
with self.face_detection_sess.graph.as_default():
face_detect_od_graph_def = self.face_detection_sess.graph_def
with GFile(self.detect_pb_path, 'rb') as fid:
serialized_graph = fid.read()
face_detect_od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(face_detect_od_graph_def, name='')
ops = get_default_graph().get_operations()
all_tensor_names = {output.name for op in ops for output in op.outputs}
self.detection_tensor_dict = {}
for key in ['num_detections', 'detection_boxes', 'detection_scores','detection_classes']:
tensor_name = key + ':0'
if tensor_name in all_tensor_names:
self.detection_tensor_dict[key] = get_default_graph().get_tensor_by_name(
tensor_name)
self.detection_image_tensor = get_default_graph().get_tensor_by_name('image_tensor:0')
def init_face_landmark_tf(self):
with self.face_landmark_sess.as_default():
with self.face_landmark_sess.graph.as_default():
graph_def = self.face_landmark_sess.graph_def
with GFile(self.landmark_pb_path, 'rb') as fid:
serialized_graph = fid.read()
graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(graph_def, name='')
self.face_landmark_tensor = get_default_graph(). \
get_tensor_by_name("fully_connected_9/Relu:0")
def init_face_attribute(self):
with self.face_attribute_sess.as_default():
with self.face_attribute_sess.graph.as_default():
graph_def = self.face_attribute_sess.graph_def
with GFile(self.attribute_pb_path, 'rb') as fid:
serialized_graph = fid.read()
graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(graph_def, name='')
self.pred_eyeglasses = get_default_graph().get_tensor_by_name("ArgMax:0")
self.pred_young = get_default_graph().get_tensor_by_name("ArgMax_1:0")
self.pred_male = get_default_graph().get_tensor_by_name("ArgMax_2:0")
self.pred_smiling = get_default_graph().get_tensor_by_name("ArgMax_3:0")
self.face_attribute_image_tensor = get_default_graph().get_tensor_by_name("Placeholder:0")
def detection_face_by_dlib(self, im_data):
##调用dlib
pass
sp = im_data.shape
im_data = cv2.cvtColor(im_data, cv2.COLOR_BGR2GRAY)
rects = self.face_detector_dlib(im_data, 1)
if len(rects) == 0:
return None, None, None, None
# 只取第一个人脸
x1 = rects[0].left() * 1.0 / sp[1]
y1 = rects[0].top() * 1.0 / sp[0]
x2 = rects[0].right() * 1.0 / sp[1]
y2 = rects[0].bottom() * 1.0 / sp[0]
'''
#调整人脸区域
'''
y1 = int(max(y1 - 0.3 * (y2 - y1), 0))
return x1, y1, x2, y2
def detection_face_by_tf(self, im_data):
im_data_re = cv2.resize(im_data, (256, 256))
output_dict = self.face_detection_sess.run(self.detection_tensor_dict,
feed_dict={self.detection_image_tensor:
np.expand_dims(
im_data_re, 0)})
# all outputs are float32 numpy arrays, so convert types as appropriate
output_dict['num_detections'] = int(output_dict['num_detections'][0])
output_dict['detection_classes'] = output_dict[
'detection_classes'][0].astype(np.uint8)
output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
output_dict['detection_scores'] = output_dict['detection_scores'][0]
for i in range(len(output_dict['detection_scores'])):
if output_dict['detection_scores'][i] > 0.1:
bbox = output_dict['detection_boxes'][i]
y1 = bbox[0]
x1 = bbox[1]
y2 = bbox[2]
x2 = bbox[3]
return x1, y1, x2, y2
return None, None, None, None
# 图像数据标准化
def prewhiten(self, x):
mean = np.mean(x)
std = np.std(x)
std_adj = np.maximum(std, 1.0/np.sqrt(x.size))
y = np.multiply(np.subtract(x, mean), 1/std_adj)
return y
def face_feature(self, face_data):
im_data = self.prewhiten(face_data) # 预处理
im_data = cv2.resize(im_data, (160, 160))
im_data1 = np.expand_dims(im_data, axis=0)
##人脸特征提取
emb1 = self.face_feature_sess.run(self.ff_embeddings,
feed_dict={self.ff_images_placeholder: im_data1,
self.ff_train_placeholder: False})
return emb1
def face_landmark_tf(self, face_data):
print("begin ... landmark")
pred = self.face_landmark_sess.run(self.face_landmark_tensor, {"Placeholder:0":
np.expand_dims(face_data, 0)})
print("success ... landmark")
pred = pred[0]
#cv2.imwrite("0_landmark.jpg", face_data)
return pred
def face_attribute(self, im_data):
[eye_glass, young, male, smiling] = self.face_attribute_sess.run(
[self.pred_eyeglasses, self.pred_young, self.pred_male, self.pred_smiling],
feed_dict={self.face_attribute_image_tensor: np.expand_dims(im_data, 0)})
return eye_glass, young, male, smiling
def load_fea_from_str(self, fea_path):
with open(fea_path) as f:
fea_str = f.readlines()
f.close()
emb2_str = fea_str[0].split(",")
emb2 = []
for ss in emb2_str:
emb2.append(float(ss))
emb2 = np.array(emb2)
return emb2
def Optimize(df,
hyper,
peak,
lr=5e-2,
epochs=100,
v=1,
weights=0,
where='/tmp/W.hdf5'):
"""df: training data
hyper: Matrix with hyperparameters. Contains, as rows: Ss,dev,posit,ks,As,freezeS
Ss: x point around which curves are to be centered
dev: allowed deviation for the center of the curves with respect to Ss
posit: slope of the curve: slope==1 -> positive slope, slope==0 -> negative slope
ks: Suggested k values (steepness of curve)
As: Suggested A values (relative importance of event, by how much did mass increment with this event?)
freezeS: Which S values are to be fixed
lr: learning rate
epochs: number of epochs
v: verbosity of output while training
weights: load pre-trained parameters to restart optimization from there
where: /path/to/file where model is to be stored. Default is /tmp/W.hdf5"""
sess = Session()
with sess.as_default():
with sess.graph.as_default():
Ss = hyper[0, :]
ks = hyper[3, :]
As = hyper[4, :]
freezeS = hyper[5, :]
model = create_model(ks, As, Ss, freezeS)
prms = [
model.layers[1].A, model.layers[1].k, model.layers[1].s,
model.layers[1].B
]
model.compile(loss=CostFunction(prms, hyper, peak=peak),
optimizer=Adam(lr))
if weights: #Load weights if available
model.load_weights(weights)
#Callbacks
rlr = callbacks.ReduceLROnPlateau(monitor='loss',
factor=0.5,
patience=10,
min_delta=0.004,
min_lr=2.0e-7,
mode='min',
verbose=v)
ton = EndOnNaN()
chk = callbacks.ModelCheckpoint(where,
monitor='loss',
save_best_only=True,
mode='min',
period=1)
earlyStp = callbacks.EarlyStopping(monitor='loss',
min_delta=0.00003,
patience=25,
verbose=1,
mode='min')
hist = model.fit(df.x,
df.y,
epochs=epochs,
batch_size=128,
verbose=v,
callbacks=[rlr, ton, chk, earlyStp])
model.load_weights(where) #Load weights (best of all epochs)
#Extract optimized weights into a dictionary
BroutePrms = model.layers[1].get_weights()
prms = ExtractParams(BroutePrms, freezeS)
return prms, min(hist.history['loss'])
from django.shortcuts import render,redirect
from django.shortcuts import get_object_or_404
from django.core.files.storage import FileSystemStorage
import numpy as np
import os
from keras.preprocessing import image
from keras.models import load_model
from tensorflow.compat.v1 import Session
from tensorflow import Graph
model_graph = Graph()
with model_graph.as_default():
tf_session = Session()
with tf_session.as_default():
# model = load_model("classify/first_one.h5")
# Please use the below link to download model from drive because it is of large size so
# i cannot use it here.
model = "https://drive.google.com/file/d/1uoa7_WWQXaahpnAB6JbqNZV6Kr9RKm2Z/view?usp=sharing"
IMG_WIDTH = 224
IMG_HEIGHT = 224
labels = {0: "Corn Gray leaf spot",
1: "Common rust Corn Maize",
2: "Northern Leaf Blight Corn Maize",
3: "Healthy Maize Corn",
4: "Early blight Potato leaf",