API de reconnaissance faciale sans serveur conçue avec Python
Cet article est l'article du 16e jour de Python-AdventCalandar-2016.
Bonjour. Jouez-vous à Python? Reconnaissez-vous votre visage? Êtes-vous sans serveur?
Cet article s'adresse à ceux qui souhaitent configurer facilement un serveur d'API de reconnaissance faciale en Python. Je pensais écrire une histoire académique sur le calendrier de l'Avent, mais j'ai choisi ce sujet parce que le timing était bon.
Tout d'abord, je vais le déclarer, mais cette fois, je vais utiliser pleinement AWS.
À propos de la reconnaissance faciale
C'est très facile à faire avec OpenCV, mais cette fois, nous utiliserons pleinement AWS! Je vais donc utiliser le service "Amazon Rekognition" annoncé lors de re: invent de cette année.
En un mot, c'est un excellent service qui peut reconnaître et rechercher des objets et des visages avec une grande précision (divers)
Pour plus d'informations, veuillez visiter https://aws.amazon.com/jp/rekognition/.
La liste de prix est la suivante. Veuillez noter que plus vous l'utilisez, plus cela vous coûtera cher.
https://aws.amazon.com/jp/rekognition/pricing/
À propos de l'architecture sans serveur
Dans AWS, l'architecture sans serveur est «API Gateway + Lambda».
Cette fois, nous allons les gérer à l'aide d'une bibliothèque appelée "Chalice" réalisée par Python.
https://github.com/awslabs/chalice
Essayez d'utiliser Chalice
Essayons "bonjour le monde" pour le moment en utilisant la commande calice.
$ pip install chalice
#Veuillez utiliser un nom de projet approprié pour la pièce freko
$ chalice new-project freko && cd freko
$ cat app.py
from chalice import Chalice
app = Chalice(app_name="helloworld")
@app.route("/")
def index():
return {"hello": "world"}
$ chalice deploy
...
Your application is available at: https://endpoint/dev
$ curl https://endpoint/dev
{"hello": "world"}
Une fois cela fait, tout ce que vous avez à faire est d'accéder aux API S3 et Rekognition.
Utiliser l'API AWS
Paramètres AWS
Je suis sûr que beaucoup de gens l'ont déjà créé, mais utilisez d'abord ʻaws-cli` pour exporter les paramètres.
Dans cet échantillon, nous avons sélectionné «eu-west-1» comme région. Toute région prise en charge par Rekognition fera l'affaire.
$ pip install awscli
$ aws configure
https://github.com/aws/aws-cli
Installez également l'AWS-SDK créé par Python appelé boto3.
$ pip install boto3
https://github.com/boto/boto3
Télécharger des images sur S3
Comme il est gênant de le faire avec l'interface graphique, je vais tout faire avec l'API.
REGION = 'eu-west-1'
BUCKET = 'freko-default'
S3 = boto3.resource('s3')
#Créer un compartiment dans S3 si le nom de compartiment spécifié n'existe pas
def create_s3_bucket_if_not_exists():
exists = True
try:
S3.meta.client.head_bucket(Bucket=BUCKET)
except botocore.exceptions.ClientError as ex:
error_code = int(ex.response['Error']['Code'])
if error_code == 404:
exists = False
if exists:
return
else:
try:
S3.create_bucket(Bucket=BUCKET, CreateBucketConfiguration={
'LocationConstraint': REGION})
except Exception as ex:
raise ChaliceViewError("fail to create bucket s3. error = " + ex.message)
return
#Téléchargez le fichier sur S3
def upload_file_s3_bucket(obj_name, image_file_name):
try:
s3_object = S3.Object(BUCKET, obj_name)
s3_object.upload_file(image_file_name)
except Exception as ex:
raise ChaliceViewError("fail to upload file s3. error = " + ex.message)
Reconnaissance faciale à l'aide de l'API ReKognition
REKOGNITION = boto3.client('rekognition')
#Reconnaissance faciale en spécifiant le fichier dans le compartiment S3
def detect_faces(name):
try:
response = REKOGNITION.detect_faces(
Image={
'S3Object': {
'Bucket': BUCKET,
'Name': name,
}
},
Attributes=[
'DEFAULT',
]
)
return response
except Exception as ex:
raise ChaliceViewError("fail to detect faces. error = " + ex.message)
Vous pouvez obtenir plus d'informations en spécifiant «ALL» pour les attributs.
Changer de politique
Chalice examine l'API utilisée dans le code au moment du déploiement et définit la stratégie sans autorisation, mais comme il s'agit toujours d'une version préliminaire, il semble qu'elle ne prend pas en charge toutes les API. Il n'a pas lu ʻupload_file` etc. utilisé lors du téléchargement du fichier sur S3. ..
Ajoutez S3 et ReKognition à Statement dans policy.json. (Parce que c'est pour tester, je le fais plein)
$ vim .chalice/policy.json
"Statement": [
{
"Action": [
"s3:*"
],
"Resource": "*",
"Effect": "Allow"
},
{
"Action": [
"rekognition:*"
],
"Resource": "*",
"Effect": "Allow"
}
...
]
La commande à déployer sans générer automatiquement de stratégie est: Faisons un Makefile approprié et enregistrons-le.
$ chalice deploy --no-autogen-policy
Définir la clé API
J'ai peur de pouvoir atteindre le point de terminaison autant que je veux, donc je vais mettre en authentification par clé API et demander une restriction pour le moment.
Pour plus d'informations, veuillez visiter http://docs.aws.amazon.com/ja_jp/apigateway/latest/developerguide/how-to-api-keys.html.
Dans Chalice, si vous définissez ʻapi_key_required = True`, vous aurez une API qui nécessite une authentification par clé API.
@app.route('/face', methods=['POST'], content_types=['application/json'], api_key_required=True)
Essayez de frapper l'API déployée
J'utiliserai Lena pour le test.
Pour les paramètres API, entrez name = nom de fichier, base64 = une chaîne d'images encodée en base64.
Veuillez définir vous-même la clé API et l'URL.
$ (echo -n '{"name":"lenna.jpg ", "base64": "'; base64 lenna.jpg; echo '"}') | curl -H "x-api-key:your-api-key" -H "Content-Type:application/json" -d @- https://your-place.execute-api.eu-west-1.amazonaws.com/dev/face | jq
Si vous souhaitez simplement déterminer si l'image a un visage, il suffit de voir si FaceDetails a une valeur et si la valeur && Confidence est élevée.
{
"exists": true,
"response": {
"FaceDetails": [
{
"BoundingBox": {
"Width": 0.4585798680782318,
"Top": 0.3210059106349945,
"Left": 0.34467455744743347,
"Height": 0.4585798680782318
},
"Landmarks": [
{
"Y": 0.501218318939209,
"X": 0.5236561894416809,
"Type": "eyeLeft"
},
{
"Y": 0.50351482629776,
"X": 0.6624458432197571,
"Type": "eyeRight"
},
{
"Y": 0.5982820391654968,
"X": 0.6305037140846252,
"Type": "nose"
},
{
"Y": 0.6746630072593689,
"X": 0.521257758140564,
"Type": "mouthLeft"
},
{
"Y": 0.6727028489112854,
"X": 0.6275562644004822,
"Type": "mouthRight"
}
],
"Pose": {
"Yaw": 30.472450256347656,
"Roll": -1.429526448249817,
"Pitch": -5.346992015838623
},
"Quality": {
"Sharpness": 160,
"Brightness": 36.45581817626953
},
"Confidence": 99.94509887695312
}
],
"ResponseMetadata": {
...
},
"OrientationCorrection": "ROTATE_0"
}
}
À propos, si le visage n'est pas reconnu, la réponse sera la suivante.
{
"exists": false,
"response": {
"FaceDetails": [],
"ResponseMetadata": {
...
}
}
}
finalement
C'est devenu un article comme comment utiliser AWS-SDK ... Sans y réfléchir, j'aimerais faire quelque chose de cool comme appeler Rekognition la prochaine fois qu'il sera mis sur S3.
Le code complet est ci-dessous. Je suis heureux que vous puissiez l'utiliser comme référence.
https://github.com/gotokatsuya/freko
Recommended Posts