Gemini 2.5 Pro Preview tani është i disponueshëm për përdorim në prodhim! Mësoni më shumë

Kjo faqe është përkthyer nga Cloud Translation API.

Kuptimi i imazhit

Modelet e Gemini mund të përpunojnë imazhe, duke mundësuar shumë raste të përdorimit të zhvilluesve kufitarë që do të kishin kërkuar historikisht modele specifike të domenit. Disa nga aftësitë e vizionit të Binjakëve përfshijnë aftësinë për të:

Shkruani dhe përgjigjuni pyetjeve rreth imazheve
Transkriptoni dhe arsyetoni mbi skedarët PDF, duke përfshirë deri në 2 milion argumente
Zbuloni objektet në një imazh dhe ktheni koordinatat e kutisë kufizuese për to
Segmentoni objektet brenda një imazhi

Binjakët u ndërtuan për të qenë multimodal nga themeli dhe ne vazhdojmë të shtyjmë kufirin e asaj që është e mundur. Ky udhëzues tregon se si të përdoret Gemini API për të gjeneruar përgjigje teksti bazuar në hyrjet e imazheve dhe për të kryer detyra të zakonshme për të kuptuar imazhin.

Para se të filloni

Përpara se të telefononi Gemini API, sigurohuni që keni të instaluar SDK-në tuaj të zgjedhur dhe një çelës Gemini API të konfiguruar dhe gati për t'u përdorur.

Hyrja e imazhit

Ju mund të jepni imazhe si hyrje për Binjakët në mënyrat e mëposhtme:

Ngarkoni një skedar imazhi duke përdorur API-në e skedarit përpara se të bëni një kërkesë për generateContent . Përdoreni këtë metodë për skedarë më të mëdhenj se 20 MB ose kur dëshironi të ripërdorni skedarin në shumë kërkesa.
Kaloni të dhënat e imazhit në linjë me kërkesën për generateContent . Përdoreni këtë metodë për skedarë më të vegjël (<20 MB madhësia totale e kërkesës) ose imazhe të marra direkt nga URL-të.

Ngarko një skedar imazhi

Ju mund të përdorni Files API për të ngarkuar një skedar imazhi. Përdorni gjithmonë API-në e skedarëve kur madhësia totale e kërkesës (përfshirë skedarin, kërkesën për tekst, udhëzimet e sistemit, etj.) është më e madhe se 20 MB, ose nëse keni ndërmend të përdorni të njëjtin imazh në disa kërkesa.

Kodi i mëposhtëm ngarkon një skedar imazhi dhe më pas përdor skedarin në një thirrje për generateContent .

Python

from google import genai

client = genai.Client(api_key="GOOGLE_API_KEY")

myfile = client.files.upload(file="path/to/sample.jpg")

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[myfile, "Caption this image."])

print(response.text)

JavaScript

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  const myfile = await ai.files.upload({
    file: "path/to/sample.jpg",
    config: { mimeType: "image/jpeg" },
  });

  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: createUserContent([
      createPartFromUri(myfile.uri, myfile.mimeType),
      "Caption this image.",
    ]),
  });
  console.log(response.text);
}

await main();

Shkoni

file, err := client.UploadFileFromPath(ctx, "path/to/sample.jpg", nil)
if err != nil {
    log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-2.0-flash")
resp, err := model.GenerateContent(ctx,
    genai.FileData{URI: file.URI},
    genai.Text("Caption this image."))
if err != nil {
    log.Fatal(err)
}

printResponse(resp)

PUSHIMI

IMAGE_PATH="path/to/sample.jpg"
MIME_TYPE=$(file -b --mime-type "${IMAGE_PATH}")
NUM_BYTES=$(wc -c < "${IMAGE_PATH}")
DISPLAY_NAME=IMAGE

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${IMAGE_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data":{"mime_type": "${MIME_TYPE}", "file_uri": '$file_uri'}},
          {"text": "Caption this image."}]
        }]
      }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

Për të mësuar më shumë rreth punës me skedarët e medias, shihni Files API .

Kaloni të dhënat e imazhit në linjë

Në vend që të ngarkoni një skedar imazhi, mund të kaloni të dhënat e imazhit në linjë në kërkesën për generateContent . Kjo është e përshtatshme për imazhe më të vogla (më pak se 20 MB madhësia totale e kërkesës) ose imazhe të marra direkt nga URL-të.

Mund të jepni të dhëna imazhi si vargje të koduara Base64 ose duke lexuar skedarët lokalë drejtpërdrejt (në varësi të SDK).

Skedari lokal i imazhit:

Python

  from google.genai import types

  with open('path/to/small-sample.jpg', 'rb') as f:
      img_bytes = f.read()

  response = client.models.generate_content(
    model='gemini-2.0-flash',
    contents=[
      types.Part.from_bytes(
        data=img_bytes,
        mime_type='image/jpeg',
      ),
      'Caption this image.'
    ]
  )

  print(response.text)

JavaScript

import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });
const base64ImageFile = fs.readFileSync("path/to/small-sample.jpg", {
  encoding: "base64",
});

const contents = [
  {
    inlineData: {
      mimeType: "image/jpeg",
      data: base64ImageFile,
    },
  },
  { text: "Caption this image." },
];

const response = await ai.models.generateContent({
  model: "gemini-2.0-flash",
  contents: contents,
});
console.log(response.text);

Shkoni

model := client.GenerativeModel("gemini-2.0-flash")

bytes, err := os.ReadFile("path/to/small-sample.jpg")
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.Blob{MIMEType: "image/jpeg", Data: bytes},
  genai.Text("Caption this image."),
}

resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
  log.Fatal(err)
}

for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

PUSHIMI

IMG_PATH=/path/to/your/image1.jpg

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {
              "inline_data": {
                "mime_type":"image/jpeg",
                "data": "'\$(base64 \$B64FLAGS \$IMG_PATH)'"
              }
            },
            {"text": "Caption this image."},
        ]
      }]
    }' 2> /dev/null

Imazhi nga URL-ja:

Python

from google import genai
from google.genai import types

import requests

image_path = "https://goo.gle/instrument-img"
image = requests.get(image_path)

client = genai.Client(api_key="GOOGLE_API_KEY")
response = client.models.generate_content(
    model="gemini-2.0-flash-exp",
    contents=["What is this image?",
              types.Part.from_bytes(data=image.content, mime_type="image/jpeg")])

print(response.text)

JavaScript

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

async function main() {
  const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_API_KEY });

  const imageUrl = "https://goo.gle/instrument-img";

  const response = await fetch(imageUrl);
  const imageArrayBuffer = await response.arrayBuffer();
  const base64ImageData = Buffer.from(imageArrayBuffer).toString('base64');

  const result = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: [
    {
      inlineData: {
        mimeType: 'image/jpeg',
        data: base64ImageData,
      },
    },
    { text: "Caption this image." }
  ],
  });
  console.log(result.text);
}

main();

Shkoni

func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("GOOGLE_API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-2.0-flash")

// Download the image.
imageResp, err := http.Get("https://goo.gle/instrument-img")
if err != nil {
  panic(err)
}
defer imageResp.Body.Close()

imageBytes, err := io.ReadAll(imageResp.Body)
if err != nil {
  panic(err)
}

// Create the request.
req := []genai.Part{
  genai.ImageData("jpeg", imageBytes),

  genai.Text("Caption this image."),
}

// Generate content.
resp, err := model.GenerateContent(ctx, req...)
if err != nil {
  panic(err)
}

// Handle the response of generated text.
for _, c := range resp.Candidates {
  if c.Content != nil {
    fmt.Println(*c.Content)
  }
}

}

PUSHIMI

IMG_URL="https://goo.gle/instrument-img"

MIME_TYPE=$(curl -sIL "$IMG_URL" | grep -i '^content-type:' | awk -F ': ' '{print $2}' | sed 's/\r$//' | head -n 1)
if [[ -z "$MIME_TYPE" || ! "$MIME_TYPE" == image/* ]]; then
  MIME_TYPE="image/jpeg"
fi

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
            {
              "inline_data": {
                "mime_type":"'"$MIME_TYPE"'",
                "data": "'$(curl -sL "$IMG_URL" | base64 $B64FLAGS)'"
              }
            },
            {"text": "Caption this image."}
        ]
      }]
    }' 2> /dev/null

Disa gjëra që duhen mbajtur parasysh në lidhje me të dhënat e imazhit të brendshëm:

Madhësia maksimale totale e kërkesës është 20 MB, e cila përfshin kërkesat e tekstit, udhëzimet e sistemit dhe të gjithë skedarët e dhënë në linjë. Nëse madhësia e skedarit tuaj do të bëjë që madhësia totale e kërkesës të kalojë 20 MB, atëherë përdorni API-në e skedarëve për të ngarkuar një skedar imazhi për përdorim në kërkesë.
Nëse jeni duke përdorur një mostër imazhi disa herë, është më efikase të ngarkoni një skedar imazhi duke përdorur File API.

Nxitja me imazhe të shumta

Ju mund të ofroni imazhe të shumta në një kërkesë të vetme duke përfshirë objekte të shumta Part imazhit në grupin contents . Këto mund të jenë një përzierje e të dhënave inline (skedarë lokalë ose URL) dhe referenca të API-së së skedarit.

Python

from google import genai
from google.genai import types

client = genai.Client(api_key="GOOGLE_API_KEY")

# Upload the first image
image1_path = "path/to/image1.jpg"
uploaded_file = client.files.upload(file=image1_path)

# Prepare the second image as inline data
image2_path = "path/to/image2.png"
with open(image2_path, 'rb') as f:
    img2_bytes = f.read()

# Create the prompt with text and multiple images
response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[
        "What is different between these two images?",
        uploaded_file,  # Use the uploaded file reference
        types.Part.from_bytes(
            data=img2_bytes,
            mime_type='image/png'
        )
    ]
)

print(response.text)

JavaScript

import {
  GoogleGenAI,
  createUserContent,
  createPartFromUri,
} from "@google/genai";
import * as fs from "node:fs";

const ai = new GoogleGenAI({ apiKey: "GOOGLE_API_KEY" });

async function main() {
  // Upload the first image
  const image1_path = "path/to/image1.jpg";
  const uploadedFile = await ai.files.upload({
    file: image1_path,
    config: { mimeType: "image/jpeg" },
  });

  // Prepare the second image as inline data
  const image2_path = "path/to/image2.png";
  const base64Image2File = fs.readFileSync(image2_path, {
    encoding: "base64",
  });

  // Create the prompt with text and multiple images
  const response = await ai.models.generateContent({
    model: "gemini-2.0-flash",
    contents: createUserContent([
      "What is different between these two images?",
      createPartFromUri(uploadedFile.uri, uploadedFile.mimeType),
      {
        inlineData: {
          mimeType: "image/png",
          data: base64Image2File,
        },
      },
    ]),
  });
  console.log(response.text);
}

await main();

Shkoni

+    // Upload the first image
image1Path := "path/to/image1.jpg"
uploadedFile, err := client.UploadFileFromPath(ctx, image1Path, nil)
if err != nil {
    log.Fatal(err)
}
defer client.DeleteFile(ctx, uploadedFile.Name)

// Prepare the second image as inline data
image2Path := "path/to/image2.png"
img2Bytes, err := os.ReadFile(image2Path)
if err != nil {
  log.Fatal(err)
}

// Create the prompt with text and multiple images
model := client.GenerativeModel("gemini-2.0-flash")
prompt := []genai.Part{
  genai.Text("What is different between these two images?"),
  genai.FileData{URI: uploadedFile.URI},
  genai.Blob{MIMEType: "image/png", Data: img2Bytes},
}

resp, err := model.GenerateContent(ctx, prompt...)
if err != nil {
  log.Fatal(err)
}

printResponse(resp)

PUSHIMI

# Upload the first image
IMAGE1_PATH="path/to/image1.jpg"
MIME1_TYPE=$(file -b --mime-type "${IMAGE1_PATH}")
NUM1_BYTES=$(wc -c < "${IMAGE1_PATH}")
DISPLAY_NAME1=IMAGE1

tmp_header_file1=upload-header1.tmp

curl "https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header1.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM1_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME1_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME1}'}}" 2> /dev/null

upload_url1=$(grep -i "x-goog-upload-url: " "${tmp_header_file1}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file1}"

curl "${upload_url1}" \
  -H "Content-Length: ${NUM1_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${IMAGE1_PATH}" 2> /dev/null > file_info1.json

file1_uri=$(jq ".file.uri" file_info1.json)
echo file1_uri=$file1_uri

# Prepare the second image (inline)
IMAGE2_PATH="path/to/image2.png"
MIME2_TYPE=$(file -b --mime-type "${IMAGE2_PATH}")

if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi
IMAGE2_BASE64=$(base64 $B64FLAGS $IMAGE2_PATH)

# Now generate content using both images
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "What is different between these two images?"},
          {"file_data":{"mime_type": "'"${MIME1_TYPE}"'", "file_uri": '$file1_uri'}},
          {
            "inline_data": {
              "mime_type":"'"${MIME2_TYPE}"'",
              "data": "'"$IMAGE2_BASE64"'"
            }
          }
        ]
      }]
    }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

Merrni një kuti kufizuese për një objekt

Modelet e Binjakëve janë trajnuar për të identifikuar objektet në një imazh dhe për të dhënë koordinatat e tyre kufizuese. Koordinatat kthehen në lidhje me dimensionet e imazhit, të shkallëzuara në [0, 1000]. Ju duhet të hiqni shkallën e këtyre koordinatave bazuar në madhësinë e imazhit tuaj origjinal.

Python

prompt = "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."

JavaScript

const prompt = "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000.";

Shkoni

prompt := []genai.Part{
    genai.FileData{URI: sampleImage.URI},
    genai.Text("Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."),
}

PUSHIMI

PROMPT="Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."

Ju mund të përdorni kutitë kufizuese për zbulimin dhe lokalizimin e objekteve brenda imazheve dhe videove. Duke identifikuar dhe përcaktuar me saktësi objektet me kuti kufizuese, ju mund të zhbllokoni një gamë të gjerë aplikacionesh dhe të përmirësoni inteligjencën e projekteve tuaja.

Përfitimet kryesore

E thjeshtë: Integroni me lehtësi aftësitë e zbulimit të objekteve në aplikacionet tuaja, pavarësisht nga ekspertiza juaj e vizionit kompjuterik.
I personalizueshëm: Krijoni kuti kufizuese bazuar në udhëzimet e personalizuara (p.sh. "Dua të shoh kutitë kufizuese të të gjitha objekteve të gjelbra në këtë imazh"), pa pasur nevojë të trajnoj një model të personalizuar.

Detaje teknike

Hyrja: Imazhet ose kornizat e videos suaj të menjëhershme dhe të lidhura.
Dalja: Kufizimet e kutive në formatin [y_min, x_min, y_max, x_max] . Këndi i sipërm majtas është origjina. Boshtet x dhe y shkojnë përkatësisht horizontalisht dhe vertikalisht. Vlerat e koordinatave normalizohen në 0-1000 për çdo imazh.
Vizualizimi: Përdoruesit e AI Studio do të shohin kutitë kufizuese të vizatuara brenda ndërfaqes së përdoruesit.

Për zhvilluesit e Python, provoni fletoren 2D të kuptimit hapësinor ose fletoren eksperimentale me drejtim 3D .

Normalizoni koordinatat

Modeli kthen koordinatat e kutisë kufizuese në formatin [y_min, x_min, y_max, x_max] . Për të kthyer këto koordinata të normalizuara në koordinatat e pikselit të imazhit tuaj origjinal, ndiqni këto hapa:

Ndani çdo koordinatë dalëse me 1000.
Shumëzoni koordinatat x me gjerësinë e imazhit origjinal.
Shumëzoni koordinatat y me lartësinë origjinale të figurës.

Për të eksploruar shembuj më të detajuar të gjenerimit të koordinatave të kutive kufizuese dhe vizualizimit të tyre në imazhe, rishikoni shembullin e librit të gatimit të Zbulimit të objekteve .

Segmentimi i imazhit

Duke filluar me modelet Gemini 2.5, modelet Gemini janë trajnuar jo vetëm për të zbuluar artikujt, por edhe për t'i segmentuar ato dhe për të siguruar një maskë të kontureve të tyre.

Modeli parashikon një listë JSON, ku çdo artikull përfaqëson një maskë segmentimi. Çdo artikull ka një kuti kufizuese (" box_2d ") në formatin [y0, x0, y1, x1] me koordinata të normalizuara midis 0 dhe 1000, një etiketë (" label ") që identifikon objektin dhe në fund maskën e segmentimit brenda kutisë kufitare, si baza64 e koduar png që është një vlerë e probabilitetit për t'u maskuar 5 dhe harta duhet të ripërcaktohet midis 5 maskave përputhen me dimensionet e kutisë kufizuese, pastaj binarizuar në pragun tuaj të besimit (127 për pikën e mesit).

Python

prompt = """
  Give the segmentation masks for the wooden and glass items.
  Output a JSON list of segmentation masks where each entry contains the 2D
  bounding box in the key "box_2d", the segmentation mask in key "mask", and
  the text label in the key "label". Use descriptive labels.
"""

JavaScript

const prompt = `
  Give the segmentation masks for the wooden and glass items.
  Output a JSON list of segmentation masks where each entry contains the 2D
  bounding box in the key "box_2d", the segmentation mask in key "mask", and
  the text label in the key "label". Use descriptive labels.
`;

Shkoni

prompt := []genai.Part{
    genai.FileData{URI: sampleImage.URI},
    genai.Text(`
      Give the segmentation masks for the wooden and glass items.
      Output a JSON list of segmentation masks where each entry contains the 2D
      bounding box in the key "box_2d", the segmentation mask in key "mask", and
      the text label in the key "label". Use descriptive labels.
    `),
}

PUSHIMI

PROMPT='''
  Give the segmentation masks for the wooden and glass items.
  Output a JSON list of segmentation masks where each entry contains the 2D
  bounding box in the key "box_2d", the segmentation mask in key "mask", and
  the text label in the key "label". Use descriptive labels.
'''

Një tavolinë me cupcakes, me objektet prej druri dhe xhami të theksuar — Maska e objekteve prej druri dhe qelqi që gjenden në foto

Kontrolloni shembullin e segmentimit në udhëzuesin e librit të gatimit për një shembull më të detajuar.

Formatet e imazhit të mbështetur

Gemini mbështet llojet e mëposhtme të formatit të imazhit MIME:

PNG - image/png
JPEG - image/jpeg
WEBP - image/webp
HEIC - image/heic
HEIF - image/heif

Detaje teknike rreth imazheve

Kufiri i skedarëve : Gemini 2.5 Pro, 2.0 Flash, 1.5 Pro dhe 1.5 Flash mbështesin një maksimum prej 3600 skedarësh imazhi për kërkesë.
Llogaritja e tokenit :
- Gemini 1.5 Flash dhe Gemini 1.5 Pro : 258 argumente nëse të dy dimensionet <= 384 piksele. Imazhet më të mëdha janë të mbuluara me pllaka (min pllakë 256 pikselë, maksimum 768 pikselë, madhësia e ndryshuar në 768x768), me çdo pllakë që kushton 258 argumente.
- Gemini 2.0 Flash : 258 argumente nëse të dy dimensionet <= 384 piksele. Imazhet më të mëdha vendosen në pllaka 768x768 pixel, secila kushton 258 tokena.
Praktikat më të mira :
- Sigurohuni që imazhet të jenë rrotulluar saktë.
- Përdorni imazhe të qarta dhe jo të turbullta.
- Kur përdorni një imazh të vetëm me tekst, vendosni kërkesën e tekstit pas pjesës së imazhit në grupin contents .

Çfarë është më pas

Ky udhëzues tregon se si të ngarkoni skedarë imazhi dhe të krijoni rezultate teksti nga hyrjet e imazhit. Për të mësuar më shumë, shikoni burimet e mëposhtme:

Udhëzimet e sistemit : Udhëzimet e sistemit ju lejojnë të drejtoni sjelljen e modelit bazuar në nevojat tuaja specifike dhe rastet e përdorimit.
Kuptimi i videos : Mësoni se si të punoni me hyrjet e videos.
Files API : Mësoni më shumë rreth ngarkimit dhe menaxhimit të skedarëve për përdorim me Gemini.
Strategjitë e nxitjes së skedarëve : Gemini API mbështet nxitjen me të dhëna teksti, imazhi, audio dhe video, të njohura gjithashtu si nxitje multimodale.
Udhëzime për sigurinë : Ndonjëherë modelet gjeneruese të AI prodhojnë rezultate të papritura, të tilla si rezultate që janë të pasakta, të njëanshme ose fyese. Pas-përpunimi dhe vlerësimi njerëzor janë thelbësore për të kufizuar rrezikun e dëmtimit nga rezultate të tilla.