이미지 이해
이미지 이해 (Image understanding)
Gemini 모델은 처음부터 멀티모달로 설계되어, 특수한 ML 모델을 학습하지 않아도 이미지 캡셔닝, 분류, 시각 질의응답 등 광범위한 이미지 처리 및 컴퓨터 비전 작업을 수행할 수 있어요.
일반 멀티모달 기능에 더해 Gemini 모델은 추가 학습을 통해 객체 감지 같은 특정 사용 사례에 대한 향상된 정확도를 제공해요.
출처: 원문
본문
Gemini에 이미지 전달하기 (Passing images to Gemini)
두 가지 방법으로 Gemini에 이미지를 입력으로 제공할 수 있어요:
- 인라인 이미지 데이터 전달: 더 작은 파일(프롬프트 포함 총 요청 크기 20MB 미만)에 이상적.
- File API로 이미지 업로드: 더 큰 파일이나 여러 요청에서 이미지 재사용에 권장.
인라인 이미지 데이터 전달 (Passing inline image data)
generateContent 요청에 인라인 이미지 데이터를 전달할 수 있어요. 이미지 데이터를 Base64 인코딩 문자열로 제공하거나(언어에 따라) 로컬 파일을 직접 읽어 제공할 수 있어요.
다음 예시는 로컬 파일에서 이미지를 읽어 generateContent API에 전달해 처리하는 방법을 보여줘요.
from google import genai
from google.genai import types
with open('path/to/small-sample.jpg', 'rb') as f:
image_bytes = f.read()
client = genai.Client()
response = client.models.generate_content(
model='gemini-3.8-flash',
contents=[
types.Part.from_bytes(
data=image_bytes,
mime_type='image/jpeg',
),
'Caption this image.'
]
)
print(response.text)
import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";
const ai = new GoogleGenAI({});
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-3.8-flash",
contents: contents,
});
console.log(response.text);
bytes, _ := os.ReadFile("path/to/small-sample.jpg")
parts := []*genai.Part{
genai.NewPartFromBytes(bytes, "image/jpeg"),
genai.NewPartFromText("Caption this image."),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
ctx,
"gemini-3.8-flash",
contents,
nil,
)
fmt.Println(result.Text())
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-3.8-flash:generateContent" \
-H "x-goog-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
URL에서 이미지를 가져와 바이트로 변환한 뒤 generateContent에 전달할 수도 있어요. 다음 예시에서 확인할 수 있어요.
from google import genai
from google.genai import types
import requests
image_path = "https://goo.gle/instrument-img"
image_bytes = requests.get(image_path).content
image = types.Part.from_bytes(
data=image_bytes, mime_type="image/jpeg"
)
client = genai.Client()
response = client.models.generate_content(
model="gemini-3.8-flash",
contents=["What is this image?", image],
)
print(response.text)
import { GoogleGenAI } from "@google/genai";
async function main() {
const ai = new GoogleGenAI({});
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-3.8-flash",
contents: [
{
inlineData: {
mimeType: 'image/jpeg',
data: base64ImageData,
},
},
{ text: "Caption this image." }
],
});
console.log(result.text);
}
main();
package main
import (
"context"
"fmt"
"os"
"io"
"net/http"
"google.golang.org/genai"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
// Download the image.
imageResp, _ := http.Get("https://goo.gle/instrument-img")
imageBytes, _ := io.ReadAll(imageResp.Body)
parts := []*genai.Part{
genai.NewPartFromBytes(imageBytes, "image/jpeg"),
genai.NewPartFromText("Caption this image."),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
ctx,
"gemini-3.8-flash",
contents,
nil,
)
fmt.Println(result.Text())
}
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
# Check for macOS
if [[ "$(uname)" == "Darwin" ]]; then
IMAGE_B64=$(curl -sL "$IMG_URL" | base64 -b 0)
elif [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
IMAGE_B64=$(curl -sL "$IMG_URL" | base64)
else
IMAGE_B64=$(curl -sL "$IMG_URL" | base64 -w0)
fi
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
-H "x-goog-api-key: *** \
-H 'Content-Type: application/json' \
-X POST \
-d '{
"contents": [{
"parts":[
{
"inline_data": {
"mime_type":"'"$MIME_TYPE"'",
"data": "'"$IMAGE_B64"'"
}
},
{"text": "Caption this image."}
]
}]
}' 2> /dev/null
참고: 인라인 이미지 데이터는 총 요청 크기(텍스트 프롬프트, 시스템 지시어, 인라인 바이트)를 20MB로 제한해요. 더 큰 요청은 File API로 이미지 파일을 업로드하세요. 같은 이미지를 반복해서 사용하는 시나리오에서도 Files API가 더 효율적이에요.
File API로 이미지 업로드하기 (Uploading images using the File API)
대용량 파일이거나 같은 이미지 파일을 반복적으로 사용하려면 Files API를 사용하세요. 다음 코드는 이미지 파일을 업로드한 뒤 generateContent 호출에서 그 파일을 사용해요. 자세한 내용과 예시는 Files API 가이드를 참고하세요.
from google import genai
client = genai.Client()
my_file = client.files.upload(file="path/to/sample.jpg")
response = client.models.generate_content(
model="gemini-3.8-flash",
contents=[my_file, "Caption this image."],
)
print(response.text)
import {
GoogleGenAI,
createUserContent,
createPartFromUri,
} from "@google/genai";
const ai = new GoogleGenAI({});
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-3.8-flash",
contents: createUserContent([
createPartFromUri(myfile.uri, myfile.mimeType),
"Caption this image.",
]),
});
console.log(response.text);
}
await main();
package main
import (
"context"
"fmt"
"os"
"google.golang.org/genai"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
uploadedFile, _ := client.Files.UploadFromPath(ctx, "path/to/sample.jpg", nil)
parts := []*genai.Part{
genai.NewPartFromText("Caption this image."),
genai.NewPartFromURI(uploadedFile.URI, uploadedFile.MIMEType),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
ctx,
"gemini-3.8-flash",
contents,
nil,
)
fmt.Println(result.Text())
}
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" \
-H "x-goog-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 "x-goog-api-key: *** \
-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 -r ".file.uri" file_info.json)
echo file_uri=$file_uri
# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
-H "x-goog-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
여러 이미지로 프롬프팅하기 (Prompting with multiple images)
contents 배열에 여러 이미지 Part 객체를 포함해 단일 프롬프트로 여러 이미지를 제공할 수 있어요. 인라인 데이터(로컬 파일 또는 URL)와 File API 참조를 섞을 수 있어요.
from google import genai
from google.genai import types
client = genai.Client()
# 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-3.8-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)
import {
GoogleGenAI,
createUserContent,
createPartFromUri,
} from "@google/genai";
import * as fs from "node:fs";
const ai = new GoogleGenAI({});
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-3.8-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();
// Upload the first image
image1Path := "path/to/image1.jpg"
uploadedFile, _ := client.Files.UploadFromPath(ctx, image1Path, nil)
// Prepare the second image as inline data
image2Path := "path/to/image2.jpeg"
imgBytes, _ := os.ReadFile(image2Path)
parts := []*genai.Part{
genai.NewPartFromText("What is different between these two images?"),
genai.NewPartFromBytes(imgBytes, "image/jpeg"),
genai.NewPartFromURI(uploadedFile.URI, uploadedFile.MIMEType),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
result, _ := client.Models.GenerateContent(
ctx,
"gemini-3.8-flash",
contents,
nil,
)
fmt.Println(result.Text())
# 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" \
-H "x-goog-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-3.8-flash:generateContent" \
-H "x-goog-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
객체 감지 (Object detection)
모델은 이미지에서 객체를 감지하고 바운딩 박스 좌표를 얻도록 학습돼요. 이미지 크기 기준 좌표는 [0, 1000]으로 스케일돼요. 이 좌표를 원본 이미지 크기에 따라 다시 스케일(descale)해야 해요.
from google import genai
from google.genai import types
from PIL import Image
import json
client = genai.Client()
prompt = "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."
image = Image.open("/path/to/image.png")
config = types.GenerateContentConfig(
response_mime_type="application/json"
)
response = client.models.generate_content(model="gemini-3.8-flash",
contents=[image, prompt],
config=config
)
width, height = image.size
bounding_boxes = json.loads(response.text)
converted_bounding_boxes = []
for bounding_box in bounding_boxes:
abs_y1 = int(bounding_box["box_2d"][0]/1000 * height)
abs_x1 = int(bounding_box["box_2d"][1]/1000 * width)
abs_y2 = int(bounding_box["box_2d"][2]/1000 * height)
abs_x2 = int(bounding_box["box_2d"][3]/1000 * width)
converted_bounding_boxes.append([abs_x1, abs_y1, abs_x2, abs_y2])
print("Image size: ", width, height)
print("Bounding boxes:", converted_bounding_boxes)
import { GoogleGenAI } from "@google/genai";
import * as fs from "node:fs";
const ai = new GoogleGenAI({});
const base64ImageFile = fs.readFileSync("/path/to/image.png", {
encoding: "base64",
});
const response = await ai.models.generateContent({
model: "gemini-3.8-flash",
contents: [
{
inlineData: {
mimeType: "image/png",
data: base64ImageFile,
},
},
"Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."
],
config: {
responseMimeType: "application/json",
},
});
const boundingBoxes = JSON.parse(response.text);
console.log(boundingBoxes);
// To convert normalized coordinates to absolute pixels:
// const absY1 = (boundingBoxes[0].box_2d[0] / 1000) * imageHeight;
// const absX1 = (boundingBoxes[0].box_2d[1] / 1000) * imageWidth;
package main
import (
"context"
"encoding/json"
"fmt"
"image"
_ "image/png" // Register PNG decoder
"log"
"os"
"google.golang.org/genai"
)
type BoundingBox struct {
Box2D []int `json:"box_2d"`
Label string `json:"label"`
}
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
imagePath := "/path/to/image.png"
// Open the image to get dimensions
file, err := os.Open(imagePath)
if err != nil {
log.Fatal(err)
}
defer file.Close()
imgConfig, _, err := image.DecodeConfig(file)
if err != nil {
log.Fatal(err)
}
width := imgConfig.Width
height := imgConfig.Height
// Read image bytes
imageBytes, err := os.ReadFile(imagePath)
if err != nil {
log.Fatal(err)
}
prompt := "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."
parts := []*genai.Part{
genai.NewPartFromBytes(imageBytes, "image/png"),
genai.NewPartFromText(prompt),
}
contents := []*genai.Content{
genai.NewContentFromParts(parts, genai.RoleUser),
}
config := &genai.GenerateContentConfig{
ResponseMIMEType: "application/json",
}
result, err := client.Models.GenerateContent(
ctx,
"gemini-3.8-flash",
contents,
config,
)
if err != nil {
log.Fatal(err)
}
var boundingBoxes []BoundingBox
err = json.Unmarshal([]byte(result.Text()), &boundingBoxes)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Image size: %d %d\n", width, height)
fmt.Println("Bounding boxes:")
for _, box := range boundingBoxes {
if len(box.Box2D) == 4 {
absY1 := int(float64(box.Box2D[0]) / 1000.0 * float64(height))
absX1 := int(float64(box.Box2D[1]) / 1000.0 * float64(width))
absY2 := int(float64(box.Box2D[2]) / 1000.0 * float64(height))
absX2 := int(float64(box.Box2D[3]) / 1000.0 * float64(width))
fmt.Printf("- %s: [%d, %d, %d, %d]\n", box.Label, absX1, absY1, absX2, absY2)
}
}
}
IMG_PATH="/path/to/image.png"
if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
B64FLAGS="--input"
else
B64FLAGS="-w0"
fi
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent" \
-H "x-goog-api-key: *** \
-H 'Content-Type: application/json' \
-X POST \
-d '{
"contents": [{
"parts":[
{
"inline_data": {
"mime_type":"image/png",
"data": "'"$(base64 $B64FLAGS $IMG_PATH)"'"
}
},
{"text": "Detect the all of the prominent items in the image. The box_2d should be [ymin, xmin, ymax, xmax] normalized to 0-1000."}
]
}],
"generationConfig": {
"responseMimeType": "application/json"
}
}' 2> /dev/null
참고: 모델은 "이 이미지의 모든 초록 객체의 바운딩 박스를 보여줘" 같은 커스텀 지시에 기반한 바운딩 박스 생성도 지원해요. "항목에 포함할 수 있는 알레르겐으로 라벨을 붙여" 같은 커스텀 라벨도 지원해요.
더 많은 예시는 Gemini Cookbook의 다음 노트북을 확인하세요:
지원 이미지 형식 (Supported image formats)
Gemini는 다음 이미지 형식 MIME 유형을 지원해요:
- PNG -
image/png - JPEG -
image/jpeg - WEBP -
image/webp - HEIC -
image/heic - HEIF -
image/heif
다른 파일 입력 방법에 대해 알아보려면 파일 입력 방법 가이드를 참고하세요.
기능 (Capabilities)
모든 Gemini 모델 버전은 멀티모달이며 이미지 캡셔닝, 시각 질의응답, 이미지 분류, 객체 감지를 포함한(여기에 국한되지 않음) 광범위한 이미지 처리 및 컴퓨터 비전 작업에 사용할 수 있어요.
Gemini는 품질과 성능 요구 사항에 따라 특수 ML 모델의 필요를 줄일 수 있어요.
최신 모델 버전은 일반 기능에 더해 향상된 객체 감지 같은 특수 작업의 정확도를 높이기 위해 특별히 학습돼요.
제한 사항 및 주요 기술 정보 (Limitations and key technical information)
파일 한도 (File limit)
Gemini 모델은 요청당 최대 3,600개 이미지 파일을 지원해요.
토큰 계산 (Token calculation)
- 두 치수 모두 384픽셀 이하이면 258토큰. 더 큰 이미지는 768x768 픽셀 타일로 분할되며, 각 타일당 258토큰이 소요돼요.
타일 수를 계산하는 대략적인 공식은 다음과 같아요:
- 크롭 단위 크기(crop unit size)를 대략 계산:
floor(min(width, height) / 1.5). - 각 치수를 크롭 단위 크기로 나누고 곱해 타일 수를 계산.
예를 들어 960x540 크기 이미지의 크롭 단위 크기는 360이에요. 각 치수를 360으로 나누면 타일 수는 3 * 2 = 6이 돼요.
미디어 해상도 (Media resolution)
Gemini 3은 media_resolution 매개변수로 멀티모달 비전 처리에 대한 세밀한 제어를 도입해요. media_resolution 매개변수는 입력 이미지 또는 비디오 프레임당 할당되는 최대 토큰 수를 결정해요. 더 높은 해상도는 모델이 미세한 텍스트를 읽거나 작은 세부 사항을 식별하는 능력을 향상시키지만, 토큰 사용량과 지연 시간은 증가해요.
매개변수와 토큰 계산에 미치는 영향에 대한 자세한 내용은 media resolution 가이드를 참고하세요.
팁과 모범 사례 (Tips and best practices)
- 이미지가 올바르게 회전되어 있는지 확인하세요.
- 선명하고 흐릿하지 않은 이미지를 사용하세요.
- 단일 이미지를 텍스트와 함께 사용할 때는
contents배열에서 이미지 파트 뒤에 텍스트 프롬프트를 두세요.
다음 단계 (What's next)
이 가이드는 이미지 파일을 업로드하고 이미지 입력에서 텍스트 출력을 생성하는 방법을 보여줘요. 더 알아보려면 다음 자료를 참고하세요:
- Files API: Gemini와 함께 사용할 파일 업로드·관리 방법.
- 시스템 지시어: 시스템 지시어로 특정 요구와 사용 사례에 따라 모델 동작을 조정.
- 파일 프롬프팅 전략: Gemini API는 텍스트·이미지·오디오·비디오 데이터(멀티모달 프롬프팅이라고도 함)로 프롬프트하는 것을 지원.
- 안전 지침: 때때로 생성형 AI 모델은 부정확하거나 편향되거나 공격적인 출력 같은 예기치 않은 출력을 생성해요. 사후 처리와 인간 평가가 그러한 출력의 피해 위험을 제한하는 데 필수적이에요.
더 알아보기 (Learn more)
- Files API — 파일 업로드·관리.
- 파일 프롬프팅 전략 — 멀티모달 프롬프팅.
- 미디어 해상도 — 토큰 할당 제어.