Gemini Robotics ER

Modele Gemini Robotics ER (embodied reasoning) to modele wizualno-językowe (VLM), które umożliwiają robotom postrzeganie świata fizycznego i interakcję z nim. Interpretują dane wizualne, przeprowadzają rozumowanie przestrzenne i czasowe, planują wieloetapowe zadania oraz koordynują pracę robotów i narzędzi.

Modele

Model Gemini Robotics ER 2 to najnowszy model w Gemini Robotics. To nasz zaktualizowany model rozumowania, który umożliwia robotom dokładne poznanie otoczenia. Specjalizuje się w rozumowaniu w świecie fizycznym, np.w orkiestracji agentów robotów (np. za pomocą VLA), rozumieniu filmów z robotami, w tym w rozumieniu postępów i wykrywaniu sukcesów, odczytywaniu wskazań przyrządów, wskazywaniu i rozumowaniu przestrzennym.

Model Gemini Robotics ER 2 wprowadza 2 punkty końcowe:

• gemini-robotics-er-2-preview: standardowy model ER 2. Ulepszona wersja Gemini 3.5 Flash z lepszym rozumowaniem przestrzennym, wyszukiwaniem momentów w filmie, klasyfikacją postępu wideo, koordynacją pracy wielu robotów i wieloetapowym korzystaniem z narzędzi.
• gemini-robotics-er-2-streaming-preview: zoptymalizowany pod kątem przesyłania strumieniowego w czasie rzeczywistym za pomocą interfejsu Live API. Używaj tego modelu w przypadku agentów robotów o krótkim czasie oczekiwania, którzy przetwarzają ciągłe dane audio i wideo.

Gemini Robotics ER 1.6 zostało wycofane 31 sierpnia 2026 r. Jeśli nadal używasz Gemini Robotics ER 1.6, przejdź na Gemini Robotics ER 2, zastępując w wywołaniach interfejsu API symbol model="gemini-robotics-er-1.6-preview" symbolem model="gemini-robotics-er-2-preview" lub model="gemini-robotics-er-2-streaming-preview".

Wypróbuj Gemini Robotics ER 2 w Google AI Studio

Możliwości w zakresie robotyki

Gemini Robotics ER obsługuje szereg funkcji rozumowania w świecie fizycznym. Wybierz funkcję, aby dowiedzieć się więcej:

Zanim zaczniesz

Modele Gemini Robotics ER są dostępne w ramach Gemini Developer API. Aby rozpocząć, utwórz klucz interfejsu Gemini API w Google AI Studio lub konsoli Google Cloud i skonfiguruj środowisko.

Szczegółowe informacje o typach kluczy, zabezpieczeniach i konfigurowaniu klucza w Pythonie, JavaScript i innych językach znajdziesz w artykule Korzystanie z kluczy interfejsu Gemini API.

Pierwsze kroki

Ten przykład znajduje obiekty na obrazie i zwraca ich znormalizowane współrzędne 2D oraz etykiety. Możesz przekazać te dane wyjściowe bezpośrednio do interfejsu API robotyki lub modelu VLA, aby wygenerować działania robota.

from google import genai

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()

uploaded_file = client.files.upload(file="my-image.png")

image_response = client.interactions.create(
    model="gemini-robotics-er-2-preview",
    input=[
        {
            "type": "image",
            "uri": uploaded_file.uri,
            "mime_type": uploaded_file.mime_type
        },
        {"type": "text", "text": PROMPT}
    ],
    generation_config={"thinking_level": "high"},
)

print(image_response.output_text)

import { GoogleGenAI } from "@google/genai";

const 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.
`;
const client = new GoogleGenAI();

const uploadedFile = await client.files.upload({ file: "my-image.png" });

const imageResponse = await client.interactions.create({
  model: "gemini-robotics-er-2-preview",
  input: [
    {
      type: "image",
      uri: uploadedFile.uri,
      mime_type: uploadedFile.mimeType,
    },
    { type: "text", text: PROMPT },
  ],
  generation_config: { thinking_level: "high" },
});

console.log(imageResponse.output_text);

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.GenerationConfig;
import com.google.genai.gaos.models.interactions.ImageContent;
import com.google.genai.gaos.models.interactions.ImageContentMimeType;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.interactions.ThinkingLevel;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.types.File;
import com.google.genai.types.UploadFileConfig;
import java.util.List;

Client client = new Client();

String 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.";

File uploadedFile =
    client.files.upload(
        new java.io.File("my-image.png"),
        UploadFileConfig.builder().mimeType("image/png").build());

Content imageContent =
    ImageContent.builder()
        .uri(uploadedFile.uri().orElse(""))
        .mimeType(ImageContentMimeType.of(uploadedFile.mimeType().orElse("image/png")))
        .build();
Content textContent = TextContent.builder().text(prompt).build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-robotics-er-2-preview"))
        .input(InteractionsInput.ofContent(List.of(imageContent, textContent)))
        .generationConfig(
            GenerationConfig.builder().thinkingLevel(ThinkingLevel.HIGH).build())
        .build();

Interaction imageResponse =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(imageResponse.outputText().orElse(""));

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    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.`

    uploadedFile, err := client.Files.UploadFromPath(ctx, "my-image.png", &genai.UploadFileConfig{
        MIMEType: "image/png",
    })
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model: interactions.Model("gemini-robotics-er-2-preview"),
            Input: interactions.NewInteractionsInput([]interactions.Content{
                interactions.NewContent(interactions.ImageContent{
                    URI:      genai.Ptr(uploadedFile.URI),
                    MimeType: genai.Ptr(interactions.ImageMimeTypeImagePng),
                }),
                interactions.NewContent(interactions.TextContent{
                    Text: prompt,
                }),
            }),
            GenerationConfig: &interactions.GenerationConfig{
                ThinkingLevel: interactions.ThinkingLevelHigh.ToPointer(),
            },
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

# 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/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-robotics-er-2-preview",
    "input": {
      "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."
        }
      ]
    },
    "generation_config": {
      "thinking_config": {
        "thinking_level": "high"
      }
    }
  }'

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.

[
  {"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 poniższym obrazie pokazano, jak mogą być wyświetlane te punkty:

Jak to działa

Gemini Robotics ER przyjmuje dane wejściowe w postaci obrazów, filmów lub dźwięku z promptami w języku naturalnym. Rozpoznaje obiekty, analizuje kontekst sceny i relacje przestrzenne oraz zwraca uporządkowane dane wyjściowe, takie jak współrzędne lub ramki ograniczające.

Gemini Robotics ER jest też agentem: dzieli złożone zadania na podzadania i wykonuje je, wywołując funkcje robota lub uruchamiając wygenerowany kod. Na przykład „włóż jabłko do miski” staje się sekwencją czynności: zlokalizuj, chwyć i umieść.

Więcej informacji o tym, jak Gemini wykonuje wywołania narzędzi, znajdziesz w sekcji Wywoływanie funkcji.

Bezpieczeństwo

Gemini Robotics ER został zaprojektowany z myślą o bezpieczeństwie, ale to Ty odpowiadasz za utrzymanie bezpiecznego środowiska wokół robota. Modele generatywnej AI mogą popełniać błędy, a roboty fizyczne mogą powodować uszkodzenia. Więcej informacji znajdziesz na stronie dotyczącej bezpieczeństwa Gemini Robotics.

Sprawdzone metody

1. Używaj prostego, języka naturalnego. Opisz, co ma robić robot, tak jakbyś mówił(-a) do człowieka. Jeśli dane słowo nie działa, spróbuj użyć popularnego synonimu.

2. Optymalizuj dane wizualne. Przed wysłaniem obrazu przytnij lub powiększ małe lub niewyraźne obiekty. Oświetlenie i niski kontrast kolorów mogą wpływać na wykrywanie.

3. Podziel skomplikowane zadania na etapy. Każdy krok wyślij jako osobny prompt, aby model był bardziej skupiony i dokładniejszy.

4. W przypadku zadań wymagających dużej precyzji wykonuj zapytania wielokrotnie i obliczaj średnią wyników. To podejście oparte na konsensusie zmniejsza wariancję danych przestrzennych.

Ograniczenia

Podczas tworzenia aplikacji z użyciem Gemini Robotics ER pamiętaj o tych ograniczeniach:

• Ograniczenia dotyczące klucza interfejsu API: interfejs Gemini API nie akceptuje żądań z nieograniczonych kluczy interfejsu API i zwraca błąd 403 Forbidden. Zabezpiecz klucz interfejsu API, dodając ograniczenia w AI Studio. Więcej informacji znajdziesz w artykule Zabezpieczanie kluczy interfejsu API bez ograniczeń.
• Opóźnienie a wydajność: złożone zapytania, dane wejściowe o wysokiej rozdzielczości lub wysoki poziom myślenia mogą wydłużyć czas przetwarzania. W przypadku poziomu myślenia użyj średniego, aby zachować równowagę między czasem oczekiwania a wydajnością.
• Halucynacje: podobnie jak wszystkie duże modele językowe, modele Gemini Robotics ER mogą 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 treści zależy od precyzji prompta. Używaj konkretnych, dobrze skonstruowanych promptów.
• Koszt obliczeniowy: uruchomienie modelu, zwłaszcza w przypadku danych wejściowych w postaci filmów lub wysokiej wartości thinking_budget, zużywa zasoby obliczeniowe i wiąże się z kosztami. Więcej informacji znajdziesz na stronie Myślenie.
• Typy danych wejściowych: szczegółowe informacje o ograniczeniach dotyczących każdego trybu znajdziesz w tych artykułach:
  • Dane wejściowe dotyczące obrazów
  • Wejścia wideo
  • Wejścia audio

Informacje na temat ochrony prywatności

Przyjmujesz do wiadomości, że modele, o których mowa w tym dokumencie („Modele robotyki”), wykorzystują dane wideo i audio do działania i poruszania sprzętem zgodnie z Twoimi instrukcjami. W związku z tym możesz obsługiwać modele 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ę, że nie zezwolisz żadnym możliwym do rozpoznania osobom na interakcję z modelami robotów ani na przebywanie w obszarze wokół nich, dopóki nie zostaną one odpowiednio poinformowane o tym, że ich dane osobowe mogą być przekazywane do Google i wykorzystywane przez Google zgodnie z Dodatkowymi warunkami korzystania z usługi 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, oraz podejmiesz uzasadnione ekonomicznie starania, 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 możliwych do rozpoznania, w zakresie, w jakim jest to wykonalne.

Ceny

Szczegółowe informacje o cenach i dostępnych regionach znajdziesz na stronie cennika.

Punkty końcowe modelu

Co dalej?

• Rozumowanie przestrzenne – wskazywanie, śledzenie, ramki ograniczające, trajektorie.
• Funkcje agentowe – wykonywanie kodu, odczytywanie instrumentów, adnotacje do obrazów.
• Orkiestracja zadań – zadania długoterminowe z niestandardowymi interfejsami API robotów.
• Robotyka z przesyłaniem strumieniowym – dwukierunkowe przesyłanie strumieniowe w czasie rzeczywistym (tylko Gemini Robotics ER 2).
• Rozumienie wideo – wyszukiwanie momentów i klasyfikacja postępów (tylko Gemini Robotics ER 2).
• Bezpieczeństwo Gemini Robotics – badania nad bezpieczeństwem rodziny modeli.