1. Descripción general
La API de Vision les permite a los desarrolladores integrar con facilidad funciones de detección de visión en las aplicaciones, como etiquetado de imágenes, detección de rostros y puntos de referencia, reconocimiento óptico de caracteres (OCR) y etiquetado de contenido explícito.
En este instructivo, te enfocarás en el uso de la API de Vision con Python.
Qué aprenderás
- Cómo configurar tu entorno
- Cómo realizar la detección de etiquetas
- Cómo realizar una detección de texto
- Cómo detectar puntos de referencia
- Cómo realizar la detección de rostro
- Cómo realizar la detección de objetos
Requisitos
Encuesta
¿Cómo usarás este instructivo?
¿Cómo calificarías tu experiencia en Python?
¿Cómo calificarías tu experiencia con los servicios de Google Cloud?
2. Configuración y requisitos
Configuración del entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.
Inicia Cloud Shell
Si bien Google Cloud se puede operar de manera remota desde tu laptop, en este codelab usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
Activar Cloud Shell
- En la consola de Cloud, haz clic en Activar Cloud Shell
.
Si es la primera vez que inicias Cloud Shell, verás una pantalla intermedia que describe en qué consiste. Si apareció una pantalla intermedia, haz clic en Continuar.
El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.
Esta máquina virtual está cargada con todas las herramientas de desarrollo necesarias. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que mejora considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer con un navegador.
Una vez que te conectes a Cloud Shell, deberías ver que estás autenticado y que el proyecto está configurado con tu ID del proyecto.
- En Cloud Shell, ejecuta el siguiente comando para confirmar que tienes la autenticación:
gcloud auth list
Resultado del comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Ejecuta el siguiente comando en Cloud Shell para confirmar que el comando de gcloud conoce tu proyecto:
gcloud config list project
Resultado del comando
[core] project = <PROJECT_ID>
De lo contrario, puedes configurarlo con el siguiente comando:
gcloud config set project <PROJECT_ID>
Resultado del comando
Updated property [core/project].
3. Configuración del entorno
Antes de comenzar a usar la API de Vision, ejecuta el siguiente comando en Cloud Shell para habilitarla:
gcloud services enable vision.googleapis.com
Debería ver algo como esto:
Operation "operations/..." finished successfully.
Ahora, puedes usar la API de Vision.
Navega a tu directorio principal:
cd ~
Crea un entorno virtual de Python para aislar las dependencias:
virtualenv venv-vision
Activa el entorno virtual:
source venv-vision/bin/activate
Instala IPython y la biblioteca cliente de la API de Vision:
pip install ipython google-cloud-vision
Debería ver algo como esto:
... Installing collected packages: ..., ipython, google-cloud-vision Successfully installed ... google-cloud-vision-3.4.0 ...
Ya tienes todo listo para usar la biblioteca cliente de la API de Vision.
En los siguientes pasos, usarás un intérprete de Python interactivo llamado IPython, que instalaste en el paso anterior. Para iniciar una sesión, ejecuta ipython en Cloud Shell:
ipython
Debería ver algo como esto:
Python 3.9.2 (default, Feb 28 2021, 17:03:44) Type 'copyright', 'credits' or 'license' for more information IPython 8.12.0 -- An enhanced Interactive Python. Type '?' for help. In [1]:
Ya puedes realizar tu primera solicitud...
4. Realiza la detección de etiquetas
Una de las funciones principales de la API de Vision es identificar objetos o entidades en una imagen, lo que se conoce como anotación de etiquetas. La detección de etiquetas identifica objetos generales, ubicaciones, actividades, especies de animales, productos y mucho más. La API de Vision toma una imagen de entrada y muestra las etiquetas más probables que se aplican a esa imagen. Devuelve las etiquetas de mayor coincidencia junto con la puntuación de confianza de una coincidencia con la imagen.
En este ejemplo, realizarás la detección de etiquetas en una imagen (cortesía de Alex Knight) de Setagaya, un distrito popular de Tokio:
Copia el siguiente código en tu sesión de IPython:
from typing import Sequence
from google.cloud import vision
def analyze_image_from_uri(
image_uri: str,
feature_types: Sequence,
) -> vision.AnnotateImageResponse:
client = vision.ImageAnnotatorClient()
image = vision.Image()
image.source.image_uri = image_uri
features = [vision.Feature(type_=feature_type) for feature_type in feature_types]
request = vision.AnnotateImageRequest(image=image, features=features)
response = client.annotate_image(request=request)
return response
def print_labels(response: vision.AnnotateImageResponse):
print("=" * 80)
for label in response.label_annotations:
print(
f"{label.score:4.0%}",
f"{label.description:5}",
sep=" | ",
)
Tómate un momento para estudiar el código y ver cómo usa el método de la biblioteca cliente annotate_image para analizar una imagen de un conjunto de funciones determinadas.
Envía una solicitud con la función LABEL_DETECTION:
image_uri = "gs://cloud-samples-data/vision/label/setagaya.jpeg"
features = [vision.Feature.Type.LABEL_DETECTION]
response = analyze_image_from_uri(image_uri, features)
print_labels(response)
Deberías obtener el siguiente resultado:
================================================================================ 97% | Bicycle 96% | Tire 94% | Wheel 91% | Automotive lighting 89% | Infrastructure 87% | Bicycle wheel 86% | Mode of transport 85% | Building 83% | Electricity 82% | Neighbourhood
La demostración en línea presenta los resultados de la siguiente manera:
Resumen
En este paso, pudiste realizar la detección de etiquetas en una imagen y mostrar las etiquetas más probables asociadas a ella. Obtén más información sobre la detección de etiquetas.
5. Realiza la detección de texto
La detección de texto realiza un reconocimiento óptico de caracteres (OCR). Detecta y extrae texto de una imagen compatible con una amplia variedad de idiomas. También cuenta con identificación automática de idiomas.
En este ejemplo, realizarás la detección de texto en una imagen de una señal de tráfico:
Copia el siguiente código en tu sesión de IPython:
def print_text(response: vision.AnnotateImageResponse):
print("=" * 80)
for annotation in response.text_annotations:
vertices = [f"({v.x},{v.y})" for v in annotation.bounding_poly.vertices]
print(
f"{repr(annotation.description):42}",
",".join(vertices),
sep=" | ",
)
Envía una solicitud con la función TEXT_DETECTION:
image_uri = "gs://cloud-samples-data/vision/ocr/sign.jpg"
features = [vision.Feature.Type.TEXT_DETECTION]
response = analyze_image_from_uri(image_uri, features)
print_text(response)
Deberías obtener el siguiente resultado:
================================================================================ 'WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE' | (310,821),(2225,821),(2225,1965),(310,1965) 'WAITING' | (344,821),(2025,879),(2016,1127),(335,1069) '?' | (2057,881),(2225,887),(2216,1134),(2048,1128) 'PLEASE' | (1208,1230),(1895,1253),(1891,1374),(1204,1351) 'TURN' | (1217,1414),(1718,1434),(1713,1558),(1212,1538) 'OFF' | (1787,1437),(2133,1451),(2128,1575),(1782,1561) 'YOUR' | (1211,1609),(1741,1626),(1737,1747),(1207,1731) 'ENGINE' | (1213,1805),(1923,1819),(1920,1949),(1210,1935)
La demostración en línea presenta los resultados de la siguiente manera:
Resumen
En este paso, pudiste realizar una detección de texto en una imagen y mostrar el texto reconocido en ella. Obtén más información sobre la detección de texto.
6. Realiza la detección de puntos de referencia
La detección de puntos de referencia detecta estructuras populares naturales y creadas por el hombre en una imagen.
En este ejemplo, detectarás puntos de referencia en una imagen (cortesía de John Towner) de la Torre Eiffel:
Copia el siguiente código en tu sesión de IPython:
def print_landmarks(response: vision.AnnotateImageResponse, min_score: float = 0.5):
print("=" * 80)
for landmark in response.landmark_annotations:
if landmark.score < min_score:
continue
vertices = [f"({v.x},{v.y})" for v in landmark.bounding_poly.vertices]
lat_lng = landmark.locations[0].lat_lng
print(
f"{landmark.description:18}",
",".join(vertices),
f"{lat_lng.latitude:.5f}",
f"{lat_lng.longitude:.5f}",
sep=" | ",
)
Envía una solicitud con la función LANDMARK_DETECTION:
image_uri = "gs://cloud-samples-data/vision/landmark/eiffel_tower.jpg"
features = [vision.Feature.Type.LANDMARK_DETECTION]
response = analyze_image_from_uri(image_uri, features)
print_landmarks(response)
Deberías obtener el siguiente resultado:
================================================================================ Trocadéro Gardens | (303,36),(520,36),(520,371),(303,371) | 48.86160 | 2.28928 Eiffel Tower | (458,76),(512,76),(512,263),(458,263) | 48.85846 | 2.29435
La demostración en línea presenta los resultados de la siguiente manera:
Resumen
En este paso, pudiste detectar puntos de referencia en una imagen de la Torre Eiffel. Obtén más información sobre la detección de puntos de referencia.
7. Realiza la detección de rostro
La detección de rasgos faciales detecta varios rostros en una imagen junto con los atributos faciales clave asociados, como el estado emocional o el uso de accesorios.
En este ejemplo, detectarás rostros en la siguiente imagen (cortesía de Himanshu Singh Gurjar):
Copia el siguiente código en tu sesión de IPython:
def print_faces(response: vision.AnnotateImageResponse):
print("=" * 80)
for face_number, face in enumerate(response.face_annotations, 1):
vertices = ",".join(f"({v.x},{v.y})" for v in face.bounding_poly.vertices)
print(f"# Face {face_number} @ {vertices}")
print(f"Joy: {face.joy_likelihood.name}")
print(f"Exposed: {face.under_exposed_likelihood.name}")
print(f"Blurred: {face.blurred_likelihood.name}")
print("-" * 80)
Envía una solicitud con la función FACE_DETECTION:
image_uri = "gs://cloud-samples-data/vision/face/faces.jpeg"
features = [vision.Feature.Type.FACE_DETECTION]
response = analyze_image_from_uri(image_uri, features)
print_faces(response)
Deberías obtener el siguiente resultado:
================================================================================ # Face 1 @ (1077,157),(2146,157),(2146,1399),(1077,1399) Joy: VERY_LIKELY Exposed: VERY_UNLIKELY Blurred: VERY_UNLIKELY -------------------------------------------------------------------------------- # Face 2 @ (144,1273),(793,1273),(793,1844),(144,1844) Joy: VERY_UNLIKELY Exposed: VERY_UNLIKELY Blurred: UNLIKELY -------------------------------------------------------------------------------- # Face 3 @ (785,167),(1100,167),(1100,534),(785,534) Joy: VERY_UNLIKELY Exposed: LIKELY Blurred: VERY_LIKELY --------------------------------------------------------------------------------
La demostración en línea presenta los resultados de la siguiente manera:
Resumen
En este paso, pudiste realizar la detección de rostro. Obtén más información sobre la detección de rostros.
8. Realiza la detección de objetos
En este ejemplo, realizarás la detección de objetos en la misma imagen anterior (cortesía de Alex Knight) de Setagaya:
Copia el siguiente código en tu sesión de IPython:
def print_objects(response: vision.AnnotateImageResponse):
print("=" * 80)
for obj in response.localized_object_annotations:
nvertices = obj.bounding_poly.normalized_vertices
print(
f"{obj.score:4.0%}",
f"{obj.name:15}",
f"{obj.mid:10}",
",".join(f"({v.x:.1f},{v.y:.1f})" for v in nvertices),
sep=" | ",
)
Envía una solicitud con la función OBJECT_LOCALIZATION:
image_uri = "gs://cloud-samples-data/vision/label/setagaya.jpeg"
features = [vision.Feature.Type.OBJECT_LOCALIZATION]
response = analyze_image_from_uri(image_uri, features)
print_objects(response)
Deberías obtener el siguiente resultado:
================================================================================ 93% | Bicycle | /m/0199g | (0.6,0.6),(0.8,0.6),(0.8,0.9),(0.6,0.9) 92% | Bicycle wheel | /m/01bqk0 | (0.6,0.7),(0.7,0.7),(0.7,0.9),(0.6,0.9) 91% | Tire | /m/0h9mv | (0.7,0.7),(0.8,0.7),(0.8,1.0),(0.7,1.0) 75% | Bicycle | /m/0199g | (0.3,0.6),(0.4,0.6),(0.4,0.7),(0.3,0.7) 51% | Tire | /m/0h9mv | (0.3,0.6),(0.4,0.6),(0.4,0.7),(0.3,0.7)
La demostración en línea presenta los resultados de la siguiente manera:
Resumen
En este paso, pudiste realizar la detección de objetos. Obtén más información sobre la detección de objetos.
9. Varias funciones
Ya viste cómo usar algunas funciones de la API de Vision, pero hay muchas más y puedes solicitar varias funciones en una sola solicitud.
Este es el tipo de solicitud que puedes realizar para obtener todas las estadísticas a la vez:
image_uri = "gs://..."
features = [
vision.Feature.Type.OBJECT_LOCALIZATION,
vision.Feature.Type.FACE_DETECTION,
vision.Feature.Type.LANDMARK_DETECTION,
vision.Feature.Type.LOGO_DETECTION,
vision.Feature.Type.LABEL_DETECTION,
vision.Feature.Type.TEXT_DETECTION,
vision.Feature.Type.DOCUMENT_TEXT_DETECTION,
vision.Feature.Type.SAFE_SEARCH_DETECTION,
vision.Feature.Type.IMAGE_PROPERTIES,
vision.Feature.Type.CROP_HINTS,
vision.Feature.Type.WEB_DETECTION,
vision.Feature.Type.PRODUCT_SEARCH,
vision.Feature.Type.OBJECT_LOCALIZATION,
]
# response = analyze_image_from_uri(image_uri, features)
Y existen más posibilidades, como realizar detecciones en un lote de imágenes, de forma síncrona o asíncrona. Consulta todas las guías prácticas.
10. ¡Felicitaciones!
Aprendiste a usar la API de Vision con Python y probaste algunas funciones de detección de imágenes.
Limpia
Para limpiar tu entorno de desarrollo, desde Cloud Shell, haz lo siguiente:
- Si aún estás en la sesión de IPython, vuelve a la shell:
exit - Deja de usar el entorno virtual de Python:
deactivate - Borra tu carpeta de entorno virtual:
cd ~ ; rm -rf ./venv-vision
Para borrar tu proyecto de Google Cloud de Cloud Shell, haz lo siguiente:
- Recupera el ID de tu proyecto actual:
PROJECT_ID=$(gcloud config get-value core/project) - Asegúrate de que este sea el proyecto que quieres borrar:
echo $PROJECT_ID - Borrar el proyecto:
gcloud projects delete $PROJECT_ID
Más información
- Prueba la demostración en línea en tu navegador: https://cloud.google.com/vision
- Documentación de la API de Vision: https://cloud.google.com/vision/docs
- Python en Google Cloud: https://cloud.google.com/python
- Bibliotecas cliente de Cloud para Python: https://github.com/googleapis/google-cloud-python
Licencia
Este trabajo cuenta con una licencia Atribución 2.0 Genérica de Creative Commons.