def classify_process():
print("* Loading model...")
model = ResNet50(weights="imagenet")
print("* Model loaded")
while True:
messages = sqs.receive()
images = []
if not messages:
continue
for msg in messages:
body = json.loads(msg['Body'])
s3_path = body['Message']
img = s3.get(s3_path)
images.append(img)
# images = db.lrange(settings.IMAGE_QUEUE, 0,
# settings.BATCH_SIZE - 1)
image_ids = []
image_batch = None
for img in images:
img = json.loads(img.decode("utf-8"))
image = helpers.base64_decode_image(
img["image"], settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
if image_batch is None:
image_batch = image
else:
image_batch = np.vstack([image_batch, image])
image_ids.append(img["id"])
if len(image_ids) > 0:
print("* Batch size: {}".format(image_batch.shape))
predicts = model.predict(image_batch)
results = imagenet_utils.decode_predictions(predicts)
for (image_id, result_set) in zip(image_ids, results):
output = []
for _, label, prob in result_set:
r = {"label": label, "probability": float(prob)}
output.append(r)
db.set(image_id, json.dumps(output))
# db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
sqs.delete(messages)
time.sleep(settings.SERVER_SLEEP)
def run_mnist_model_server():
"""
The model server
Pull image from the Redis, decode
send to the model, predict
return the response to the redis
Images are tracked using is Image IDs
"""
print "* Loading MNIST Model..."
mnist_model = load_model(settings.MNIST_MODEL_PATH)
print "* MNIST Model Loaded!"
while True:
# continues listening...
# grab a list of image (equal to the batch size from the
# redis db
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE)
imageIDs = []
batch = None
# for each image in the queue
for q in queue:
q = json.loads(q.decode("utf-8"))
# decode the image
this_image = helpers.base64_decode_image(
q['image'],
settings.IMAGE_TYPE,
shape=(1, 1, settings.IMAGE_WIDTH, settings.IMAGE_HEIGHT))
# stack up the image to the current
# batch
if batch is None:
batch = this_image
else:
batch = np.vstack([batch, this_image])
# add the id
imageIDs.append(q['id'])
# start to put the result back to the db
if len(imageIDs) > 0:
print "* Batch size: {}".format(batch.shape)
# get the prediction results
this_preds = mnist_model.predict(batch)
for (each_id, each_pred) in zip(imageIDs, this_preds):
output = [{"label": np.argmax(each_pred)}]
# push the results to db
# imageID as the key
db.set(each_id, json.dumps(output))
# remove the set of images from the queue
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
# wait for the redis to receive new images to predict
time.sleep(settings.SERVER_SLEEP)
def ocr_process():
# 载入ocr模型
model = ocr.Ocr(text_process=False)
print("load model done")
while True:
# 尝试从redis数据库取出一队图像数据
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE - 1)
# 用于放置每幅图像的id
imageIDs = []
batch = None
# 遍历图像数据队列
for q in queue:
# 解码图像数据
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(q["image"],
settings.IMAGE_DTYPE,
q["shape"])
# 检查数据批是否为空
if batch is None:
batch = image
# 不为空则将数据堆叠起来，形成一批数据
else:
batch = np.vstack([batch, image])
# 更新图像id列表
imageIDs.append(q["id"])
# 检查是否需要进行模型预测
if len(imageIDs) > 0:
# 处理数据块
results = []
print("* Batch size: {}".format(batch.shape))
for img in batch:
preds = model.predict(img)
results.append(preds)
for (imageID, resultSet) in zip(imageIDs, results):
# 初始化预测结果
output = []
# 初始化文本检测结果
boxes = []
for box in resultSet[1]:
boxes.append([box[xy] for xy in range(8)])
r = {"words": resultSet[0], "boxes": boxes}
output.append(r)
# 存储检测与识别结果
db.set(imageID, json.dumps(output, ensure_ascii=False))
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
# 延时
time.sleep(settings.SERVER_SLEEP)
def face_process():
#vgg_features = VGGFace(include_top=False, input_shape=(224, 224, 3), pooling='avg') ## doesn't seem to be required.
print("* Loading model")
model = VGGFace(model='vgg16')
print("* Model loaded")
while True:
queue = db.lrange(settings.FACE_QUEUE, 0, settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(
q["image"], settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
imageIDs.append(q["id"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
# classify the batch
print("* Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = utils.decode_predictions(preds)
#print(results) ## this comes back with something so its the below structure giving me an issue.
# [[["b'A.J._Buckley'", 0.9768057], ["b'David_Denman'", 0.0013909286], ["b'Carmine_Giovinazzo'", 0.0010687601], ["b'Robert_Buckley'", 0.00093060045], ["b'Eddie_Cahill'", 0.00044030472]]]
for (imageID, resultSet) in zip(imageIDs, results):
print("imageID", imageID, resultSet)
## imageID 63350aef-0ec3-4e1d-be99-3db36013a6d7
output = []
for (label, prob) in resultSet:
r = {"label": label, "probability": float(prob)}
output.append(r)
db.set(imageID, json.dumps(output))
# remove the set of images from our queue
db.ltrim(settings.FACE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def classify_process():
# load the pre-trained Keras model (here we are using a model
# pre-trained on ImageNet and provided by Keras, but you can
# substitute in your own networks just as easily)
print("* Loading model...")
model = ResNet50(weights="imagenet")
print("* Model loaded")
# continually pool for new images to classify
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
# loop over the queue
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(
q["image"], settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
imageIDs.append(q["id"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
# classify the batch
print("* Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = decode_predictions(preds)
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(imageIDs, results):
# initialize the list of output predictions
output = []
# loop over the results and add them to the list of
# output predictions
for (imagenetID, label, prob) in resultSet:
r = {"label": label, "probability": float(prob)}
output.append(r)
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
db.set(imageID, json.dumps(output))
# remove the set of images from our queue
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def classify_process():
#to be replaced
model = ResNet50(weights="imagenet")
while True:
# get batch
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
for q in queue:
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(
q["image"], settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
if batch is None:
batch = image
else:
batch = np.vstack([batch, image])
imageIDs.append(q["id"])
if len(imageIDs) > 0:
print("* Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = imagenet_utils.decode_predictions(preds)
for (imageID, resultSet) in zip(imageIDs, results):
output = []
for (imagenetID, label, prob) in resultSet:
r = {
"label": label,
"point_x": float(prob[0]),
"point_x": float(prob[1])
}
output.append(r)
db.set(imageID, json.dumps(output))
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
time.sleep(settings.SERVER_SLEEP)
def classify_process(stream_batch, batch_id):
# Covert to List[Row]
stream_batch = stream_batch.collect()
image_ids = []
batch = None
# loop over the queue
for q in stream_batch:
# deserialize the object and obtain the input image
image = helpers.base64_decode_image(q["image"])
image = helpers.byte_to_mat(image, dtype=settings.IMAGE_DTYPE)
image = helpers.image_preprocess(image, settings.IMAGE_WIDTH, settings.IMAGE_HEIGHT)
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
image_ids.append(q["id"])
# check to see if we need to process the batch
if len(image_ids) > 0:
# classify the batch
batch = np.expand_dims(batch, axis=0)
print("* Batch size: {}".format(batch.shape))
# Output is [1, 4, 1000]
results = model.predict(batch)[0]
# loop over the image IDs and their corresponding set of
# results from our model
for (image_id, resultSet) in zip(image_ids, results):
# initialize the list of output predictions
output = {}
# loop over the results and add them to the list of
# output predictions
# Top 1
max_index = np.argmax(resultSet)
output["Top-1"] = str(max_index)
output["id"] = image_id
print("* Predict result " + str(output))
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
DB.lpush(settings.PREDICT_QUEUE, json.dumps(output))
# remove the set of images from our queue
DB.ltrim(settings.IMAGE_QUEUE, len(image_ids), -1)
def detect_process():
# continually pool for new images to detect
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
# loop over the queue
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(
q["image"], settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
#rfid = q["rfid"]
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
imageIDs.append(q["id"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
# detect the batch
print("* Batch size: {}".format(batch.shape))
rfid = './data/tmp/rfid.csv'
results = sync_bibnumber_api(batch, rfid)
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(imageIDs, results):
db.set(imageID, json.dumps(resultSet))
# remove the set of images from our queue
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def tag_process():
print("* Loading model .....")
model = VGG16(weights="vgg16_weights_tf_dim_ordering_tf_kernels.h5")
print("* Model loaded")
while True:
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
for q in queue:
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(
q["image"], settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
if batch is None:
batch = image
else:
batch = np.vstack([batch, image])
imageIDs.append(q["id"])
if len(imageIDs) > 0:
print("* Batch size : {}".format(batch.shape))
preds = model.predict(batch)
results = imagenet_utils.decode_predictions(
preds, top=settings.VGG_TOP_CLASSES)
for (imageID, resultSet) in zip(imageIDs, results):
tags = []
for (_, label, prob) in resultSet:
tags.append(label)
db.set(imageID, json.dumps(tags))
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
time.sleep(settings.SERVER_SLEEP)
def start_classify():
model = load_model()
print("Done LOADING!")
while True:
queue = db.lrange(settings.IMAGE_QUEUE, 0, settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
for q in queue:
q = json.loads(q.decode("utf-8"))
#print(type(q["image"]))
image = base64_decode_image(q["image"], settings.IMAGE_DTYPE)
if batch is None:
batch = image
else:
batch = np.vstack([batch, image])
imageIDs.append(q["id"])
if len(imageIDs) > 0:
print("* Batch size: {}".format(batch.shape))
results = [im_detect(model, image)]
for (imageID, ans) in zip(imageIDs, results):
#print(ans)
output = []
scores = ans[0]
boxes = ans[1]
r = {"labels": scores.tolist(), "boxes": boxes.tolist()}
output.append(r)
db.set(imageID, json.dumps(output))
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
time.sleep(settings.SERVER_SLEEP)
def classify_process(model_path):
# load the pre-trained OpenVINO model
print("* Loading model...")
model = InferenceModel()
model.load_openvino(model_path,
weight_path=model_path[:model_path.rindex(".")] + ".bin")
print("* Model loaded")
# continually pool for new images to classify
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = DB.lrange(settings.IMAGE_QUEUE, 0,
settings.BATCH_SIZE - 1)
image_ids = []
batch = None
# loop over the queue
start_time = time.time()
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(q["image"])
image = helpers.byte_to_mat(image, dtype=settings.IMAGE_DTYPE)
image = helpers.image_preprocess(image, settings.IMAGE_WIDTH, settings.IMAGE_HEIGHT)
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
image_ids.append(q["id"])
print("* Pop from redis %d ms" % int(round((time.time() - start_time) * 1000)))
# check to see if we need to process the batch
if len(image_ids) > 0:
# classify the batch
batch = np.expand_dims(batch, axis=0)
print("* Batch size: {}".format(batch.shape))
# Output is [1, 4, 1000]
results = model.predict(batch)[0]
print("* Predict a batch %d ms" % int(round((time.time() - start_time) * 1000)))
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(image_ids, results):
# initialize the list of output predictions
output = {}
# loop over the results and add them to the list of
# output predictions
# Top 1
max_index = np.argmax(resultSet)
output["Top-1"] = str(max_index)
output["id"] = imageID
print("* Predict result " + str(output))
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
DB.lpush(settings.PREDICT_QUEUE, json.dumps(output))
# remove the set of images from our queue
print("* Total time used is %d ms" % int(round((time.time() - start_time) * 1000)))
DB.ltrim(settings.IMAGE_QUEUE, len(image_ids), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def classify_process(model_path):
print("* Loading model...")
model = InferenceModel()
model.load_openvino(model_path=model_path,
weight_path=model_path[:model_path.rindex(".")] +
".bin")
print("* Model loaded")
# continually poll for new images to classify
while True:
image_ids = []
batch = None
# loop over the queue
start_time = time.time()
count = 0
while count < 4:
# Get message or None or timeout
record = pub.get_message()
if record and record['type'] == 'message':
data = json.loads(record['data'].decode("utf-8"))
image = helpers.base64_decode_image(data["image"])
image = helpers.byte_to_mat(image, dtype=settings.IMAGE_DTYPE)
image = helpers.image_preprocess(image, settings.IMAGE_WIDTH,
settings.IMAGE_HEIGHT)
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
image_ids.append(data["id"])
count += 1
print("* Pop from redis %d ms" %
int(round((time.time() - start_time) * 1000)))
# check to see if we need to process the batch
if len(image_ids) > 0:
# classify the batch
batch = np.expand_dims(batch, axis=0)
print("* Batch size: {}".format(batch.shape))
# Output is [1, 4, 1000]
results = model.predict(batch)[0]
print("* Predict a batch %d ms" %
int(round((time.time() - start_time) * 1000)))
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(image_ids, results):
# initialize the list of output predictions
output = {}
# loop over the results and add them to the list of
# output predictions
# Top 1
max_index = np.argmax(resultSet)
output["Top-1"] = str(max_index)
output["id"] = imageID
print("* Predict result " + str(output))
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
DB.lpush(settings.PREDICT_QUEUE, json.dumps(output))
# remove the set of images from our queue
print("* Total time used is %d ms" %
int(round((time.time() - start_time) * 1000)))
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def classify_process():
print("* Loading model...")
img_size = 64
model = WideResNet(img_size, depth=16, k=8)()
model.load_weights("checkpoints168/weights.48-3.62.hdf5")
print("* Model loaded")
while True:
body = db.lpop(settings.IMAGE_QUEUE)
if body is not None:
body = json.loads(body.decode("utf-8"))
image = helpers.base64_decode_image(body["image"], body["height"])
bounding_boxes = demo_mtcnn.detect_face(image)
margin = 0.4
faces = np.empty((len(bounding_boxes), 64, 64, 3))
for i, bounding_box in enumerate(bounding_boxes):
x = int(bounding_box[0])
y = int(bounding_box[1])
w = int(bounding_box[2])
h = int(bounding_box[3])
img_h, img_w, _ = np.shape(image)
_x = max(int(x - margin * w), 0)
_y = max(int(y - margin * h), 0)
_x2 = min(int(x + w + margin * w), img_w - 1)
_y2 = min(int(y + h + margin * h), img_h - 1)
# cv2.rectangle(image, (x, y), (x+w, y+h), (0, 155, 255), 2)
faces[i, :, :, :] = cv2.resize(
image[_y:_y2 + 1, _x:_x2 + 1, :], (64, 64))
# cv2.rectangle(image, (_x, _y), (_x2, _y2), (0, 155, 255), 2)
# cv2.imshow("",faces[0])
# key = cv2.waitKey(-1)
# if key==27:
# break
if len(faces) > 0:
results = model.predict(faces)
# results = imagenet_utils.decode_predictions(preds)
predicted_genders = results[0]
ages = np.arange(0, 101).reshape(101, 1)
predicted_ages = results[1].dot(ages).flatten()
predicted_ages = predicted_ages.tolist()
predicted_genders = [
gender.tolist() for gender in predicted_genders
]
print(type(predicted_genders[0]))
print(type(predicted_ages))
# for i, bounding_box in enumerate(bounding_boxes):
# label = "{}, {}".format(int(predicted_ages[i]),"M" if predicted_genders[i][0] < 0.5 else "F")
# demo_mtcnn.draw_label(image, (int(bounding_box[0]), int(bounding_box[1])), label)
# cv2.imshow("",image)
# cv2.waitKey(1000)
print("done")
# image_out = helpers.base64_encode_image(image).decode('utf-8')
# db.set(body["id"], json.dumps(image_out))
data = {
"boudingboxes": bounding_boxes.tolist(),
"ages": predicted_ages,
"genders": predicted_genders
}
db.set(body["id"], json.dumps(data))
else:
print("No data")
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def receive_img(self, topic, dtype, shape):
img = self._consume(topic, is_img=True)
return base64_decode_image(img, dtype=dtype, shape=shape)
def classify_process():
# load the pre-trained Keras model (here we are using a model
# pre-trained on ImageNet and provided by Keras, but you can
# substitute in your own networks just as easily)
print("* Loading model...")
base_model = tf.keras.applications.MobileNetV2(input_shape=(settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH, settings.IMAGE_CHANS),
include_top=False,
weights='imagenet')
model = Sequential([base_model, GlobalAveragePooling2D(), Dense(497, activation='softmax')])
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.load_weights(settings.CHECKPOINT_PATH)
print("* Model loaded")
# continually pool for new images to classify
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = db.lrange(settings.IMAGE_QUEUE, 0,
settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
# loop over the queue
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(q["image"],
settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
imageIDs.append(q["id"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
# classify the batch
print("* Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = helpers.decode_predictions(preds)
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(imageIDs, results):
# initialize the list of output predictions
output = []
# loop over the results and add them to the list of
# output predictions
label, prob = resultSet
r = {"label": label, "probability": float(prob)}
output.append(r)
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
db.set(imageID, json.dumps(output))
# remove the set of images from our queue
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def classify_process():
# load the pre-trained Keras model (here we are using a model
# pre-trained on ImageNet and provided by Keras, but you can
# substitute in your own networks just as easily)
print("* Loading model...")
model = ResNet50(weights="imagenet")
print("* Model loaded")
# continually pool for new images to classify
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = db.lrange(settings.IMAGE_QUEUE, 0,
settings.BATCH_SIZE - 1)
imageIDs = []
batch = None
# loop over the queue
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(q["image"],
settings.IMAGE_DTYPE,
(1, settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH,
settings.IMAGE_CHANS))
# check to see if the batch list is None
if batch is None:
batch = image
# otherwise, stack the data
else:
batch = np.vstack([batch, image])
# update the list of image IDs
imageIDs.append(q["id"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
# classify the batch
print("* Batch size: {}".format(batch.shape))
preds = model.predict(batch)
results = imagenet_utils.decode_predictions(preds)
# loop over the image IDs and their corresponding set of
# results from our model
for (imageID, resultSet) in zip(imageIDs, results):
# initialize the list of output predictions
output = []
# loop over the results and add them to the list of
# output predictions
for (imagenetID, label, prob) in resultSet:
r = {"label": label, "probability": float(prob)}
output.append(r)
# store the output predictions in the database, using
# the image ID as the key so we can fetch the results
db.set(imageID, json.dumps(output))
# remove the set of images from our queue
db.ltrim(settings.IMAGE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
def main():
print("* Loading models...")
input_img = Input(
(settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH, settings.IMAGE_CHANS),
name='img')
model = get_unet(input_img, n_filters=16, dropout=0.05, batchnorm=True)
model.compile(optimizer=Adam(),
loss="binary_crossentropy",
metrics=["accuracy"])
model.load_weights('face-segmentation.h5')
net = cv2.dnn.readNetFromCaffe('deploy.prototxt.txt',
'res10_300x300_ssd_iter_140000.caffemodel')
print("* Models loaded")
while True:
# attempt to grab a batch of images from the database, then
# initialize the image IDs and batch of images themselves
queue = db.lrange(settings.SEGMENT_IMAGE_QUEUE, 0,
settings.BATCH_SIZE - 1)
imageIDs = []
batch = []
confidences = []
# loop over the queue
for q in queue:
# deserialize the object and obtain the input image
q = json.loads(q.decode("utf-8"))
image = helpers.base64_decode_image(q["image"],
settings.IMAGE_DTYPE,
q["shape"])
# check to see if the batch list is None
batch.append(image)
# update the list of image IDs
imageIDs.append(q["id"])
# add to list of confidence attributes
confidences.append(q["confidence"])
# check to see if we need to process the batch
if len(imageIDs) > 0:
print('* ImageIDs: {}'.format(imageIDs))
faces = {}
for i in range(len(batch)):
print("* Batch size: {}".format(batch[i][0].shape))
image = np.array(batch[i][0], dtype="uint8")
(h, w) = image.shape[:2]
if h > 1000 or w > 1000:
blob = cv2.dnn.blobFromImage(image,
mean=(104.0, 117.0, 123.0),
swapRB=True)
net.setInput(blob)
detections = net.forward()
else:
blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)),
1.0, (300, 300),
(104.0, 117.0, 123.0),
swapRB=True)
net.setInput(blob)
detections = net.forward()
if detections.shape[2] == 0:
faces[i] = np.array([[[[0., 1., 1., 0., 0., 1., 1.]]]])
else:
faces[i] = detections
X = []
X_positions = []
numFaces = []
for imageNum, detections in faces.items():
image = batch[imageNum][0]
confidence = confidences[imageNum]
(h, w) = image.shape[:2]
index = 0
# loop over the detections
for i in range(0, detections.shape[2]):
# extract the confidence (i.e., probability) associated with the prediction
conf = detections[0, 0, i, 2]
# filter out weak detections by ensuring the `confidence` is greater than the minimum confidence
if conf > confidence:
# compute the (x, y)-coordinates of the bounding box for the object
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
if startX > image.shape[
1] - 10 or startY > image.shape[0] - 10:
continue
w_box = endX - startX
h_box = endY - startY
transpose_x, transpose_y = w_box * 0.75, h_box * 0.75
x_img = math.floor(startX - transpose_x) if math.floor(
startX - transpose_x) >= 0 else 0
y_img = math.floor(startY - transpose_y) if math.floor(
startY - transpose_y) >= 0 else 0
w_img = math.floor(
w_box + 2 * transpose_x) if x_img + math.floor(
w_box + 2 * transpose_x
) <= image.shape[1] else image.shape[1] - x_img
h_img = math.floor(
h_box + 2 * transpose_y) if y_img + math.floor(
h_box + 2 * transpose_y
) <= image.shape[0] else image.shape[0] - y_img
X_positions.append([x_img, y_img, w_img, h_img])
# 2d array of cropped image
roi_color = image[y_img:h_img + y_img,
x_img:w_img + x_img]
X.append(
resize(
roi_color,
(settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH),
mode='constant',
preserve_range=True))
index += 1
if (index == 0):
index = 1
box = [0., 0., 1., 1.] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
w_box = endX - startX
h_box = endY - startY
transpose_x, transpose_y = w_box * 0.75, h_box * 0.75
x_img = math.floor(startX - transpose_x) if math.floor(
startX - transpose_x) >= 0 else 0
y_img = math.floor(startY - transpose_y) if math.floor(
startY - transpose_y) >= 0 else 0
w_img = math.floor(
w_box + 2 * transpose_x) if x_img + math.floor(
w_box + 2 * transpose_x
) <= image.shape[1] else image.shape[1] - x_img
h_img = math.floor(
h_box + 2 * transpose_y) if y_img + math.floor(
h_box + 2 * transpose_y
) <= image.shape[0] else image.shape[0] - y_img
X_positions.append([x_img, y_img, w_img, h_img])
# 2d array of cropped image
roi_color = image[y_img:h_img + y_img, x_img:w_img + x_img]
X.append(
resize(roi_color,
(settings.IMAGE_HEIGHT, settings.IMAGE_WIDTH),
mode='constant',
preserve_range=True))
numFaces.append(index)
X = np.array(X).astype(np.float32)
preds_test = (model.predict(X, verbose=1) > 0.8).astype(np.uint8)
index = 0
masks = []
for imageNum, detections in faces.items():
upsampled_mask = np.zeros(
(batch[imageNum][0].shape[0], batch[imageNum][0].shape[1]),
dtype=np.uint8)
for i in range(index, index + numFaces[imageNum]):
coords = X_positions[i]
section = resize(np.squeeze(preds_test[i]),
(coords[3], coords[2]),
mode='constant',
preserve_range=True,
order=0)
upsampled_mask[coords[1]:coords[3] + coords[1],
coords[0]:coords[2] +
coords[0]] += section.astype(np.uint8)
masks.append(upsampled_mask)
index += numFaces[imageNum]
for imageID, i in zip(imageIDs, range(len(imageIDs))):
db.set(imageID, json.dumps(masks[i].tolist()))
# remove the set of images from our queue
db.ltrim(settings.SEGMENT_IMAGE_QUEUE, len(imageIDs), -1)
# sleep for a small amount
time.sleep(settings.SERVER_SLEEP)
