1. Panoramica
L'API Vision consente agli sviluppatori di integrare facilmente funzionalità di rilevamento visivo nelle applicazioni, tra cui etichettatura delle immagini, riconoscimento facciale e dei punti di riferimento, riconoscimento ottico dei caratteri (OCR) e tagging dei contenuti espliciti.
In questo tutorial ti concentrerai sull'utilizzo dell'API Vision con Python.
Cosa imparerai a fare
- Come configurare l'ambiente
- Come eseguire il rilevamento etichette
- Come eseguire il rilevamento del testo
- Come eseguire il rilevamento di punti di riferimento
- Come eseguire il riconoscimento facciale
- Come eseguire il rilevamento di oggetti
Che cosa ti serve
- Un progetto Google Cloud
- Un browser, ad esempio Chrome o Firefox
- Familiarità con l'utilizzo di Python
Sondaggio
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con Python?
Come valuteresti la tua esperienza con i servizi Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente autonomo
- Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.
- Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come
PROJECT_ID). Se non ti piace l'ID generato, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono usufruire del programma prova senza costi di 300$.
Avvia Cloud Shell
Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo codelab utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Attiva Cloud Shell
- Nella console Cloud, fai clic su Attiva Cloud Shell
.
Se è la prima volta che avvii Cloud Shell, viene visualizzata una schermata intermedia che ne descrive le funzionalità. Se è stata visualizzata una schermata intermedia, fai clic su Continua.
Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.
Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Gran parte del lavoro per questo codelab, se non tutto, può essere svolto con un browser.
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è autenticato e il progetto è impostato sul tuo ID progetto.
- Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:
gcloud auth list
Output comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Esegui questo comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto:
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
In caso contrario, puoi impostarlo con questo comando:
gcloud config set project <PROJECT_ID>
Output comando
Updated property [core/project].
3. Configurazione dell'ambiente
Prima di poter iniziare a utilizzare l'API Vision, esegui il seguente comando in Cloud Shell per abilitare l'API:
gcloud services enable vision.googleapis.com
Il risultato dovrebbe essere simile a questo:
Operation "operations/..." finished successfully.
Ora puoi utilizzare l'API Vision.
Vai alla home directory:
cd ~
Crea un ambiente virtuale Python per isolare le dipendenze:
virtualenv venv-vision
Attiva l'ambiente virtuale:
source venv-vision/bin/activate
Installa IPython e la libreria client dell'API Vision:
pip install ipython google-cloud-vision
Il risultato dovrebbe essere simile a questo:
... Installing collected packages: ..., ipython, google-cloud-vision Successfully installed ... google-cloud-vision-3.4.0 ...
Ora puoi utilizzare la libreria client dell'API Vision.
Nei passaggi successivi, utilizzerai un interprete Python interattivo chiamato IPython, che hai installato nel passaggio precedente. Avvia una sessione eseguendo ipython in Cloud Shell:
ipython
Il risultato dovrebbe essere simile a questo:
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]:
Ora puoi effettuare la tua prima richiesta…
4. Eseguire il rilevamento etichette
Una delle funzionalità principali dell'API Vision è l'identificazione di oggetti o entità in un'immagine, nota come annotazione di etichette. Il rilevamento etichette identifica oggetti generici, località, attività, specie animali, prodotti e altro ancora. L'API Vision prende un'immagine di input e restituisce le etichette più probabili che si applicano a quell'immagine. Restituisce le etichette con la corrispondenza migliore insieme a un punteggio di confidenza di una corrispondenza con l'immagine.
In questo esempio, eseguirai il rilevamento delle etichette su un'immagine (per gentile concessione di Alex Knight) di Setagaya, un quartiere popolare di Tokyo:
Copia il seguente codice nella sessione 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=" | ",
)
Dedica qualche istante a studiare il codice e a capire come utilizza il metodo della libreria client annotate_image per analizzare un'immagine in base a un insieme di funzionalità specificate.
Invia una richiesta con la funzionalità 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)
Dovrebbe essere visualizzato il seguente output:
================================================================================ 97% | Bicycle 96% | Tire 94% | Wheel 91% | Automotive lighting 89% | Infrastructure 87% | Bicycle wheel 86% | Mode of transport 85% | Building 83% | Electricity 82% | Neighbourhood
Ecco come vengono presentati i risultati dalla demo online:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento etichette su un'immagine e visualizzare le etichette più probabili associate a quell'immagine. Scopri di più sul rilevamento delle etichette.
5. Eseguire il rilevamento del testo
Il rilevamento del testo esegue il riconoscimento ottico dei caratteri (OCR). Rileva ed estrae il testo all'interno di un'immagine con il supporto di una vasta gamma di lingue. Inoltre, è disponibile l'identificazione automatica della lingua.
In questo esempio, eseguirai il rilevamento del testo su un'immagine di un segnale stradale:
Copia il seguente codice nella sessione 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=" | ",
)
Invia una richiesta con la funzionalità 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)
Dovrebbe essere visualizzato il seguente output:
================================================================================ '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)
Ecco come vengono presentati i risultati dalla demo online:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento del testo in un'immagine e visualizzare il testo riconosciuto. Scopri di più sul rilevamento del testo.
6. Eseguire il rilevamento di punti di riferimento
Il rilevamento dei punti di riferimento rileva strutture naturali e artificiali note all'interno di un'immagine.
In questo esempio, eseguirai il rilevamento dei punti di riferimento su un'immagine (per gentile concessione di John Towner) della Torre Eiffel:
Copia il seguente codice nella sessione 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=" | ",
)
Invia una richiesta con la funzionalità 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)
Dovrebbe essere visualizzato il seguente output:
================================================================================ 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
Ecco come vengono presentati i risultati dalla demo online:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento dei punti di riferimento su un'immagine della Torre Eiffel. Scopri di più sul rilevamento dei punti di riferimento.
7. Eseguire il riconoscimento facciale
Il rilevamento delle caratteristiche facciali rileva più volti all'interno di un'immagine, oltre agli attributi facciali principali associati, ad esempio lo stato emotivo o un copricapo indossato.
In questo esempio, rileverai i volti nella seguente immagine (per gentile concessione di Himanshu Singh Gurjar):
Copia il seguente codice nella sessione 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)
Invia una richiesta con la funzionalità 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)
Dovrebbe essere visualizzato il seguente output:
================================================================================ # 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 --------------------------------------------------------------------------------
Ecco come vengono presentati i risultati dalla demo online:
Riepilogo
In questo passaggio, hai potuto eseguire il riconoscimento facciale. Scopri di più sul rilevamento dei volti.
8. Eseguire il rilevamento di oggetti
In questo esempio, eseguirai il rilevamento di oggetti sulla stessa immagine precedente (per gentile concessione di Alex Knight) di Setagaya:
Copia il seguente codice nella sessione 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=" | ",
)
Invia una richiesta con la funzionalità 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)
Dovrebbe essere visualizzato il seguente output:
================================================================================ 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)
Ecco come vengono presentati i risultati dalla demo online:
Riepilogo
In questo passaggio, hai potuto eseguire il rilevamento degli oggetti. Scopri di più sul rilevamento degli oggetti.
9. Più funzionalità
Hai visto come utilizzare alcune funzionalità dell'API Vision, ma ce ne sono molte altre e puoi richiedere più funzionalità in un'unica richiesta.
Ecco il tipo di richiesta che puoi fare per ottenere tutti gli approfondimenti contemporaneamente:
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)
E ci sono altre possibilità, come eseguire rilevamenti su un batch di immagini, in modo sincrono o asincrono. Dai un'occhiata a tutte le guide illustrative.
10. Complimenti!
Hai imparato a utilizzare l'API Vision con Python e hai testato alcune funzionalità di rilevamento delle immagini.
Esegui la pulizia
Per pulire l'ambiente di sviluppo, da Cloud Shell:
- Se sei ancora nella sessione IPython, torna alla shell:
exit - Interrompi l'utilizzo dell'ambiente virtuale Python:
deactivate - Elimina la cartella dell'ambiente virtuale:
cd ~ ; rm -rf ./venv-vision
Per eliminare il progetto Google Cloud, da Cloud Shell:
- Recupera l'ID progetto corrente:
PROJECT_ID=$(gcloud config get-value core/project) - Assicurati che sia il progetto che vuoi eliminare:
echo $PROJECT_ID - Elimina il progetto:
gcloud projects delete $PROJECT_ID
Scopri di più
- Prova la demo online nel tuo browser: https://cloud.google.com/vision
- Documentazione dell'API Vision: https://cloud.google.com/vision/docs
- Python su Google Cloud: https://cloud.google.com/python
- Librerie client di Cloud per Python: https://github.com/googleapis/google-cloud-python
Licenza
Questo lavoro è concesso in licenza ai sensi di una licenza Creative Commons Attribution 2.0 Generic.