Gemini Robotics-ER 1.5 to model wizualno-językowy (VLM), który udostępnia funkcje agenta Gemini w robotyce. Został on zaprojektowany z myślą o zaawansowanym rozumowaniu w świecie fizycznym, dzięki czemu roboty mogą interpretować złożone dane wizualne, przeprowadzać rozumowanie przestrzenne i planować działania na podstawie poleceń w języku naturalnym.
Najważniejsze funkcje i korzyści:
- Ulepszona autonomia: roboty mogą rozumować, dostosowywać się i reagować na zmiany w otwartych środowiskach.
- Interakcja w języku naturalnym: ułatwia korzystanie z robotów, umożliwiając przypisywanie złożonych zadań za pomocą języka naturalnego.
- Orkiestracja zadań: rozkłada polecenia w języku naturalnym na podzadania i integruje się z istniejącymi kontrolerami i zachowaniami robotów, aby wykonywać zadania długoterminowe.
- Wszechstronne możliwości: lokalizuje i identyfikuje obiekty, rozumie relacje między nimi, planuje chwytanie i trajektorie oraz interpretuje dynamiczne sceny.
W tym dokumencie opisujemy działanie modelu i przedstawiamy kilka przykładów, które pokazują jego możliwości.
Jeśli chcesz od razu zacząć, możesz wypróbować model w Google AI Studio.
Bezpieczeństwo
Gemini Robotics-ER 1.5 został zaprojektowany z myślą o bezpieczeństwie, ale to Ty ponosisz odpowiedzialność za utrzymanie bezpiecznego środowiska wokół robota. Modele generatywnej AI mogą popełniać błędy, a roboty fizyczne mogą powodować uszkodzenia. Bezpieczeństwo jest dla nas priorytetem, a zapewnienie bezpieczeństwa modeli generatywnej AI podczas korzystania z robotyki w rzeczywistym świecie to aktywny i kluczowy obszar naszych badań. Więcej informacji znajdziesz na stronie Google DeepMind poświęconej bezpieczeństwu robotów.
Wprowadzenie: znajdowanie obiektów w scenie
Poniższy przykład pokazuje typowe zastosowanie robotyki. Pokazuje, jak przekazać do modelu obraz i prompt tekstowy za pomocą metody generateContent, aby uzyskać listę zidentyfikowanych obiektów z odpowiadającymi im punktami 2D.
Model zwraca punkty dla elementów zidentyfikowanych na obrazie, podając ich znormalizowane współrzędne 2D i etykiety.
Możesz użyć tego wyniku w interfejsie Robotics API lub wywołać model wizyjno-językowo-działaniowy (VLA) albo inne funkcje zdefiniowane przez użytkownika, aby wygenerować działania, które robot ma wykonać.
Python
from google import genai
from google.genai import types
import IPython
from PIL import Image
# Initialize the GenAI client and specify the model
MODEL_ID = "gemini-robotics-er-1.5-preview"
PROMPT = """
Point to no more than 10 items in the image. The label returned
should be an identifying name for the object detected.
The answer should follow the json format: [{"point": <point>,
"label": <label1>}, ...]. The points are in [y, x] format
normalized to 0-1000.
"""
client = genai.Client()
# Load your image
img = Image.open("my-image.png")
img = img.resize((800, int(800 * img.size[1] / img.size[0])), Image.Resampling.LANCZOS) # Resizing to speed-up rendering
image_response = client.models.generate_content(
model=MODEL_ID,
contents=[
img,
PROMPT
],
config = types.GenerateContentConfig(
temperature=0.5,
thinking_config=types.ThinkingConfig(thinking_budget=0)
)
)
print(image_response.text)
REST
# First, ensure you have the image file locally.
# Encode the image to base64
IMAGE_BASE64=$(base64 -w 0 my-image.png)
curl -X POST \
"https://generativelanguage.googleapis.com/v1beta/models/gemini-robotics-er-1.5-preview:generateContent \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"contents": [
{
"parts": [
{
"inlineData": {
"mimeType": "image/png",
"data": "'"${IMAGE_BASE64}"'"
}
},
{
"text": "Point to no more than 10 items in the image. The label returned should be an identifying name for the object detected. The answer should follow the json format: [{\"point\": [y, x], \"label\": <label1>}, ...]. The points are in [y, x] format normalized to 0-1000."
}
]
}
],
"generationConfig": {
"temperature": 0.5,
"thinkingConfig": {
"thinkingBudget": 0
}
}
}'
Dane wyjściowe będą tablicą JSON zawierającą obiekty, z których każdy będzie miał point (znormalizowane współrzędne [y, x]) i label identyfikujące obiekt.
JSON
[
{"point": [376, 508], "label": "small banana"},
{"point": [287, 609], "label": "larger banana"},
{"point": [223, 303], "label": "pink starfruit"},
{"point": [435, 172], "label": "paper bag"},
{"point": [270, 786], "label": "green plastic bowl"},
{"point": [488, 775], "label": "metal measuring cup"},
{"point": [673, 580], "label": "dark blue bowl"},
{"point": [471, 353], "label": "light blue bowl"},
{"point": [492, 497], "label": "bread"},
{"point": [525, 429], "label": "lime"}
]
Na tym obrazie widać, jak mogą być wyświetlane te punkty:
Jak to działa
Gemini Robotics-ER 1.5 umożliwia robotom kontekstowe działanie w świecie fizycznym dzięki zrozumieniu przestrzennemu. Przyjmuje dane wejściowe w postaci obrazów, filmów i dźwięku oraz promptów w języku naturalnym, aby:
- Rozumienie obiektów i kontekstu sceny: identyfikuje obiekty i określa ich relację ze sceną, w tym ich możliwości.
- Rozumienie instrukcji dotyczących zadań: interpretuje zadania podane w języku naturalnym, np. „znajdź banana”.
- Rozumienie przestrzenne i czasowe: rozumienie sekwencji działań i sposobu, w jaki obiekty wchodzą w interakcje ze sceną w czasie.
- Dostarczanie danych wyjściowych w formie strukturalnej: zwraca współrzędne (punkty lub ramki ograniczające) reprezentujące lokalizacje obiektów.
Dzięki temu roboty mogą „widzieć” i „rozumieć” swoje otoczenie w sposób programowy.
Gemini Robotics-ER 1.5 ma też funkcję agenta, co oznacza, że może dzielić złożone zadania (np. „włóż jabłko do miski”) na podzadania, aby koordynować zadania długoterminowe:
- Sekwencjonowanie zadań podrzędnych: rozkłada polecenia na logiczną sekwencję kroków.
- Wywoływanie funkcji/wykonywanie kodu: wykonuje kroki, wywołując istniejące funkcje/narzędzia robota lub wykonując wygenerowany kod.
Więcej informacji o tym, jak działa wywoływanie funkcji w Gemini, znajdziesz na stronie Wywoływanie funkcji.
Korzystanie z budżetu na myślenie w przypadku Gemini Robotics-ER 1.5
Gemini Robotics-ER 1.5 ma elastyczny budżet na myślenie, który pozwala kontrolować kompromisy między opóźnieniem a dokładnością. W przypadku zadań związanych z rozumieniem przestrzennym, takich jak wykrywanie obiektów, model może osiągać wysoką skuteczność przy niewielkim budżecie na myślenie. Bardziej złożone zadania wymagające rozumowania, takie jak liczenie i szacowanie wagi, wymagają większego budżetu na myślenie. Pozwala to zrównoważyć potrzebę uzyskiwania odpowiedzi o niskim opóźnieniu z wysoką dokładnością wyników w przypadku bardziej złożonych zadań.
Więcej informacji o budżetach na myślenie znajdziesz na stronie z myśleniem jako podstawową funkcją.
Możliwości agentowe w robotyce
W tej sekcji omawiamy różne możliwości modelu Gemini Robotics-ER 1.5, pokazując, jak używać go w aplikacjach do percepcji, rozumowania i planowania w robotyce.
Przykłady w tej sekcji pokazują możliwości od wskazywania i wyszukiwania obiektów na obrazie po planowanie trajektorii i koordynowanie zadań długoterminowych. Dla uproszczenia fragmenty kodu zostały skrócone, aby pokazywać tylko prompt i wywołanie interfejsu generate_content API. Pełny kod, który można uruchomić, oraz dodatkowe przykłady znajdziesz w książce kucharskiej dotyczącej robotyki.
Wskazywanie obiektów
Wskazywanie i wyszukiwanie obiektów na obrazach lub klatkach wideo to typowe zastosowanie modeli wizualno-językowych w robotyce. W poniższym przykładzie model ma znaleźć konkretne obiekty na obrazie i zwrócić ich współrzędne na obrazie.
Python
from google import genai
from google.genai import types
# Initialize the GenAI client and specify the model
MODEL_ID = "gemini-robotics-er-1.5-preview"
client = genai.Client()
# Load your image and set up your prompt
with open('path/to/image-with-objects.jpg', 'rb') as f:
image_bytes = f.read()
queries = [
"bread",
"starfruit",
"banana",
]
prompt = f"""
Get all points matching the following objects: {', '.join(queries)}. The
label returned should be an identifying name for the object detected.
The answer should follow the json format:
[\{\{"point": <point>, "label": <label1>\}\}, ...]. The points are in
[y, x] format normalized to 0-1000.
"""
image_response = client.models.generate_content(
model=MODEL_ID,
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
prompt
],
config = types.GenerateContentConfig(
temperature=0.5,
thinking_config=types.ThinkingConfig(thinking_budget=0)
)
)
print(image_response.text)
Dane wyjściowe będą podobne do przykładu na początek, czyli będą zawierać plik JSON ze współrzędnymi znalezionych obiektów i ich etykietami.
[
{"point": [671, 317], "label": "bread"},
{"point": [738, 307], "label": "bread"},
{"point": [702, 237], "label": "bread"},
{"point": [629, 307], "label": "bread"},
{"point": [833, 800], "label": "bread"},
{"point": [609, 663], "label": "banana"},
{"point": [770, 483], "label": "starfruit"}
]
Użyj tego prompta, aby poprosić model o interpretowanie abstrakcyjnych kategorii, takich jak „owoc”, zamiast konkretnych obiektów i znalezienie wszystkich wystąpień na obrazie.
Python
prompt = f"""
Get all points for fruit. The label returned should be an identifying
name for the object detected.
""" + """The answer should follow the json format:
[{"point": <point>, "label": <label1>}, ...]. The points are in
[y, x] format normalized to 0-1000."""
Na stronie rozumienie obrazu znajdziesz inne techniki przetwarzania obrazu.
Śledzenie obiektów w filmie
Gemini Robotics-ER 1.5 może też analizować klatki filmu, aby śledzić obiekty w czasie. Listę obsługiwanych formatów wideo znajdziesz w sekcji Dane wejściowe wideo.
Poniżej znajdziesz podstawowy prompt używany do znajdowania konkretnych obiektów w każdej klatce analizowanej przez model:
Python
# Define the objects to find
queries = [
"pen (on desk)",
"pen (in robot hand)",
"laptop (opened)",
"laptop (closed)",
]
base_prompt = f"""
Point to the following objects in the provided image: {', '.join(queries)}.
The answer should follow the json format:
[\{\{"point": <point>, "label": <label1>\}\}, ...].
The points are in [y, x] format normalized to 0-1000.
If no objects are found, return an empty JSON list [].
"""
Dane wyjściowe pokazują śledzenie pióra i laptopa w klatkach filmu.
Pełny kod, który można uruchomić, znajdziesz w książce kucharskiej dotyczącej robotyki.
Wykrywanie obiektów i ramki ograniczające
Oprócz pojedynczych punktów model może też zwracać 2-wymiarowe ramki ograniczające, czyli prostokątne obszary otaczające obiekt.
W tym przykładzie żądamy 2-wymiarowych ramek ograniczających dla rozpoznawalnych obiektów na stole. Model ma ograniczyć liczbę obiektów do 25 i nadawać unikalne nazwy wielu instancjom.
Python
from google import genai
from google.genai import types
# Initialize the GenAI client and specify the model
MODEL_ID = "gemini-robotics-er-1.5-preview"
client = genai.Client()
# Load your image and set up your prompt
with open('path/to/image-with-objects.jpg', 'rb') as f:
image_bytes = f.read()
prompt = """
Return bounding boxes as a JSON array with labels. Never return masks
or code fencing. Limit to 25 objects. Include as many objects as you
can identify on the table.
If an object is present multiple times, name them according to their
unique characteristic (colors, size, position, unique characteristics, etc..).
The format should be as follows: [{"box_2d": [ymin, xmin, ymax, xmax],
"label": <label for the object>}] normalized to 0-1000. The values in
box_2d must only be integers
"""
image_response = client.models.generate_content(
model=MODEL_ID,
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
prompt
],
config = types.GenerateContentConfig(
temperature=0.5,
thinking_config=types.ThinkingConfig(thinking_budget=0)
)
)
print(image_response.text)
Poniżej znajdują się ramki zwrócone przez model.
Pełny kod, który można uruchomić, znajdziesz w książce kucharskiej Robotics. Na stronie Rozumienie obrazów znajdziesz też dodatkowe przykłady zadań wizualnych, takich jak segmentacja i wykrywanie obiektów.
Dodatkowe przykłady ramek ograniczających znajdziesz na stronie Rozumienie obrazów.
Trajektorie
Gemini Robotics-ER 1.5 może generować sekwencje punktów, które definiują trajektorię, co jest przydatne do sterowania ruchem robota.
W tym przykładzie żądamy trajektorii, która przeniesie czerwony długopis do organizera, w tym punktu początkowego i serii punktów pośrednich.
Python
from google import genai
from google.genai import types
# Initialize the GenAI client and specify the model
MODEL_ID = "gemini-robotics-er-1.5-preview"
client = genai.Client()
# Load your image and set up your prompt
with open('path/to/image-with-objects.jpg', 'rb') as f:
image_bytes = f.read()
points_data = []
prompt = """
Place a point on the red pen, then 15 points for the trajectory of
moving the red pen to the top of the organizer on the left.
The points should be labeled by order of the trajectory, from '0'
(start point at left hand) to <n> (final point)
The answer should follow the json format:
[{"point": <point>, "label": <label1>}, ...].
The points are in [y, x] format normalized to 0-1000.
"""
image_response = client.models.generate_content(
model=MODEL_ID,
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
prompt
],
config = types.GenerateContentConfig(
temperature=0.5,
)
)
print(image_response.text)
Odpowiedź to zestaw współrzędnych opisujących trajektorię ścieżki, po której czerwony długopis powinien się poruszać, aby wykonać zadanie polegające na przesunięciu go na organizer:
[
{"point": [550, 610], "label": "0"},
{"point": [500, 600], "label": "1"},
{"point": [450, 590], "label": "2"},
{"point": [400, 580], "label": "3"},
{"point": [350, 550], "label": "4"},
{"point": [300, 520], "label": "5"},
{"point": [250, 490], "label": "6"},
{"point": [200, 460], "label": "7"},
{"point": [180, 430], "label": "8"},
{"point": [160, 400], "label": "9"},
{"point": [140, 370], "label": "10"},
{"point": [120, 340], "label": "11"},
{"point": [110, 320], "label": "12"},
{"point": [105, 310], "label": "13"},
{"point": [100, 305], "label": "14"},
{"point": [100, 300], "label": "15"}
]
Administracja
Gemini Robotics-ER 1.5 potrafi przeprowadzać bardziej zaawansowane rozumowanie przestrzenne, wyciągając wnioski dotyczące działań lub identyfikując optymalne lokalizacje na podstawie zrozumienia kontekstu.
Zrobienie miejsca na laptopa
Ten przykład pokazuje, jak Gemini Robotics-ER może analizować przestrzeń. Prompt prosi model o określenie, który obiekt należy przenieść, aby zrobić miejsce na inny element.
Python
from google import genai
from google.genai import types
# Initialize the GenAI client and specify the model
MODEL_ID = "gemini-robotics-er-1.5-preview"
client = genai.Client()
# Load your image and set up your prompt
with open('path/to/image-with-objects.jpg', 'rb') as f:
image_bytes = f.read()
prompt = """
Point to the object that I need to remove to make room for my laptop
The answer should follow the json format: [{"point": <point>,
"label": <label1>}, ...]. The points are in [y, x] format normalized to 0-1000.
"""
image_response = client.models.generate_content(
model=MODEL_ID,
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
prompt
],
config = types.GenerateContentConfig(
temperature=0.5,
thinking_config=types.ThinkingConfig(thinking_budget=0)
)
)
print(image_response.text)
Odpowiedź zawiera współrzędne 2D obiektu, który odpowiada na pytanie użytkownika, w tym przypadku obiektu, który powinien się przesunąć, aby zrobić miejsce na laptopa.
[
{"point": [672, 301], "label": "The object that I need to remove to make room for my laptop"}
]
Pakowanie lunchu
Model może też podawać instrukcje dotyczące zadań wieloetapowych i wskazywać odpowiednie obiekty na każdym etapie. Ten przykład pokazuje, jak model planuje serię kroków, aby spakować lunch.
Python
from google import genai
from google.genai import types
# Initialize the GenAI client and specify the model
MODEL_ID = "gemini-robotics-er-1.5-preview"
client = genai.Client()
# Load your image and set up your prompt
with open('path/to/image-of-lunch.jpg', 'rb') as f:
image_bytes = f.read()
prompt = """
Explain how to pack the lunch box and lunch bag. Point to each
object that you refer to. Each point should be in the format:
[{"point": [y, x], "label": }], where the coordinates are
normalized between 0-1000.
"""
image_response = client.models.generate_content(
model=MODEL_ID,
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
prompt
],
config = types.GenerateContentConfig(
temperature=0.5,
thinking_config=types.ThinkingConfig(thinking_budget=0)
)
)
print(image_response.text)
Odpowiedzią na ten prompt jest zestaw instrukcji krok po kroku dotyczących pakowania torby na lunch na podstawie przesłanego obrazu.
Obraz wejściowy
Dane wyjściowe modelu
Based on the image, here is a plan to pack the lunch box and lunch bag:
1. **Pack the fruit into the lunch box.** Place the [apple](apple), [banana](banana), [red grapes](red grapes), and [green grapes](green grapes) into the [blue lunch box](blue lunch box).
2. **Add the spoon to the lunch box.** Put the [blue spoon](blue spoon) inside the lunch box as well.
3. **Close the lunch box.** Secure the lid on the [blue lunch box](blue lunch box).
4. **Place the lunch box inside the lunch bag.** Put the closed [blue lunch box](blue lunch box) into the [brown lunch bag](brown lunch bag).
5. **Pack the remaining items into the lunch bag.** Place the [blue snack bar](blue snack bar) and the [brown snack bar](brown snack bar) into the [brown lunch bag](brown lunch bag).
Here is the list of objects and their locations:
* [{"point": [899, 440], "label": "apple"}]
* [{"point": [814, 363], "label": "banana"}]
* [{"point": [727, 470], "label": "red grapes"}]
* [{"point": [675, 608], "label": "green grapes"}]
* [{"point": [706, 529], "label": "blue lunch box"}]
* [{"point": [864, 517], "label": "blue spoon"}]
* [{"point": [499, 401], "label": "blue snack bar"}]
* [{"point": [614, 705], "label": "brown snack bar"}]
* [{"point": [448, 501], "label": "brown lunch bag"}]
Wywoływanie niestandardowego interfejsu API robota
Ten przykład pokazuje orkiestrację zadań za pomocą niestandardowego interfejsu API robota. Przedstawia on przykładowy interfejs API zaprojektowany do operacji typu „pick and place”. Zadanie polega na podniesieniu niebieskiego klocka i umieszczeniu go w pomarańczowej misce:
Podobnie jak w przypadku innych przykładów na tej stronie, pełny kod, który można uruchomić, jest dostępny w książce kucharskiej dotyczącej robotyki.
Pierwszym krokiem jest zlokalizowanie obu produktów za pomocą tego prompta:
Python
prompt = """
Locate and point to the blue block and the orange bowl. The label
returned should be an identifying name for the object detected.
The answer should follow the json format: [{"point": <point>, "label": <label1>}, ...].
The points are in [y, x] format normalized to 0-1000.
"""
Odpowiedź modelu zawiera znormalizowane współrzędne bloku i miski:
[
{"point": [389, 252], "label": "orange bowl"},
{"point": [727, 659], "label": "blue block"}
]
W tym przykładzie używamy tego interfejsu API robota:
Python
def move(x, y, high):
print(f"moving to coordinates: {x}, {y}, {15 if high else 5}")
def setGripperState(opened):
print("Opening gripper" if opened else "Closing gripper")
def returnToOrigin():
print("Returning to origin pose")
Następnym krokiem jest wywołanie sekwencji funkcji interfejsu API z logiką niezbędną do wykonania działania. Poniższy prompt zawiera opis interfejsu API robota, którego model powinien używać podczas koordynowania tego zadania.
Python
prompt = f"""
You are a robotic arm with six degrees-of-freedom. You have the
following functions available to you:
def move(x, y, high):
# moves the arm to the given coordinates. The boolean value 'high' set
to True means the robot arm should be lifted above the scene for
avoiding obstacles during motion. 'high' set to False means the robot
arm should have the gripper placed on the surface for interacting with
objects.
def setGripperState(opened):
# Opens the gripper if opened set to true, otherwise closes the gripper
def returnToOrigin():
# Returns the robot to an initial state. Should be called as a cleanup
operation.
The origin point for calculating the moves is at normalized point
y={robot_origin_y}, x={robot_origin_x}. Use this as the new (0,0) for
calculating moves, allowing x and y to be negative.
Perform a pick and place operation where you pick up the blue block at
normalized coordinates ({block_x}, {block_y}) (relative coordinates:
{block_relative_x}, {block_relative_y}) and place it into the orange
bowl at normalized coordinates ({bowl_x}, {bowl_y})
(relative coordinates: {bowl_relative_x}, {bowl_relative_y}).
Provide the sequence of function calls as a JSON list of objects, where
each object has a "function" key (the function name) and an "args" key
(a list of arguments for the function).
Also, include your reasoning before the JSON output.
For example:
Reasoning: To pick up the block, I will first move the arm to a high
position above the block, open the gripper, move down to the block,
close the gripper, lift the arm, move to a high position above the bowl,
move down to the bowl, open the gripper, and then lift the arm back to
a high position.
"""
Poniżej znajdziesz możliwe dane wyjściowe modelu na podstawie promptu i mockowego interfejsu API robota. Dane wyjściowe obejmują proces myślowy modelu i zaplanowane przez niego zadania. Wyświetla też wyniki wywołań funkcji robota, które model połączył w sekwencję.
Reasoning: To perform the pick and place operation, I will first move the
robotic arm to a high position above the blue block to ensure clearance. Then, I
will open the gripper in preparation for grasping. Next, I will lower the arm to
the surface level to position the gripper around the block and close the gripper
to secure it. After picking up the block, I will lift the arm to clear the
surface and move towards the orange bowl, maintaining a high position to avoid
collisions. Once positioned above the bowl, I will lower the arm to place the
block inside. I will then open the gripper to release the block. Finally, I will
lift the arm out of the bowl and call `returnToOrigin` to reset the robot's
state.
[
{
"function": "move",
"args": [
163,
427,
true
]
},
{
"function": "setGripperState",
"args": [
true
]
},
{
"function": "move",
"args": [
163,
427,
false
]
},
{
"function": "setGripperState",
"args": [
false
]
},
{
"function": "move",
"args": [
163,
427,
true
]
},
{
"function": "move",
"args": [
-247,
90,
true
]
},
{
"function": "move",
"args": [
-247,
90,
false
]
},
{
"function": "setGripperState",
"args": [
true
]
},
{
"function": "move",
"args": [
-247,
90,
true
]
},
{
"function": "returnToOrigin",
"args": []
}
]
Executing Function Calls:
moving to coordinates: 163, 427, 15
Opening gripper
moving to coordinates: 163, 427, 5
Closing gripper
moving to coordinates: 163, 427, 15
moving to coordinates: -247, 90, 15
moving to coordinates: -247, 90, 5
Opening gripper
moving to coordinates: -247, 90, 15
Returning to origin pose
Wykonanie kodu
Gemini Robotics-ER 1.5 może sugerować i wykonywać kod w Pythonie, aby realizować zadania wymagające dynamicznych działań, np. powiększanie fragmentu obrazu w celu uzyskania większej ilości szczegółów.
Ten przykład pokazuje, jak model może zaproponować użycie narzędzia wykonywanie kodu, aby „powiększyć” określony obszar obrazu, a następnie wykonać to działanie, aby odpowiedzieć na pytanie użytkownika.
Python
from google import genai
from google.genai import types
client = genai.Client()
MODEL_ID = "gemini-robotics-er-1.5-preview"
# Load your image and set up your prompt
with open('path/to/image-of-object.jpg', 'rb') as f:
image_bytes = f.read()
prompt = """
What is the air quality reading? Using the code execution feature,
zoom in on the image to take a closer look.
"""
response = client.models.generate_content(
model=MODEL_ID,
contents=[
img,
prompt
],
config = types.GenerateContentConfig(
temperature=0.5,
tools=[types.Tool(code_execution=types.ToolCodeExecution)]
)
)
for part in response.candidates[0].content.parts:
if part.text is not None:
print(part.text)
if part.executable_code is not None:
print(part.executable_code.code)
if part.code_execution_result is not None:
print(part.code_execution_result.output)
Poniżej znajdziesz możliwą odpowiedź modelu na to zadanie. W wyniku widać, że model generuje kod, który umożliwia powiększenie obrazu, aby lepiej odczytać ekran. Wyświetla też proces myślowy związany z wprowadzonymi zmianami w przycinaniu. Pełne dane wyjściowe znajdziesz w książce kucharskiej dotyczącej robotyki.
# Detect relevant objects and output in json format
# [{"box_2d": [379, 407, 481, 553], "label": "display"}]
from PIL import Image
# Open the image
img = Image.open("input_file_0.jpeg")
# Define the coordinates for cropping (normalized to 0-1000)
# Based on visual inspection, the display is roughly centered around [430, 430] to [500, 500] in a 1000x1000 scale.
# Let's try to zoom in on the display area.
# Bounding box for display: [ymin, xmin, ymax, xmax] in pixels.
# From visual inspection of the original image (size 90489 bytes, resolution
unknown but let's assume a standard aspect ratio and roughly 1000x1000 for
relative positioning),
# the display is located at approximately y=380-480, x=410-540.
# Let's define a larger area around it for context.
# Let's say we want to crop from y=350 to y=550 and x=350 to x=650.
...
thought
The crop was too tight and only captured part of the display. Let's adjust the bounding box.
The previous crop was `img.crop((400, 350, 600, 500))`. This means xmin=400, ymin=350, xmax=600, ymax=500.
The display is centered around x=480, y=430.
The previous crop captured the left side of the display.
Let's expand the x range to the right and y range to cover the whole circle.
New bounding box estimate: ymin=370, xmin=400, ymax=500, xmax=600.
Let's try again with a wider crop.
# Detect relevant objects and output in json format
# [{"box_2d": [379, 407, 481, 553], "label": "display"}]
from PIL import Image
# Open the image
img = Image.open("input_file_0.jpeg")
# Define the coordinates for cropping (normalized to 0-1000)
…
The reading of 14 falls into the "Moderate" category.
The prompt asks for the "air quality reading", which can be interpreted as
either the numerical value or the categorical description. Given the numerical
value is explicitly displayed, it's the primary reading.
Let's provide the numerical value as the reading.
The reading is 014.
Based on the display on the air purifier, the air quality reading is **014**.
Sprawdzone metody
Aby zoptymalizować wydajność i dokładność aplikacji robotycznych, musisz wiedzieć, jak skutecznie korzystać z modelu Gemini. W tej sekcji znajdziesz sprawdzone metody i kluczowe strategie tworzenia promptów, obsługi danych wizualnych i strukturyzowania zadań, aby uzyskać jak najbardziej wiarygodne wyniki.
Używaj jasnego i prostego języka.
Używaj języka naturalnego: model Gemini został zaprojektowany tak, aby rozumieć język naturalny, którym posługujemy się w rozmowie. Twórz prompty w sposób semantycznie jasny, który odzwierciedla naturalny sposób wydawania instrukcji przez człowieka.
Używaj powszechnie stosowanej terminologii: zamiast terminów technicznych lub specjalistycznego żargonu używaj powszechnie stosowanego języka. Jeśli model nie reaguje na określony termin zgodnie z oczekiwaniami, spróbuj użyć bardziej powszechnego synonimu.
Zoptymalizuj dane wizualne.
Powiększanie, aby zobaczyć szczegóły: w przypadku obiektów, które są małe lub trudne do odróżnienia na szerszym ujęciu, użyj funkcji ramki ograniczającej, aby wyodrębnić interesujący Cię obiekt. Następnie możesz przyciąć obraz do tego wyboru i przesłać nowy, wykadrowany obraz do modelu, aby uzyskać bardziej szczegółową analizę.
Eksperymentuj z oświetleniem i kolorami: na percepcję modelu mogą wpływać trudne warunki oświetleniowe i słaby kontrast kolorów.
Dzielenie złożonych problemów na mniejsze etapy. Rozpatrując każdy mniejszy krok z osobna, możesz poprowadzić model do bardziej precyzyjnego i skutecznego wyniku.
Zwiększanie dokładności dzięki konsensusowi. W przypadku zadań wymagających dużej precyzji możesz wysyłać do modelu to samo zapytanie wielokrotnie. Uśredniając zwrócone wyniki, możesz uzyskać „konsensus”, który jest często dokładniejszy i bardziej wiarygodny.
Ograniczenia
Podczas tworzenia aplikacji z użyciem Gemini Robotics-ER 1.5 pamiętaj o tych ograniczeniach:
- Stan podglądu: model jest obecnie w podglądzie. Interfejsy API i funkcje mogą ulec zmianie, dlatego bez dokładnego przetestowania mogą nie nadawać się do aplikacji o krytycznym znaczeniu dla produkcji.
- Opóźnienie: złożone zapytania, dane wejściowe o wysokiej rozdzielczości lub obszerne
thinking_budgetmogą wydłużyć czas przetwarzania. - Halucynacje: podobnie jak wszystkie duże modele językowe, Gemini Robotics-ER 1.5 może czasami „halucynować”, czyli podawać nieprawidłowe informacje, zwłaszcza w przypadku niejednoznacznych promptów lub danych wejściowych spoza zakresu.
- Zależność od jakości prompta: jakość wygenerowanych przez model treści w dużym stopniu zależy od jasności i szczegółowości prompta. Niejasne lub źle sformułowane prompty mogą prowadzić do uzyskania niezadowalających wyników.
- Koszt obliczeniowy: uruchomienie modelu, zwłaszcza w przypadku danych wejściowych w postaci filmów lub wysokiego parametru
thinking_budget, zużywa zasoby obliczeniowe i generuje koszty. Więcej informacji znajdziesz na stronie Myślenie. - Typy danych wejściowych: szczegółowe informacje o ograniczeniach w przypadku każdego trybu znajdziesz w tych artykułach:
Informacje na temat ochrony prywatności
Przyjmujesz do wiadomości, że modele, o których mowa w tym dokumencie („Modele robotyczne”), wykorzystują dane wideo i audio do działania i poruszania sprzętem zgodnie z Twoimi instrukcjami. W związku z tym możesz używać modeli robotów w taki sposób, aby zbierały dane od osób, które można zidentyfikować, takie jak dane głosowe, obrazy i dane dotyczące podobieństwa („Dane osobowe”). Jeśli zdecydujesz się korzystać z modeli robotów w sposób, który umożliwia zbieranie danych osobowych, zgadzasz się nie zezwalać osobom, które można zidentyfikować, na interakcję z modelami robotów ani na przebywanie w ich pobliżu, dopóki nie zostaną one odpowiednio poinformowane o tym, że ich dane osobowe mogą być przekazywane firmie Google i wykorzystywane przez nią w sposób opisany w Dodatkowych warunkach korzystania z interfejsu Gemini API, które są dostępne na stronie https://ai.google.dev/gemini-api/terms („Warunki”), w tym zgodnie z sekcją zatytułowaną „Jak Google wykorzystuje Twoje dane”. Zapewnisz, że takie powiadomienie zezwala na zbieranie i wykorzystywanie danych osobowych w sposób określony w Warunkach, i dołożysz uzasadnionych ekonomicznie starań, aby zminimalizować zbieranie i rozpowszechnianie danych osobowych, stosując techniki takie jak rozmywanie twarzy i używając modeli robotów w obszarach, w których nie ma osób umożliwiających identyfikację, w możliwie największym stopniu.
Ceny
Szczegółowe informacje o cenach i dostępnych regionach znajdziesz na stronie cennika.
Dalsze kroki
- Poznaj inne możliwości i dalej eksperymentuj z różnymi promptami i danymi wejściowymi, aby odkrywać kolejne zastosowania Gemini Robotics-ER 1.5. Więcej przykładów znajdziesz w książce kucharskiej dotyczącej robotyki.
- Dowiedz się, jak modele Gemini Robotics zostały stworzone z myślą o bezpieczeństwie. Odwiedź stronę Google DeepMind poświęconą bezpieczeństwu robotów.
- Więcej informacji o najnowszych aktualizacjach modeli Gemini Robotics znajdziesz na stronie docelowej Gemini Robotics.