diff options
| -rw-r--r-- | megapixels/app/models/bbox.py | 16 | ||||
| -rw-r--r-- | megapixels/app/processors/face_age.py | 28 | ||||
| -rw-r--r-- | megapixels/app/processors/face_age_gender.py | 116 | ||||
| -rw-r--r-- | megapixels/app/processors/face_gender.py | 28 | ||||
| -rw-r--r-- | megapixels/app/utils/draw_utils.py | 2 | ||||
| -rw-r--r-- | megapixels/commands/demo/face_age_gender.py (renamed from megapixels/commands/demo/face_age.py) | 61 | ||||
| -rw-r--r-- | megapixels/commands/demo/face_gender.py | 53 | ||||
| -rw-r--r-- | megapixels/notebooks/face_analysis/age_gender.ipynb | 278 | ||||
| -rw-r--r-- | megapixels/notebooks/face_analysis/beauty.ipynb | 2 |
9 files changed, 491 insertions, 93 deletions
diff --git a/megapixels/app/models/bbox.py b/megapixels/app/models/bbox.py index 04ee4a70..40874691 100644 --- a/megapixels/app/models/bbox.py +++ b/megapixels/app/models/bbox.py @@ -130,10 +130,10 @@ class BBox: # ----------------------------------------------------------------- # Modify - def expand_dim(self, amt, dim): + def expand_dim(self, amt, bounds): """Expands BBox within dim :param box: (tuple) left, top, right, bottom - :param dim: (tuple) width, height + :param bounds: (tuple) width, height :returns (BBox) in pixel dimensions """ # expand @@ -142,8 +142,8 @@ class BBox: oob = list(range(4)) oob[0] = min(r[0], 0) oob[1] = min(r[1], 0) - oob[2] = dim[0] - r[2] - oob[3] = dim[1] - r[3] + oob[2] = bounds[0] - r[2] + oob[3] = bounds[1] - r[3] oob = np.array(oob) oob[oob > 0] = 0 # absolute amount @@ -151,16 +151,16 @@ class BBox: # threshold expanded rectangle r[0] = max(r[0], 0) r[1] = max(r[1], 0) - r[2] = min(r[2], dim[0]) - r[3] = min(r[3], dim[1]) + r[2] = min(r[2], bounds[0]) + r[3] = min(r[3], bounds[1]) # redistribute oob amounts oob = np.array([-oob[2], -oob[3], oob[0], oob[1]]) r = np.add(np.array(r), oob) # find overage oob[0] = min(r[0], 0) oob[1] = min(r[1], 0) - oob[2] = dim[0] - r[2] - oob[3] = dim[1] - r[3] + oob[2] = bounds[0] - r[2] + oob[3] = bounds[1] - r[3] oob = np.array(oob) oob[oob > 0] = 0 oob = np.absolute(oob) diff --git a/megapixels/app/processors/face_age.py b/megapixels/app/processors/face_age.py deleted file mode 100644 index 35174628..00000000 --- a/megapixels/app/processors/face_age.py +++ /dev/null @@ -1,28 +0,0 @@ -import os -from os.path import join -from pathlib import Path -import math - -import cv2 as cv -import numpy as np -import imutils - -from app.utils import im_utils, logger_utils -from app.models.bbox import BBox -from app.settings import app_cfg as cfg -from app.settings import types - - - -class FaceAge: - - # Estimates face age - - def __init__(self, gpu=0): - self.log = logger_utils.Logger.getLogger() - pass - - - def age(self, im, bbox_dim): - self.log.warn('not yet implemented') - return 0.0
\ No newline at end of file diff --git a/megapixels/app/processors/face_age_gender.py b/megapixels/app/processors/face_age_gender.py new file mode 100644 index 00000000..95efa8fc --- /dev/null +++ b/megapixels/app/processors/face_age_gender.py @@ -0,0 +1,116 @@ +''' +Uses models from: https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/ + +@article{Rothe-IJCV-2016, + author = {Rasmus Rothe and Radu Timofte and Luc Van Gool}, + title = {Deep expectation of real and apparent age from a single image without facial landmarks}, + journal = {International Journal of Computer Vision (IJCV)}, + year = {2016}, + month = {July}, +} +''' + +import os +from os.path import join +from pathlib import Path +import math + +import cv2 as cv +import numpy as np +import imutils + +from app.utils import im_utils, logger_utils +from app.models.bbox import BBox +from app.settings import app_cfg as cfg +from app.settings import types + + + +class _FaceAgeGender: + '''Predicts age from face crop + https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/ + ''' + + dnn_size = (224,224) + dnn_mean = (104.0, 177.0, 123.0) + ages = np.arange(0, 101).reshape(101, 1) + + def __init__(self, fp_prototxt, fp_model): + self.log = logger_utils.Logger.getLogger() + self.net = cv.dnn.readNetFromCaffe(fp_prototxt, fp_model) + + def _preprocess(self, im, bbox_dim): + # isolate face ROI, expand bbox by 40% according to authors + # https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/ + dim = im.shape[:2][::-1] + bbox_dim_exp = bbox_dim.expand_dim( int(0.4*bbox_dim.width), dim) + roi = bbox_dim_exp.to_xyxy() + im_face_crop = im[roi[1]:roi[3], roi[0]:roi[2]] # isolate face roi + + # resize for blob + im_resized = cv.resize(im_face_crop, self.dnn_size) + blob = cv.dnn.blobFromImage(im_resized, 1.0, self.dnn_size, self.dnn_mean) + return blob + +class FaceGender(_FaceAgeGender): + + # use "apparent" age models + fp_model = join(cfg.DIR_MODELS_CAFFE, 'gender', 'gender.caffemodel') + fp_prototxt = join(cfg.DIR_MODELS_CAFFE, 'gender', 'gender.prototxt') + + def __init__(self): + super().__init__(self.fp_prototxt, self.fp_model) + + def predict(self, im, bbox_dim): + '''Predicts gender from face crop + :param im: (numpy.ndarray) BGR image + :param bbox_dim: (BBox) dimensioned + :returns (dict) with scores for male and female + ''' + im_blob = self._preprocess(im, bbox_dim) + self.net.setInput(im_blob) + preds = self.net.forward()[0] + return {'f': preds[0], 'm': preds[1]} + +class FaceAgeApparent(_FaceAgeGender): + + # use "apparent" age models + fp_model = join(cfg.DIR_MODELS_CAFFE, 'age_apparent', 'dex_chalearn_iccv2015.caffemodel') + fp_prototxt = join(cfg.DIR_MODELS_CAFFE, 'age_apparent', 'age.prototxt') + + def __init__(self): + super().__init__(self.fp_prototxt, self.fp_model) + + def predict(self, im, bbox_dim): + '''Predicts apparent age from face crop + :param im: (numpy.ndarray) BGR image + :param bbox_dim: (BBox) dimensioned + :returns (float) predicted age + ''' + im_blob = self._preprocess(im, bbox_dim) + self.net.setInput(im_blob) + preds = self.net.forward()[0] + age = preds.dot(self.ages).flatten()[0] + return age + + +class FaceAgeReal(_FaceAgeGender): + + # use "real" age models + fp_model = join(cfg.DIR_MODELS_CAFFE, 'age_real', 'dex_imdb_wiki.caffemodel') + fp_prototxt = join(cfg.DIR_MODELS_CAFFE, 'age_real', 'age.prototxt') + + def __init__(self): + super().__init__(self.fp_prototxt, self.fp_model) + + def predict(self, im, bbox_dim): + '''Predicts apparent age from face crop + :param im: (numpy.ndarray) BGR image + :param bbox_dim: (BBox) dimensioned + :returns (float) predicted age + ''' + im_blob = self._preprocess(im, bbox_dim) + self.net.setInput(im_blob) + preds = self.net.forward()[0] + age = preds.dot(self.ages).flatten()[0] + return age
\ No newline at end of file diff --git a/megapixels/app/processors/face_gender.py b/megapixels/app/processors/face_gender.py deleted file mode 100644 index ea64b828..00000000 --- a/megapixels/app/processors/face_gender.py +++ /dev/null @@ -1,28 +0,0 @@ -import os -from os.path import join -from pathlib import Path -import math - -import cv2 as cv -import numpy as np -import imutils - -from app.utils import im_utils, logger_utils -from app.models.bbox import BBox -from app.settings import app_cfg as cfg -from app.settings import types - - - -class FaceGender: - - # Estimates face age - - def __init__(self, gpu=0): - self.log = logger_utils.Logger.getLogger() - pass - - - def gender(self, im, bbox_dim): - self.log.warn('not yet implemented') - return 0.0
\ No newline at end of file diff --git a/megapixels/app/utils/draw_utils.py b/megapixels/app/utils/draw_utils.py index cafac5a5..7083c956 100644 --- a/megapixels/app/utils/draw_utils.py +++ b/megapixels/app/utils/draw_utils.py @@ -43,7 +43,7 @@ def draw_pose(im, pt_nose, image_pts): def draw_text(im, pt, text, color=(0,255,0)): '''Draws degrees as text over image ''' - cv.putText(im, text, pt, cv.FONT_HERSHEY_SIMPLEX, 0.5, color, thickness=2, lineType=2) + cv.putText(im, text, pt, cv.FONT_HERSHEY_SIMPLEX, 0.75, color, thickness=1, lineType=cv.LINE_AA) def draw_degrees(im, pose_data, color=(0,255,0)): diff --git a/megapixels/commands/demo/face_age.py b/megapixels/commands/demo/face_age_gender.py index 45ae5190..477404a5 100644 --- a/megapixels/commands/demo/face_age.py +++ b/megapixels/commands/demo/face_age_gender.py @@ -37,7 +37,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils from app.utils import plot_utils - from app.processors import face_detector, face_age + from app.processors import face_detector, face_age_gender from app.models.data_store import DataStore @@ -68,25 +68,53 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): # ---------------------------------------------------------------------------- # age - age_predictor = face_age.FaceAge(gpu=opt_gpu) - age_score = age_predictor.age(im_resized, bbox_dim) + # real + age_real_predictor = face_age_gender.FaceAgeReal() + st = time.time() + age_real = age_real_predictor.predict(im_resized, bbox_dim) + log.info(f'age real took: {(time.time()-st)/1000:.5f}s') + + # apparent + age_apparent_predictor = face_age_gender.FaceAgeApparent() + st = time.time() + age_apparent = age_apparent_predictor.predict(im_resized, bbox_dim) + log.info(f'age apparent took: {(time.time()-st)/1000:.5f}s') + # gender + gender_predictor = face_age_gender.FaceGender() + st = time.time() + gender = gender_predictor.predict(im_resized, bbox_dim) + log.info(f'gender took: {(time.time()-st)/1000:.5f}s') # ---------------------------------------------------------------------------- # output log.info(f'Face coords: {bbox_dim} face') - log.info(f'age score: {(100*age_score):.2f}') + log.info(f'Age (real): {(age_real):.2f}') + log.info(f'Age (apparent): {(age_apparent):.2f}') + log.info(f'gender: {gender}') # ---------------------------------------------------------------------------- # draw - # draw 2d landmarks - im_age = im_resized.copy() - draw_utils.draw_bbox(im_age, bbox_dim) - txt = f'age score: {(100*age_score):.2f}' - draw_utils.draw_text(im_age, bbox_dim.pt_tl, txt) + # draw real age + im_age_real = im_resized.copy() + draw_utils.draw_bbox(im_age_real, bbox_dim) + txt = f'{(age_real):.2f}' + draw_utils.draw_text(im_age_real, bbox_dim.pt_tl, txt) + + # apparent age + im_age_apparent = im_resized.copy() + draw_utils.draw_bbox(im_age_apparent, bbox_dim) + txt = f'{(age_apparent):.2f}' + draw_utils.draw_text(im_age_apparent, bbox_dim.pt_tl, txt) + + # gender + im_gender = im_resized.copy() + draw_utils.draw_bbox(im_age_apparent, bbox_dim) + txt = f"M: {gender['m']:.2f}, F: {gender['f']:.2f}" + draw_utils.draw_text(im_gender, (10, dim[1]-20), txt) # ---------------------------------------------------------------------------- @@ -94,7 +122,16 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): if opt_fp_out: # save pose only - cv.imwrite(opt_fp_out, im_age) + fpp_out = Path(opt_fp_out) + + fp_out = join(fpp_out.parent, f'{fpp_out.stem}_real{fpp_out.suffix}') + cv.imwrite(fp_out, im_age_real) + + fp_out = join(fpp_out.parent, f'{fpp_out.stem}_apparent{fpp_out.suffix}') + cv.imwrite(fp_out, im_age_apparent) + + fp_out = join(fpp_out.parent, f'{fpp_out.stem}_gender{fpp_out.suffix}') + cv.imwrite(fp_out, im_age_apparent) # ---------------------------------------------------------------------------- @@ -102,5 +139,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): if opt_display: # show all images here - cv.imshow('age', im_age) + cv.imshow('real', im_age_real) + cv.imshow('apparent', im_age_apparent) + cv.imshow('gender', im_gender) display_utils.handle_keyboard()
\ No newline at end of file diff --git a/megapixels/commands/demo/face_gender.py b/megapixels/commands/demo/face_gender.py index 8e8c86f3..ea083fcb 100644 --- a/megapixels/commands/demo/face_gender.py +++ b/megapixels/commands/demo/face_gender.py @@ -7,12 +7,12 @@ from app.settings import app_cfg as cfg @click.command() @click.option('-i', '--input', 'opt_fp_in', default=None, required=True, - help='Imgender filepath') + help='Image filepath') @click.option('-o', '--output', 'opt_fp_out', default=None, help='GIF output path') @click.option('--size', 'opt_size', type=(int, int), default=(300, 300), - help='Output imgender size') + help='Output image size') @click.option('-g', '--gpu', 'opt_gpu', default=0, help='GPU index') @click.option('-f', '--force', 'opt_force', is_flag=True, @@ -37,7 +37,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): from app.utils import logger_utils, file_utils, im_utils, display_utils, draw_utils from app.utils import plot_utils - from app.processors import face_detector, face_gender + from app.processors import face_detector, face_age from app.models.data_store import DataStore @@ -45,7 +45,7 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): # ------------------------------------------------- - # load imgender + # load image im = cv.imread(opt_fp_in) im_resized = im_utils.resize(im, width=opt_size[0], height=opt_size[1]) @@ -66,27 +66,41 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): # ---------------------------------------------------------------------------- - # gender + # age - gender_predictor = face_gender.FaceGender(gpu=opt_gpu) - gender_score = gender_predictor.gender(im_resized, bbox_dim) + age_apparent_predictor = face_age.FaceAgeApparent() + age_real_predictor = face_age.FaceAgeReal() + + st = time.time() + age_real = age_real_predictor.age(im_resized, bbox_dim) + log.info(f'age real took: {(time.time()-st)/1000:.5f}s') + st = time.time() + age_apparent = age_apparent_predictor.age(im_resized, bbox_dim) + log.info(f'age apparent took: {(time.time()-st)/1000:.5f}s') # ---------------------------------------------------------------------------- # output log.info(f'Face coords: {bbox_dim} face') - log.info(f'gender score: {(100*gender_score):.2f}') + log.info(f'Age (real): {(age_real):.2f}') + log.info(f'Age (apparent): {(age_apparent):.2f}') # ---------------------------------------------------------------------------- # draw - # draw 2d landmarks - im_gender = im_resized.copy() - draw_utils.draw_bbox(im_gender, bbox_dim) - txt = f'gender score: {(100*gender_score):.2f}' - draw_utils.draw_text(im_gender, bbox_dim.pt_tl, txt) + # draw real age + im_age_real = im_resized.copy() + draw_utils.draw_bbox(im_age_real, bbox_dim) + txt = f'{(age_real):.2f}' + draw_utils.draw_text(im_age_real, bbox_dim.pt_tl, txt) + + # apparent + im_age_apparent = im_resized.copy() + draw_utils.draw_bbox(im_age_apparent, bbox_dim) + txt = f'{(age_apparent):.2f}' + draw_utils.draw_text(im_age_apparent, bbox_dim.pt_tl, txt) # ---------------------------------------------------------------------------- @@ -94,13 +108,20 @@ def cli(ctx, opt_fp_in, opt_fp_out, opt_gpu, opt_size, opt_force, opt_display): if opt_fp_out: # save pose only - cv.imwrite(opt_fp_out, im_gender) + fpp_out = Path(opt_fp_out) + + fp_out = join(fpp_out.parent, f'{fpp_out.stem}_real{fpp_out.suffix}') + cv.imwrite(fp_out, im_age_real) + + fp_out = join(fpp_out.parent, f'{fpp_out.stem}_apparent{fpp_out.suffix}') + cv.imwrite(fp_out, im_age_apparent) # ---------------------------------------------------------------------------- # display if opt_display: - # show all imgenders here - cv.imshow('gender', im_gender) + # show all images here + cv.imshow('real', im_age_real) + cv.imshow('apparent', im_age_apparent) display_utils.handle_keyboard()
\ No newline at end of file diff --git a/megapixels/notebooks/face_analysis/age_gender.ipynb b/megapixels/notebooks/face_analysis/age_gender.ipynb new file mode 100644 index 00000000..98a18fc6 --- /dev/null +++ b/megapixels/notebooks/face_analysis/age_gender.ipynb @@ -0,0 +1,278 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2\n", + "%matplotlib inline\n", + "import os\n", + "import sys\n", + "import math\n", + "from pathlib import Path\n", + "import random\n", + "from glob import glob\n", + "\n", + "from os.path import join\n", + "import os.path as osp\n", + "\n", + "import cv2 as cv\n", + "import numpy as np\n", + "from PIL import Image, ImageDraw\n", + "import matplotlib.pyplot as plt\n", + "import dlib\n", + "\n", + "sys.path.append('/work/megapixels_dev/megapixels/')\n", + "from app.settings import app_cfg as cfg\n", + "from app.models.bbox import BBox\n", + "from app.utils import file_utils, im_utils, draw_utils\n", + "from app.processors import face_detector" + ] + }, + { + "cell_type": "code", + "execution_count": 308, + "metadata": {}, + "outputs": [], + "source": [ + "# set proto/model filepaths\n", + "fp_prototxt_apparent = join(cfg.DIR_MODELS_CAFFE, 'age_apparent', 'age.prototxt')\n", + "fp_model_apparent = join(cfg.DIR_MODELS_CAFFE, 'age_apparent', 'dex_imdb_wiki.caffemodel')\n", + "\n", + "fp_prototxt_real = join(cfg.DIR_MODELS_CAFFE, 'age_real', 'age.prototxt')\n", + "fp_model_real = join(cfg.DIR_MODELS_CAFFE, 'age_real', 'dex_chalearn_iccv2015.caffemodel')\n", + "\n", + "fp_prototxt_gender = join(cfg.DIR_MODELS_CAFFE, 'gender', 'gender.prototxt')\n", + "fp_model_gender = join(cfg.DIR_MODELS_CAFFE, 'gender', 'gender.caffemodel')" + ] + }, + { + "cell_type": "code", + "execution_count": 309, + "metadata": {}, + "outputs": [], + "source": [ + "# create dnn net\n", + "net_apparent = cv.dnn.readNetFromCaffe(fp_prototxt_apparent, fp_model_apparent)\n", + "net_real = cv.dnn.readNetFromCaffe(fp_prototxt_real, fp_model_real)\n", + "net_gender = cv.dnn.readNetFromCaffe(fp_prototxt_gender, fp_model_gender)" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [], + "source": [ + "# create face detector\n", + "detector = face_detector.DetectorDLIBCNN()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# get list of images\n", + "dir_in = '/data_store_hdd/datasets/people/lfw/media/original/'\n", + "fp_ims = glob(join(dir_in, '**/*.jpg'), recursive=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 310, + "metadata": {}, + "outputs": [], + "source": [ + "def predict(im, net):\n", + " dnn_size = (224,224)\n", + " dnn_mean = (104.0, 177.0, 123.0)\n", + " blob = cv2.dnn.blobFromImage(cv.resize(im_face_crop, dnn_size), 1.0, dnn_size, dnn_mean)\n", + " net.setInput(blob)\n", + " outputs = net.forward()[0]\n", + " return outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 318, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loading /data_store_hdd/datasets/people/lfw/media/original/Sally_Ride/Sally_Ride_0002.jpg\n", + "[0.87139773 0.12860227]\n", + "real: 24.044405392869123, apparent: 27.50983550487581\n", + "gender: f, score: 87.14\n" + ] + }, + { + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7fb2aae5dd30>" + ] + }, + "execution_count": 318, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x432 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fp_im = np.random.choice(fp_ims)\n", + "print(f'loading {fp_im}')\n", + "fp_im = '/data_store_hdd/datasets/people/lfw/media/original/Winona_Ryder/Winona_Ryder_0012.jpg'\n", + "#fp_im = '/home/adam/Pictures/imdb_01.png'\n", + "im = cv.imread(fp_im)\n", + "bboxes = detector.detect(im, largest=True)\n", + "bbox = bboxes[0]\n", + "dim = im.shape[:2][::-1]\n", + "bbox_dim = bbox.to_dim(dim)\n", + "\n", + "# expand bbox by 40% according to https://data.vision.ee.ethz.ch/cvl/rrothe/imdb-wiki/\n", + "bbox_dim_exp = bbox_dim.expand_dim( int(0.4*bbox_dim.width), dim)\n", + "roi = bbox_dim_exp.to_xyxy()\n", + "im_face_crop = im[roi[1]:roi[3], roi[0]:roi[2]] # isolate face roi\n", + "\n", + "preds_real = predict(im_face_crop, net_real)\n", + "preds_apparent = predict(im_face_crop, net_apparent)\n", + "preds_gender = predict(im_face_crop, net_gender)\n", + "\n", + "print(preds_gender)\n", + "gender = 'f' if preds_gender[0] > 0.5 else 'm'\n", + "gender_score = preds_gender[0] if gender is 'f' else preds_gender[1]\n", + "\n", + "ages = np.arange(0, 101).reshape(101, 1)\n", + "# take dot product and make a single list out of lists\n", + "predicted_age_apparent = preds_apparent.dot(ages).flatten()[0]\n", + "predicted_age_real = preds_real.dot(ages).flatten()[0]\n", + "print(f'real: {predicted_age_real}, apparent: {predicted_\n", + " age_apparent}')\n", + "print(f'gender: {gender}, score: {100*gender_score:.2f}')\n", + "\n", + "# draw\n", + "im_face = im.copy()\n", + "draw_utils.draw_bbox(im_face, bbox_dim, color=(0,255,0))\n", + "draw_utils.draw_bbox(im_face, bbox_dim_exp, color=(0,255,255))\n", + "draw_utils.draw_text(im_face, (20,20), f'Real: {predicted_age_real:.2f}')\n", + "draw_utils.draw_text(im_face, (20,50), f'Apparent: {predicted_age_apparent:.2f}')\n", + "draw_utils.draw_text(im_face, (20,80), f'{gender.upper()}')\n", + "\n", + "# plot\n", + "plt.figure(figsize=(6,6))\n", + "plt.imshow(cv.cvtColor(im_face, cv.COLOR_BGR2RGB))" + ] + }, + { + "cell_type": "code", + "execution_count": 307, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.image.AxesImage at 0x7fb2ab0e65c0>" + ] + }, + "execution_count": 307, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(im_face_crop)\n", + "cv.FO" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "101\n", + "0.00034814802\n" + ] + } + ], + "source": [ + "print(len(preds))\n", + "print(preds[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.0000010269578485\n" + ] + } + ], + "source": [ + "age = sum([(float(age) * preds[age_idx]) for age_idx, pred in enumerate(preds)])\n", + "print(age)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:megapixels]", + "language": "python", + "name": "conda-env-megapixels-py" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/megapixels/notebooks/face_analysis/beauty.ipynb b/megapixels/notebooks/face_analysis/beauty.ipynb index fc557c99..d5da1cb2 100644 --- a/megapixels/notebooks/face_analysis/beauty.ipynb +++ b/megapixels/notebooks/face_analysis/beauty.ipynb @@ -173,7 +173,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.6.6" } }, "nbformat": 4, |
