def _dojob(ready, e, queue):
prctl.set_name('AI detector - do job')
global session1, session2, ip_model, mac_model
ip_graph = Graph()
config = ConfigProto()
config.gpu_options.allow_growth = True
with ip_graph.as_default():
session1 = Session(config=config)
with session1.as_default():
ip_model = K.models.load_model(
'gru_ip_4tuple.hdf5', custom_objects={'attention': attention})
ip_model._make_predict_function()
mac_graph = Graph()
with mac_graph.as_default():
session2 = Session(config=config)
with session2.as_default():
mac_model = K.models.load_model(
'gru_mac_4tuple.hdf5', custom_objects={'attention': attention})
mac_model._make_predict_function()
ready.set()
print 'set ready'
last = time.time()
global ignore_packet
while e.is_set() == False:
if queue.empty() == False:
obj = queue.get()
if (obj[0], obj[1]) in ignore_packet:
if obj[3] <= ignore_packet[(obj[0], obj[1])]:
continue
feature_extract((obj[2], obj[3]))
if time.time() - last >= polling_interval:
print queue.qsize()
global flow_statics, src_addr_list, memory_data
# calculate features in last 5 seconds
result = calculate_feature(flow_statics)
memory_data.pop(0)
memory_data.append(result)
t_run_exp = threading.Thread(target=_run_exp,
args=(
result,
src_addr_list,
memory_data,
))
t_run_exp.start()
t_run_exp.join()
flow_statics = {}
src_addr_list = {}
last = time.time()
K.backend.clear_session()
del ip_model
del mac_model
def facial_Emotion(filepath):
imgName = (filepath)
img = Image.open(imgName).convert('L')
pixels = list(img.getdata())
# 픽셀 값 reshape
reshapeImgPixels = np.zeros((1, 48 * 48))
for i in range(48 * 48):
reshapeImgPixels[0, i] = int(pixels[i])
img = reshapeImgPixels
img = img / 255
img = img.reshape((img.shape[0], 1, 48, 48))
thread_graph = Graph()
with thread_graph.as_default():
thread_session = Session()
with thread_session.as_default():
model = load_model('./testModel/detectEmotionModel_epoch10.h5')
global graph
graph = tf.get_default_graph()
with graph.as_default():
with thread_session.as_default():
global result
result = model.predict(img)
#result = model.predict(img)
max = 0
maxIdx = 0
for i in range(0, 4):
if result[0][i] > max:
max = result[0][i]
maxIdx = i
if maxIdx == 0:
emotion = 'Angry'
elif maxIdx == 1:
emotion = 'Happy'
elif maxIdx == 2:
emotion = 'Sad'
elif maxIdx == 3:
emotion = 'neutral'
return emotion
def _dojob(e, queue):
prctl.set_name('AI detector - do job')
global session1, session2, ip_model, mac_model
ip_graph = Graph()
with ip_graph.as_default():
session1 = Session()
with session1.as_default():
ip_model = K.models.load_model(ip_model_path)
ip_model._make_predict_function()
mac_graph = Graph()
with mac_graph.as_default():
session2 = Session()
with session2.as_default():
mac_model = K.models.load_model(mac_model_path)
mac_model._make_predict_function()
#pcap_file = open('test.pcap', 'wb')
#writer = dpkt.pcap.Writer(pcap_file)
global total_tp, total_tn, total_fp, total_fn
total_tp = 0
total_tn = 0
total_fp = 0
total_fn = 0
last = time.time()
#count_lock = threading.Lock()
while e.is_set() == False:
if queue.empty() == False:
obj = queue.get()
feature_extract(obj)
current = obj[1]
else:
current = time.time()
if current - last >= polling_interval:
global flow_statics, src_addr_list, attacker
#calculate features in last 5 seconds
result = calculate_feature(flow_statics)
memory_data.pop(0)
memory_data.append(result)
#t_run_exp = threading.Thread(target=_run_exp, args=(flow_statics, src_addr_list, attacker, memory_data, count_lock, ))
t_run_exp = threading.Thread(target=_run_exp, args=(flow_statics, src_addr_list, attacker, memory_data, ))
t_run_exp.start()
t_run_exp.join()
flow_statics = {}
src_addr_list = []
attacker = []
last = current
K.backend.clear_session()
del ip_model
del mac_model
class DetectFace:
def __init__(self):
self.graph = Graph()
with self.graph.as_default():
self.session = Session(graph=self.graph)
with self.session.as_default():
self.detector = MTCNN()
def processe(self, args):
faces = []
image = args
k.set_session(self.session)
with self.graph.as_default():
results = self.detector.detect_faces(image)
for res in results:
x1, y1, width, height = res['box']
x1, y1 = abs(x1), abs(y1)
x2, y2 = x1 + width, y1 + height
face = image[y1:y2, x1:x2]
faces.append(face)
return faces
def loadKerasModel(self, filePath):
global PMMLMODELSTORAGE
fO = pathlib.Path(filePath)
keyToModel = fO.name.replace(fO.suffix, '')
# print (PMMLMODELSTORAGE)
try:
model_graph = Graph()
with model_graph.as_default():
tf_session = Session()
with tf_session.as_default():
seqModel = load_model(filePath)
tempDictModel = {
'modelObj': seqModel,
'model_graph': model_graph,
'modelGeneratedFrom': 'Keras',
'tf_session': tf_session,
'inputShape': seqModel.input_shape,
}
PMMLMODELSTORAGE[keyToModel] = tempDictModel
messageToWorld = "Model Loaded Successfully"
reStat = 200
except:
messageToWorld = "Model load failed, please connect with admin"
keyToModel = None
reStat = 500
resultResp = {'message': messageToWorld, 'keytoModel': keyToModel}
return JsonResponse(resultResp, status=reStat)
def load_KerasGraph(path):
print("> ====== loading Keras model for classification")
thread_graph = Graph()
with thread_graph.as_default():
thread_session = Session()
with thread_session.as_default():
input_shape = (28, 28, 1)
num_classes = 6
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), input_shape=input_shape))
model.add(ReLU())
model.add(Conv2D(32, kernel_size=(3, 3)))
model.add(ReLU())
model.add(Conv2D(32, kernel_size=(3, 3)))
model.add(ReLU())
model.add(Conv2D(32, kernel_size=(3, 3)))
model.add(ReLU())
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(ReLU())
model.add(Dropout(0.5))
model.add(Dense(num_classes))
model.add(Softmax())
model.load_weights(path)
graph = tf.get_default_graph()
print("> ====== Keras model loaded")
return model, graph, thread_session
def save(self, sess: tf.Session, folder: str, step: int):
p = os.path.join(folder, f"full-model-{step:05}.save")
self.forward_model.save(p, overwrite=True, include_optimizer=False)
config = tf.ConfigProto(allow_soft_placement=True)
config.gpu_options.allow_growth = True
with tf.Graph().as_default(), tf.Session(
config=config) as sess, sess.as_default():
model = models.load_model(p,
custom_objects=custom_layers,
compile=False)
with tf.name_scope("export"):
x = tf.placeholder(tf.float32, shape=(None, None, 1))
y = model(x)
model.load_weights(p)
model_input = tf.saved_model.utils.build_tensor_info(x)
model_output = tf.saved_model.utils.build_tensor_info(y)
signature_definition = tf.saved_model.signature_def_utils.build_signature_def(
inputs={"x": model_input},
outputs={"y": model_output},
method_name=tf.saved_model.signature_constants.
PREDICT_METHOD_NAME)
export_path = os.path.join(folder, "saver", "1")
builder = tf.saved_model.builder.SavedModelBuilder(export_path)
builder.add_meta_graph_and_variables(
sess,
[tf.saved_model.tag_constants.SERVING],
signature_def_map={
"mincall": signature_definition,
},
)
builder.save()
def rsna_evaluate(model_path, backbone, anchor_boxes, score_threshold,
nms_threshold, rsna_path, rsna_test_json, anchor_scales):
""" Evaluate an json using retinanet model, print mAP based on GT and generate kaggle submission file.
"""
save_path = None
from tensorflow import Graph, Session
graph1 = Graph()
with graph1.as_default():
session1 = Session()
with session1.as_default():
model2 = models.load_model(model_path,
backbone_name=backbone,
convert=True,
nms_threshold=nms_threshold,
anchors_ratios=anchor_boxes,
anchors_scales=anchor_scales)
# create the generator
generator = create_generator(rsna_test_json, rsna_path)
map = evaluate(generator,
model2,
iou_threshold=0.5,
score_threshold=score_threshold,
max_detections=100,
generate_kaggle_output='teste.csv')
del model2
import gc
gc.collect()
with open('output_map.txt', 'a') as output_map:
output_map.write('{} : {} \n'.format(model_path, map))
def _predict(cls, user_ids: List, item_ids: List, with_user_embedding,
graph: GraphConvolutionalMatrixCompletionGraph,
dataset: GcmcGraphDataset, session: tf.Session) -> np.ndarray:
if graph is None:
RuntimeError('Please call fit first.')
rating_adjacency_matrix = dataset.train_rating_adjacency_matrix()
user_indices, item_indices = dataset.to_indices(user_ids, item_ids)
if not with_user_embedding:
user_indices = np.array(
[0] * len(user_indices)) # TODO use default user index.
user_feature_indices, item_feature_indices = dataset.to_feature_indices(
user_ids, item_ids)
input_data = dict(user=user_indices,
item=item_indices,
user_feature_indices=user_feature_indices,
item_feature_indices=item_feature_indices)
feed_dict = cls._feed_dict(input_data,
graph,
dataset,
rating_adjacency_matrix,
is_train=False)
with session.as_default():
predictions = session.run(graph.expectation, feed_dict=feed_dict)
predictions = predictions.flatten()
predictions = np.clip(predictions,
dataset.rating()[0],
dataset.rating()[-1])
return predictions
def load():
global session
global graph
global model
global data_result
data_result = DataResult(None, None)
with open(script_dir + '/../temp/processed_data.json', 'r') as output:
json_data = json.load(output)
data_result.loadJSON(json_data)
graph = Graph()
with graph.as_default():
session = Session(graph=graph)
with session.as_default():
temp_encoder = Encoder(data_result.input_data)
temp_decoder = Decoder(data_result.output_data, temp_encoder)
temp_model = Model([temp_encoder.inputs, temp_decoder.inputs],
temp_decoder.outputs)
temp_model.compile(optimizer='rmsprop',
loss='categorical_crossentropy')
temp_model.load_weights(
os.path.dirname(__file__) + '/../model_weights.h5')
model = temp_model
def loadModels(self, path):
"""Load models from the json file given."""
logger.info('Loading models from %s', path)
self.data_location = None
self.models = []
if path == self.data_location:
return
if not os.path.exists(path):
logger.error('Could not find file: %s', path)
self.data_location = path
with open(path, 'r') as f:
data = json.load(f)
if 'models' not in data:
logger.error('No models defined in data')
return
models = data['models']
for i, model in enumerate(models):
if not model:
self.models.append(None)
continue
vertices = data['joint_map'][i]
graph = Graph()
with graph.as_default():
session = Session()
with session.as_default():
meta = model.get('meta')
root = model.get('root')
saver = tf.train.import_meta_graph(meta)
saver.restore(session, tf.train.latest_checkpoint(root))
in_tensor = session.graph.get_tensor_by_name(
model['input'])
out_tensor = session.graph.get_tensor_by_name(
model['output'])
normalized = model['normalized']
verts_max, verts_min, trans_max, trans_min = None, None, None, None
if normalized:
trans_max = np.array(model['trans_max'])
trans_min = np.array(model['trans_min'])
verts_max = np.array(model['verts_max'])
verts_min = np.array(model['verts_min'])
tfmodel = TFModel(graph=session.graph,
session=session,
input_tensor=in_tensor,
output_tensor=out_tensor,
vertices=vertices,
normalized=normalized,
trans_max=trans_max,
trans_min=trans_min,
verts_max=verts_max,
verts_min=verts_min)
self.models.append(tfmodel)
def test_mesh_evaluate_models(
graph: tf.Graph,
session: tf.Session,
space: gym.Space,
n_models: int,
n_mesh: int = 64,
):
"""Checks `canonical_sample.mesh_evaluate_models` agrees with `mesh_evaluate_models_slow`."""
with datasets.sample_dist_from_space(space) as dist:
obs = dist(n_mesh)
actions = dist(n_mesh)
next_obs = dist(n_mesh)
with graph.as_default():
models = {}
for i in range(n_models):
with tf.variable_scope(str(i)):
models[i] = rewards.MLPRewardModel(space, space)
session.run(tf.global_variables_initializer())
with session.as_default():
expected = mesh_evaluate_models_slow(models, obs, actions,
next_obs)
actual = epic_sample.mesh_evaluate_models(models, obs, actions,
next_obs)
assert expected.keys() == actual.keys()
for k in expected:
assert np.allclose(expected[k], actual[k]), f"difference in model {k}"
def pretrainSingleClass(self, modelname, dataset, class_name, batch_size,
epochs, lr):
#K.clear_session()
graph2 = Graph()
with graph2.as_default():
session2 = Session()
with session2.as_default():
reader = LFWReader(dir_images=dataset, class_name=class_name)
gen_train = TripletGeneratorSingleID(reader)
gen_test = TripletGeneratorSingleID(reader)
embedding_model, triplet_model = GetModel()
for layer in embedding_model.layers[-3:]:
layer.trainable = True
for layer in embedding_model.layers[:-3]:
layer.trainable = False
triplet_model.compile(loss=None, optimizer=Adam(lr))
history = triplet_model.fit_generator(gen_train,
validation_data=gen_test,
epochs=epochs,
verbose=1,
steps_per_epoch=50,
validation_steps=5)
embedding_model.save_weights('./trained-models/weights/' +
modelname + '.h5')
self.embeddingmodel(modelname, dataset)
K.get_session()
def _get_feature(cls, user_ids: List, item_ids: List, with_user_embedding,
graph: GraphConvolutionalMatrixCompletionGraph,
dataset: GcmcGraphDataset, session: tf.Session,
feature: str) -> np.ndarray:
if graph is None:
RuntimeError('Please call fit first.')
rating_adjacency_matrix = dataset.train_rating_adjacency_matrix()
user_indices, item_indices = dataset.to_indices(user_ids, item_ids)
if not with_user_embedding:
user_indices = np.array(
[0] * len(user_indices)) # TODO use default user index.
user_feature_indices, item_feature_indices = dataset.to_feature_indices(
user_ids, item_ids)
input_data = dict(user=user_indices,
item=item_indices,
user_feature_indices=user_feature_indices,
item_feature_indices=item_feature_indices)
feed_dict = cls._feed_dict(input_data,
graph,
dataset,
rating_adjacency_matrix,
is_train=False)
encoder_map = dict(user=graph.user_encoder, item=graph.item_encoder)
with session.as_default():
feature = session.run(encoder_map[feature], feed_dict=feed_dict)
return feature
def load_KerasGraph(path):
thread_graph = Graph()
with thread_graph.as_default():
thread_session = Session()
with thread_session.as_default():
model = keras.models.load_model(path)#model._make_predict_function()
graph = tf.get_default_graph()
return model, graph, thread_session
def graphandsession():
model_graph = Graph()
with model_graph.as_default():
tf_session = Session()
with tf_session.as_default():
mdl=load_model("C:/Users/Ritik/Desktop/Machine Learning Practice/Bank Loan Classification/DjangoAPI/MyAPI/models/model.h5")
return (model_graph,tf_session,mdl)
def load_KerasGraph(path):
print("> ====== loading Keras model for classification")
thread_graph = Graph()
with thread_graph.as_default():
thread_session = Session()
with thread_session.as_default():
model = keras.models.load_model(path)
graph = tf.get_default_graph()
print("> ====== Keras model loaded")
return model, graph, thread_session
def load_single_model(path):
graph = Graph()
with graph.as_default():
session = Session()
with session.as_default():
model = load_model(path)
model._make_predict_function()
MODELS.append(model)
GRAPHS.append(graph)
SESSIONS.append(session)
def test_compare_synthetic(
self,
graph: tf.Graph,
session: tf.Session,
rel_upperbound: float,
fudge_factor: float,
rescale: bool,
env_kwargs,
kwargs,
):
"""Try comparing randomly generated reward models, same scale."""
with graph.as_default():
with session.as_default():
noise = np.array([0.0, 0.5, 1.0]) # coarse-grained for speed
df, _ = synthetic.compare_synthetic(
reward_noise=noise,
potential_noise=noise,
model_affine=rescale,
**env_kwargs,
**kwargs,
)
with pd.option_context("display.max_rows", None, "display.max_columns", None):
logging.info("Results: %s", df)
for k in ["Intrinsic", "Shaping", "Extrinsic"]:
assert (df[k] >= 0).all(axis=None), f"distances {k} should not be negative"
# No reward noise, but potential noise
no_rew_noise = df.loc[(0.0, slice(0.1, None)), :]
rel = no_rew_noise["Intrinsic"] / no_rew_noise["Extrinsic"]
assert rel.max(axis=None) < (rel_upperbound * fudge_factor)
if not rescale:
# When ground truth and noised reward are on the same scale,
# shaping distance should increase proportionally with potential
# magnitude. When reward-noise is non-zero there's a confounder as
# the shaping noise we add can *cancel* with shaping in the reward
# noise. So just consider zero reward noise.
deltas = no_rew_noise["Shaping"].diff().dropna() # first row is N/A
assert deltas.min(axis=None) > 0.0
mean_delta = deltas.mean()
# Increment should be similar: allow it to vary by 2x up & down
assert (deltas < mean_delta * 2).all(axis=None)
assert (deltas > mean_delta * 0.5).all(axis=None)
# We're no more than 10% of intrinsic upper bound at any point.
# The upper bound is based on the magnitude of the reward noise
# we added. It's an upper bound since it may include some potential
# shaping, so we actually could find a shorter intrinsic distance.
# Add 10% margin of error since we don't expect perfect optimization.
some_noise = df.loc[df.index.get_level_values("Reward Noise") > 0.0]
rel = some_noise["Intrinsic"] / some_noise["Intrinsic Upper Bound"]
assert rel.max(axis=None) < (1 + 0.1 * fudge_factor)
def test_regress(
graph: tf.Graph,
session: tf.Session,
target: str,
loss_ub: float,
rel_loss_lb: float,
discount: float = 0.99,
):
"""Test regression onto target.
Args:
target: The target reward model type. Must be a hardcoded reward:
we always load with a path "dummy".
loss_ub: The maximum loss of the model at the end of training.
rel_loss_lb: The minimum relative improvement to the initial loss.
"""
env_name = "evaluating_rewards/PointMassLine-v0"
venv = vec_env.DummyVecEnv([lambda: gym.make(env_name)])
with datasets.transitions_factory_from_random_model(
env_name) as dataset_generator:
with graph.as_default():
with session.as_default():
with tf.variable_scope("source") as source_scope:
source = base.MLPRewardModel(venv.observation_space,
venv.action_space)
with tf.variable_scope("target"):
target_model = serialize.load_reward(
target, "dummy", venv, discount)
with tf.variable_scope("match") as match_scope:
match = comparisons.RegressModel(source, target_model)
init_vars = source_scope.global_variables(
) + match_scope.global_variables()
session.run(tf.initializers.variables(init_vars))
stats = match.fit(dataset_generator,
total_timesteps=1e5,
batch_size=512)
loss = pd.DataFrame(stats["loss"])["singleton"]
logging.info(f"Loss: {loss.iloc[::10]}")
initial_loss = loss.iloc[0]
logging.info(f"Initial loss: {initial_loss}")
final_loss = loss.iloc[-10:].mean()
logging.info(f"Final loss: {final_loss}")
assert initial_loss / final_loss > rel_loss_lb
assert final_loss < loss_ub
def get_eval_embeddings(eval_datasets):
outer_graph = Graph()
with outer_graph.as_default():
outer_session = Session()
with outer_session.as_default():
with open(
parent_directory + model_directory +
model_architecture_as_json, "r") as json_file:
model_json = json_file.read()
network = model_from_json(model_json)
network.load_weights(parent_directory + model_directory +
weights_of_model)
embeds = network.predict(np.stack(getImages(eval_datasets)))
return embeds
class MyPredictBrain():
def __init__(self):
self.basepath = os.path.dirname(__file__)
self.Imgs_Test = np.ndarray((1, 512, 512, 1), dtype=np.float32)
self.Predict = np.ndarray((512, 512), dtype=np.float32)
keras.backend.clear_session() # 用于重复使用模型
self.graph = Graph()
with self.graph.as_default():
self.session = Session()
with self.session.as_default():
unet = myUnet3()
self.model = unet.Model
self.model.load_weights('Unet_Brain.hdf5')
def LoadPic(self):
self.img = cv2.imread(
self.basepath + "/static/auto_photos/auto_picture.jpg",
cv2.IMREAD_GRAYSCALE)
self.img = cv2.resize(self.img, (512, 512),
interpolation=cv2.INTER_NEAREST)
pix = np.float32(self.img)
max = np.max(pix)
pix = np.divide(pix, max)
pix = img_to_array(pix)
for i in range(512):
for j in range(512):
self.Imgs_Test[0][i][j] = pix[i][j]
def PredictPic(self):
K.set_session(self.session)
with self.graph.as_default():
self.Result = self.model.predict(self.Imgs_Test, verbose=1)
def SavePic(self):
for m in range(512):
for n in range(512):
if ((self.Result[0][m][n][0] >= self.Result[0][m][n][1]) and
(self.Result[0][m][n][0] >= self.Result[0][m][n][2])):
self.Predict[m][n] = 0
elif (self.Result[0][m][n][1] >= self.Result[0][m][n][2]):
self.Predict[m][n] = 127.5
else:
self.Predict[m][n] = 255
# scipy.misc.imsave(self.basepath + '\\1.jpg', self.Predict)
path = self.basepath + "/static/after_auto_brain_photo/"
cv2.imwrite(os.path.join(path, 'after_auto_brain_temp.jpg'),
self.Predict)
def ai_predict(imgPath):
print("PATH:", imgPath)
# #preprocessing frame to predict its label
# config = tf.ConfigProto()
# config.gpu_options.allow_growth = True # dynamically grow the memory used on the GPU
# config.log_device_placement = True # to log device placement (on which device the operation ran)
# sess = tf.Session(config=config)
### PRIMEIRO ####
# #load previously trained model
#K.clear_session()
#global model
#model = load_model(os.path.join(SAVE_DIR, CRAPPY_MODEL))
#model._make_predict_function()
#global graph
#model = applications.VGG16(include_top=False, weights='imagenet', input_shape=(IMAGE_SIZE,IMAGE_SIZE,3))
#graph = tf.get_default_graph()
### SEGUNDO ####
graph1 = Graph()
with graph1.as_default():
session1 = Session(graph=graph1)
with session1.as_default():
model_1 = load_model(os.path.join(SAVE_DIR, CRAPPY_MODEL))
frame2 = cv2.imread(imgPath)
frame2 = cv2.resize(frame2, (IMAGE_SIZE, IMAGE_SIZE))
frame2 = img_to_array(frame2)
frame2 = np.array(frame2, dtype="float32") / 255.0
Image.fromarray((frame2[-1] * 255).round().astype(np.uint8))
frame2 = np.expand_dims(frame2, axis=0)
# # generating a prdiction of the frame
## PRIMEIRO
#with graph.as_default():
#y_pred = model.predict_classes(frame2)
## SEGUNDO
K.set_session(session1)
with graph1.as_default():
try:
y_pred = model_1.predict_classes(frame2)
except:
print()
#y_pred = top_model.predict_classes(model.predict(frame2[None,:,:,:]))
print("y_pred:", int(y_pred))
return int(y_pred[0])
class FaceID:
def __init__(self):
self.to_identify_path = os.path.join(os.path.abspath(os.sep), 'ALFI_Data','To_Identify', 'Raw')
self.to_identify_processed_path = os.path.join(os.path.abspath(os.sep), 'ALFI_Data','To_Identify', 'Processed')
self.to_process_path = os.path.join(os.path.abspath(os.sep), 'ALFI_Data','To_Process')
self.dataset_path = os.path.join(os.path.abspath(os.sep), 'ALFI_Data','Dataset','DC')
self.dataset_ds_path = os.path.join(os.path.abspath(os.sep), 'ALFI_Data','Dataset','DS')
self.weigths_path = os.path.join(os.path.abspath(os.sep), 'ALFI_Data','Weigths')
self.current_sbj = 0
while(os.path.exists(os.path.join(self.dataset_path,'sbj-'+str(self.current_sbj)))):
self.current_sbj = self.current_sbj + 1
self.graph = Graph()
with self.graph.as_default():
self.session = Session()
with self.session.as_default():
self.model = faceIDNet()
def train(self, epochs, save_name, load=False):
if load:
self.load(save_name)
K.set_session(self.session)
with self.graph.as_default():
gen = generator(24, self.dataset_ds_path)
save_folder = os.path.join(self.weigths_path, save_name)
if not os.path.exists(save_folder):
os.makedirs(save_folder)
cp_callback = ModelCheckpoint(os.path.join(save_folder, 'faceID_weights'), save_weights_only=True)
self.model.fit_generator(gen, steps_per_epoch=30, epochs=epochs, validation_steps=20, callbacks=[cp_callback])
lossTrain = self.model.evaluate_generator(gen, steps=30)
print('* - Loss: '+str(lossTrain))
def predict(self, inputs, threshold=0.2):
K.set_session(self.session)
with self.graph.as_default():
inputs = [inputs[0,:].reshape((1,100,100,4)), inputs[1,:].reshape((1,100,100,4))]
out = self.model.predict(inputs)
return (out <= threshold)
def load(self, save_name):
K.set_session(self.session)
with self.graph.as_default():
self.model.load_weights(os.path.join(self.weigths_path, save_name, 'faceID_weights'))
self.model._make_predict_function()
print('--- Weights loaded ---')
class KerasClassifier(ClassifierABC):
def __init__(self, model: Model, trainer: KerasTrainer):
self.model = model
self.trainer: Optional[KerasTrainer] = trainer
def fit(self, images: List[Image], labels: List[int], validation_size: int) -> "KerasClassifier":
assert self.trainable, "You can't train an un-pickled classifier"
images = asarray(images)
labels = to_categorical(asarray(labels), self.n_classes)
train_images, train_labels = images[:-validation_size], labels[:-validation_size]
val_images, val_labels = images[-validation_size:], labels[-validation_size:]
self.trainer.train(self.model, train_images, train_labels, val_images, val_labels)
return self
def predict_proba(self, examples: List[Image]) -> Sequence[float]:
try: # FIXME
with self.graph.as_default(), self.session.as_default():
return self.model.predict(asarray(examples))
except AttributeError:
return self.model.predict(asarray(examples))
def __getstate__(self) -> Dict:
with NamedTemporaryFile(suffix=".hdf5", delete=True) as fd:
self.model.save(fd.name, overwrite=True, include_optimizer=False)
model_str = fd.read()
state = copy(self.__dict__)
state.pop("model")
state.pop("trainer")
return {**state, "model_str": model_str}
def __setstate__(self, state: Dict):
self.__dict__.update(state)
self.graph = Graph()
with NamedTemporaryFile(suffix=".hdf5", delete=True) as fd:
fd.write(state.pop("model_str"))
fd.flush()
with self.graph.as_default():
self.session = Session(graph=self.graph)
with self.session.as_default():
self.model = load_model(fd.name, compile=False)
self.trainer = None
@property
def trainable(self) -> bool:
return self.trainer is not None
def get_eval_embeddings(eval_datasets):
outer_graph = Graph()
with outer_graph.as_default():
outer_session = Session()
with outer_session.as_default():
#network = load_model(parent_directory + model_directory + complete_model, custom_objects={'triplet_loss':train.triplet_loss} )
with open(
parent_directory + model_directory +
model_architecture_as_json, "r") as json_file:
model_json = json_file.read()
network = model_from_json(model_json)
print(network.summary())
network.load_weights(parent_directory + model_directory +
weights_of_model)
embeds = network.predict(np.stack(getImages(eval_datasets)))
return embeds
class EmotionsDetection:
def __init__(self):
self.emotion_model_path = 'emotion_model/trained_models/emotion_models/fer2013_mini_XCEPTION.102-0.66.hdf5'
self.emotion_labels = get_labels('fer2013')
self.graph = Graph()
with self.graph.as_default():
self.session = Session(graph=self.graph)
with self.session.as_default():
self.emotion_classifier = load_model(self.emotion_model_path,
compile=False)
# starting lists for calculating modes
self.emotion_target_size = self.emotion_classifier.input_shape[1:3]
self.emotion_window = []
self.frame_window = 10
self.emotion_offsets = (20, 40)
##################################
def processe(self, args):
res = []
faces = args
for face in faces:
face = cv2.cvtColor(face, cv2.COLOR_BGR2GRAY)
# try:
face = cv2.resize(face, self.emotion_target_size)
# except :
# continue
face = preprocess_input(face, True)
face = np.expand_dims(face, 0)
face = np.expand_dims(face, -1)
t1 = time.time()
k.set_session(self.session)
with self.graph.as_default():
emotion_prediction = self.emotion_classifier.predict(face)
print('time is :', time.time() - t1)
emotion_probability = np.max(emotion_prediction)
all_emotions = emotion_prediction
emotion_label_arg = np.argmax(all_emotions)
if round(all_emotions[0][6] - all_emotions[0][4], 2) >= 0.45:
emotion_label_arg = 4
elif round(all_emotions[0][0], 2) >= 0.2:
emotion_label_arg = 0
emotion_text = self.emotion_labels[emotion_label_arg]
res.append([emotion_text, emotion_probability])
return res
def train(masterLabels, filename):
outer_graph = Graph()
with outer_graph.as_default():
outer_session = Session()
with outer_session.as_default():
network_input = Input((height, width, 3))
network_output = InceptionResnetV2(network_input)
network = Model(inputs=network_input, outputs=network_output)
print(network.summary())
opt = Adam(lr=0.01, beta_1=0.99, beta_2=0.999, epsilon=0.1)
network.compile(loss=triplet_loss,
optimizer=opt,
metrics=['accuracy'])
saved_triplet_paths = np.loadtxt(filename,
delimiter=",",
dtype=np.str)
steps_for_each_epoch = len(saved_triplet_paths) // (
max_nrof_epochs * training_images_per_step)
print(' steps per each epoch is %d ' % (steps_for_each_epoch))
checkpoint = ModelCheckpoint(parent_directory + model_directory +
interim_best_weights_of_model,
monitor='loss',
verbose=1,
save_best_only=True,
mode='max')
history = network.fit_generator(
generator=getTriplets(saved_triplet_paths, masterLabels),
epochs=max_nrof_epochs,
steps_per_epoch=steps_for_each_epoch,
verbose=2,
max_queue_size=1,
callbacks=[checkpoint, debug])
history_dict = history.history
for key, value in history_dict.items():
print('Key is %s and value is %s' % (key, value))
print(history_dict.keys())
model_json = network.to_json()
with open(
parent_directory + model_directory +
model_architecture_as_json, "w") as json_file:
json_file.write(model_json)
network.save(parent_directory + model_directory + complete_model)
network.save_weights(parent_directory + model_directory +
weights_of_model)
class KerasModel(object):
"Load the Keras Model"
def __init__(self):
self.initialized = False
self.verbose = False
self.model_path = self.set_model_path()
self.model = None
self.session = None
@staticmethod
def set_model_path():
""" Set the path to the Face Alignment Network Model """
model_path = os.path.join(os.path.dirname(__file__),
".cache", "2DFAN-4.h5")
if not os.path.exists(model_path):
raise Exception("Error: Unable to find {}, "
"reinstall the lib!".format(model_path))
return model_path
def load_model(self, verbose, dummy, ratio):
""" Load the Keras Model """
if self.initialized:
return
self.verbose = verbose
if self.verbose:
print("Initializing keras model...")
keras_graph = Graph()
with keras_graph.as_default():
config = ConfigProto()
if ratio:
config.gpu_options.per_process_gpu_memory_fraction = ratio
self.session = Session(config=config)
with self.session.as_default():
self.model = keras.models.load_model(
self.model_path,
custom_objects={'TorchBatchNorm2D':
TorchBatchNorm2D})
self.model.predict(dummy)
keras_graph.finalize()
self.initialized = True
def getOutput(hours, past, type):
from keras.models import load_model
from tensorflow import Graph, Session
# import tensorflow as tf
import numpy as np
testData = np.array(past)
testData = testData.reshape(1, len(past), 1)
graph = Graph()
with graph.as_default():
session = Session()
with session.as_default():
# load model
if(type == "load"):
model = load_model("./model/model" + str(hours) + ".h5")
elif(type == "generation"):
model = load_model("./model/solar_model" + str(hours) + ".h5")
model.summary()
output = model.predict(testData)
return output
class KerasModel(object):
"Load the Keras Model"
def __init__(self):
self.initialized = False
self.verbose = False
self.model_path = self.set_model_path()
self.model = None
self.session = None
@staticmethod
def set_model_path():
""" Set the path to the Face Alignment Network Model """
model_path = os.path.join(os.path.dirname(__file__), ".cache",
"2DFAN-4.h5")
if not os.path.exists(model_path):
raise Exception("Error: Unable to find {}, "
"reinstall the lib!".format(model_path))
return model_path
def load_model(self, verbose, dummy, ratio):
""" Load the Keras Model """
if self.initialized:
return
self.verbose = verbose
if self.verbose:
print("Initializing keras model...")
keras_graph = Graph()
with keras_graph.as_default():
config = ConfigProto()
if ratio:
config.gpu_options.per_process_gpu_memory_fraction = ratio
self.session = Session(config=config)
with self.session.as_default():
self.model = keras.models.load_model(
self.model_path,
custom_objects={'TorchBatchNorm2D': TorchBatchNorm2D})
self.model.predict(dummy)
keras_graph.finalize()
self.initialized = True
def create_detector(self, verbose, mtcnn_kwargs):
""" Create the mtcnn detector """
self.verbose = verbose
if self.verbose:
print("Adding MTCNN detector")
self.kwargs = mtcnn_kwargs
mtcnn_graph = Graph()
with mtcnn_graph.as_default():
mtcnn_session = Session()
with mtcnn_session.as_default():
pnet, rnet, onet = create_mtcnn(mtcnn_session, self.data_path)
mtcnn_graph.finalize()
self.kwargs["pnet"] = pnet
self.kwargs["rnet"] = rnet
self.kwargs["onet"] = onet
self.initialized = True
