1. Przegląd
Vision API umożliwia deweloperom łatwą integrację w aplikacjach funkcji związanych z wykrywaniem treści wizualnych, takich jak oznaczanie obrazów etykietami, rozpoznawanie twarzy i punktów orientacyjnych, optyczne rozpoznawanie znaków (OCR) oraz tagowanie treści dla dorosłych.
W tym samouczku skupisz się na korzystaniu z interfejsu Vision API w Pythonie.
Czego się nauczysz
- Jak skonfigurować środowisko
- Jak przeprowadzić wykrywanie etykiet
- Jak przeprowadzić wykrywanie tekstu
- Jak przeprowadzić wykrywanie punktów orientacyjnych
- Jak przeprowadzić wykrywanie twarzy
- Jak przeprowadzić wykrywanie obiektów
Czego potrzebujesz
Ankieta
Jak zamierzasz korzystać z tego samouczka?
Jak oceniasz swoje doświadczenie z Pythonem?
Jak oceniasz korzystanie z usług Google Cloud?
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
- Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.
- Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google. Zawsze możesz ją zaktualizować.
- Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić po ustawieniu. Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się nim przejmować. W większości ćwiczeń z programowania musisz odwoływać się do identyfikatora projektu (zwykle oznaczanego jako
PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować własnej nazwy i sprawdzić, czy jest dostępna. Po tym kroku nie można go zmienić i pozostaje on taki przez cały czas trwania projektu. - Warto wiedzieć, że istnieje też trzecia wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.
- Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Wykonanie tego laboratorium nie będzie kosztować dużo, a może nawet nic. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub projekt. Nowi użytkownicy Google Cloud mogą skorzystać z programu bezpłatnego okresu próbnego o wartości 300 USD.
Uruchamianie Cloud Shell
Z Google Cloud można korzystać zdalnie na laptopie, ale w tym module użyjemy Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.
Aktywowanie Cloud Shell
- W konsoli Cloud kliknij Aktywuj Cloud Shell
.
Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni z opisem tego środowiska. Jeśli pojawił się ekran pośredni, kliknij Dalej.
Uzyskanie dostępu do środowiska Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.
Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Większość zadań w tym module, a być może wszystkie, możesz wykonać w przeglądarce.
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu.
- Aby potwierdzić, że uwierzytelnianie zostało przeprowadzone, uruchom w Cloud Shell to polecenie:
gcloud auth list
Wynik polecenia
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli nie, możesz go ustawić za pomocą tego polecenia:
gcloud config set project <PROJECT_ID>
Wynik polecenia
Updated property [core/project].
3. Konfigurowanie środowiska
Zanim zaczniesz korzystać z interfejsu Vision API, uruchom w Cloud Shell to polecenie, aby go włączyć:
gcloud services enable vision.googleapis.com
Powinien pojawić się ekran podobny do tego:
Operation "operations/..." finished successfully.
Teraz możesz używać interfejsu Vision API.
Przejdź do katalogu głównego:
cd ~
Utwórz środowisko wirtualne Pythona, aby odizolować zależności:
virtualenv venv-vision
Aktywuj środowisko wirtualne:
source venv-vision/bin/activate
Zainstaluj IPython i bibliotekę klienta Vision API:
pip install ipython google-cloud-vision
Powinien pojawić się ekran podobny do tego:
... Installing collected packages: ..., ipython, google-cloud-vision Successfully installed ... google-cloud-vision-3.4.0 ...
Teraz możesz używać biblioteki klienta Vision API.
W kolejnych krokach użyjesz interaktywnego interpretera Pythona o nazwie IPython, który został zainstalowany w poprzednim kroku. Rozpocznij sesję, uruchamiając ipython w Cloud Shell:
ipython
Powinien pojawić się ekran podobny do tego:
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]:
Możesz teraz wysłać pierwsze żądanie...
4. Wykrywanie etykiet
Jedną z głównych funkcji interfejsu Vision API jest identyfikowanie obiektów lub elementów na obrazie, czyli dodawanie adnotacji z etykietami. Wykrywanie etykiet identyfikuje ogólne obiekty, lokalizacje, aktywności, gatunki zwierząt, produkty i inne elementy. Interfejs Vision API przyjmuje obraz wejściowy i zwraca najbardziej prawdopodobne etykiety, które do niego pasują. Zwraca najlepiej pasujące etykiety wraz z wartością ufności dopasowania do obrazu.
W tym przykładzie przeprowadzisz wykrywanie etykiet na obrazie (udostępnionym przez Alexa Knighta) przedstawiającym Setagayę, popularną dzielnicę Tokio:
Skopiuj ten kod do sesji 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=" | ",
)
Poświęć chwilę na zapoznanie się z kodem i zobacz, jak używa on metody biblioteki klienta annotate_image do analizowania obrazu pod kątem określonego zestawu funkcji.
Wyślij żądanie za pomocą funkcji 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)
Powinien pojawić się następujący wynik:
================================================================================ 97% | Bicycle 96% | Tire 94% | Wheel 91% | Automotive lighting 89% | Infrastructure 87% | Bicycle wheel 86% | Mode of transport 85% | Building 83% | Electricity 82% | Neighbourhood
Oto jak wyniki są prezentowane w wersji demonstracyjnej online:
Podsumowanie
W tym kroku udało Ci się wykryć etykiety na obrazie i wyświetlić najbardziej prawdopodobne etykiety powiązane z tym obrazem. Dowiedz się więcej o wykrywaniu etykiet.
5. Wykrywanie tekstu
Wykrywanie tekstu wykorzystuje optyczne rozpoznawanie znaków (OCR). Wykrywa i wyodrębnia tekst z obrazu, obsługując szeroki zakres języków. Ma też funkcję automatycznego rozpoznawania języka.
W tym przykładzie wykonasz wykrywanie tekstu na obrazie znaku drogowego:
Skopiuj ten kod do sesji 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=" | ",
)
Wyślij żądanie za pomocą funkcji 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)
Powinien pojawić się następujący wynik:
================================================================================ '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)
Oto jak wyniki są prezentowane w wersji demonstracyjnej online:
Podsumowanie
Na tym etapie udało Ci się wykryć tekst na obrazie i wyświetlić rozpoznany tekst. Dowiedz się więcej o wykrywaniu tekstu.
6. Wykrywanie punktów orientacyjnych
Wykrywanie punktów orientacyjnych rozpoznaje popularne obiekty naturalne i stworzone przez człowieka na obrazie.
W tym przykładzie wykonasz wykrywanie punktów orientacyjnych na zdjęciu (dzięki uprzejmości Johna Townera) wieży Eiffla:
Skopiuj ten kod do sesji 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=" | ",
)
Wyślij żądanie za pomocą funkcji 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)
Powinien pojawić się następujący wynik:
================================================================================ 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
Oto jak wyniki są prezentowane w wersji demonstracyjnej online:
Podsumowanie
Na tym etapie udało Ci się wykryć punkt orientacyjny na zdjęciu wieży Eiffla. Dowiedz się więcej o wykrywaniu punktów orientacyjnych.
7. Wykrywanie twarzy
Wykrywanie cech twarzy wykrywa wiele twarzy na obrazie wraz z powiązanymi kluczowymi atrybutami twarzy, takimi jak stan emocjonalny czy nakrycie głowy.
W tym przykładzie wykryjesz twarze na tym zdjęciu (dzięki uprzejmości Himanshu Singha Gurjara):
Skopiuj ten kod do sesji 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)
Wyślij żądanie za pomocą funkcji 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)
Powinien pojawić się następujący wynik:
================================================================================ # 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 --------------------------------------------------------------------------------
Oto jak wyniki są prezentowane w wersji demonstracyjnej online:
Podsumowanie
Na tym etapie udało Ci się wykryć twarze. Dowiedz się więcej o wykrywaniu twarzy.
8. Wykrywanie obiektów
W tym przykładzie przeprowadzisz wykrywanie obiektów na tym samym wcześniejszym zdjęciu (dzięki uprzejmości Alexa Knighta) dzielnicy Setagaya:
Skopiuj ten kod do sesji 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=" | ",
)
Wyślij żądanie za pomocą funkcji 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)
Powinien pojawić się następujący wynik:
================================================================================ 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)
Oto jak wyniki są prezentowane w wersji demonstracyjnej online:
Podsumowanie
Na tym etapie udało Ci się przeprowadzić wykrywanie obiektów. Dowiedz się więcej o wykrywaniu obiektów.
9. Wiele funkcji
Wiesz już, jak korzystać z niektórych funkcji interfejsu Vision API, ale jest ich znacznie więcej. W jednym żądaniu możesz poprosić o wiele funkcji.
Oto rodzaj prośby, którą możesz wysłać, aby uzyskać wszystkie statystyki naraz:
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)
Istnieje więcej możliwości, np. wykrywanie na partii obrazów synchronicznie lub asynchronicznie. Zapoznaj się ze wszystkimi instrukcjami.
10. Gratulacje!
Dowiedzieliśmy się, jak korzystać z interfejsu Vision API w Pythonie, i przetestowaliśmy kilka funkcji wykrywania obrazów.
Czyszczenie danych
Aby wyczyścić środowisko programistyczne, w Cloud Shell:
- Jeśli nadal korzystasz z sesji IPython, wróć do powłoki:
exit - Przestań używać środowiska wirtualnego Pythona:
deactivate - Usuń folder środowiska wirtualnego:
cd ~ ; rm -rf ./venv-vision
Aby usunąć projekt Google Cloud, w Cloud Shell:
- Pobierz bieżący identyfikator projektu:
PROJECT_ID=$(gcloud config get-value core/project) - Sprawdź, czy to jest projekt, który chcesz usunąć:
echo $PROJECT_ID - Usuń projekt:
gcloud projects delete $PROJECT_ID
Więcej informacji
- Wypróbuj wersję demonstracyjną online w przeglądarce: https://cloud.google.com/vision
- Dokumentacja interfejsu Vision API: https://cloud.google.com/vision/docs
- Python w Google Cloud: https://cloud.google.com/python
- Biblioteki klienta Google Cloud do Pythona: https://github.com/googleapis/google-cloud-python
Licencja
To zadanie jest licencjonowane na podstawie ogólnej licencji Creative Commons Attribution 2.0.