1. Panoramica
L'API Vision consente agli sviluppatori di integrare facilmente le funzionalità di rilevamento visivo nelle applicazioni, tra cui etichettatura delle immagini, rilevamento di volti e 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 dei punti di riferimento
- Come eseguire il rilevamento dei volti
- Come eseguire il rilevamento di oggetti
Che cosa ti serve
- Un progetto Google Cloud
- Un browser, ad esempio Chrome o Firefox
- Dimestichezza nell'utilizzo di Python
Sondaggio
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con Python?
Come giudichi la tua esperienza con i servizi Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo 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 progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
- L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come
PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto. - Per informazione, c'è un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.
- Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.
Avvia Cloud Shell
Mentre Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Attiva Cloud Shell
- Dalla console Cloud, fai clic su Attiva Cloud Shell
.
Se è la prima volta che avvii Cloud Shell, ti verrà mostrata una schermata intermedia che descrive di cosa si tratta. Se ti è stata presentata una schermata intermedia, fai clic su Continua.
Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.
Questa macchina virtuale viene 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 di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto con un browser.
Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai eseguito l'autenticazione e che 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 confermare che il comando gcloud è a conoscenza del 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 questo 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.
Passa alla tua 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 è tutto pronto per 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]:
Sei pronto per effettuare la tua prima richiesta...
4. Esegui rilevamento etichette
Una delle funzionalità principali dell'API Vision è l'identificazione di oggetti o entità in un'immagine, nota come annotazione delle etichette. Il rilevamento etichette identifica oggetti generici, luoghi, attività, specie animali, prodotti e altro ancora. L'API Vision prende un'immagine di input e restituisce le etichette più probabili applicabili a quell'immagine. Restituisce le etichette con maggiore corrispondenza insieme al 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 famoso distretto di Tokyo:
Copia il seguente codice nella tua 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 un momento a studiare il codice e vedere come utilizza il metodo della libreria client annotate_image per analizzare un'immagine per un insieme di determinate funzionalità.
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, sei stato in grado di eseguire il rilevamento di etichette su un'immagine e visualizzare le etichette più probabili associate a quell'immagine. Scopri di più sul rilevamento delle etichette.
5. Esegui rilevamento 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 dotata di identificazione automatica della lingua.
In questo esempio, eseguirai il rilevamento del testo sull'immagine di un segnale stradale:
Copia il seguente codice nella tua 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 su un'immagine e visualizzare il testo riconosciuto dall'immagine. Scopri di più sul rilevamento del testo.
6. Esegui rilevamento dei punti di riferimento
Il rilevamento dei punti di riferimento rileva strutture naturali e artificiali popolari 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 tua 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. Esegui rilevamento volto
Il rilevamento delle caratteristiche del volto rileva più volti all'interno di un'immagine, insieme alle caratteristiche principali del viso associate, come lo stato emotivo o l'indossato un copricapo.
In questo esempio, rileverai i volti nell'immagine seguente (per gentile concessione di Himanshu Singh Gurjar):
Copia il seguente codice nella tua 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 rilevamento dei volti. Ulteriori informazioni sul rilevamento facciale.
8. Esegui rilevamento oggetti
In questo esempio, effettuerai il rilevamento di oggetti sulla stessa immagine precedente (per gentile concessione di Alex Knight) di Setagaya:
Copia il seguente codice nella tua 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 una singola richiesta.
Ecco il tipo di richiesta che puoi effettuare per ottenere tutti gli insight 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 l'esecuzione di rilevamenti su un batch di immagini, in modo sincrono o asincrono. Consulta tutte le guide illustrative.
10. Complimenti
Hai imparato a utilizzare l'API Vision con Python e hai testato alcune funzionalità di rilevamento di immagini.
Esegui la pulizia
Per ripulire il tuo ambiente di sviluppo, da Cloud Shell:
- Se sei ancora nella sessione Python, 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 tuo progetto Google Cloud, da Cloud Shell:
- Recupera il tuo ID progetto attuale:
PROJECT_ID=$(gcloud config get-value core/project) - Assicurati che questo sia il progetto che vuoi eliminare:
echo $PROJECT_ID - Elimina il progetto:
gcloud projects delete $PROJECT_ID
Scopri di più
- Testa 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.