Bagikan melalui

Menggunakan model fondasi

Dalam artikel ini, Anda mempelajari cara menulis permintaan kueri untuk model fondasi dan mengirimkannya ke titik akhir penyajian model Anda. Anda dapat mengkueri model fondasi yang dihosting oleh Databricks dan model fondasi yang dihosting di luar Databricks.

Untuk permintaan kueri model ML atau Python tradisional, lihat Kueri yang melayani titik akhir untuk model kustom.

Mosaic AI Model Serving mendukung API Model Foundation dan model eksternal untuk mengakses model fondasi. Model Serving menggunakan API dan SDK yang kompatibel dengan OpenAI terpadu untuk mengkuerinya. Hal ini memungkinkan untuk bereksperimen dengan dan menyesuaikan model fondasi untuk produksi di seluruh cloud dan penyedia yang didukung.

Mosaic AI Model Serving menyediakan opsi berikut untuk mengirim permintaan penilaian ke titik akhir yang melayani model fondasi atau model eksternal:

Metode Detail-detail
Klien OpenAI Menjalankan kueri pada model yang dihosting oleh endpoint Mosaic AI Model Serving menggunakan klien OpenAI. Tentukan nama titik akhir penyajian model model sebagai input. Didukung untuk model obrolan, penyematan, dan penyelesaian yang disediakan oleh API Model Foundation atau model eksternal.
Fungsi SQL Panggil inferensi model langsung dari SQL menggunakan ai_query fungsi SQL. Lihat Contoh: Mengkueri model fondasi.
Menampilkan UI Pilih Titik akhir kueri dari halaman Titik akhir penayangan . Sisipkan data input model format JSON dan klik Kirim Permintaan. Jika model memiliki contoh input yang dicatat, gunakan Tampilkan Contoh untuk memuatnya.
REST API Panggil dan kueri model menggunakan REST API. Lihat POST /serving-endpoints/{name}/invocations untuk detailnya. Untuk permintaan penilaian ke titik akhir yang melayani beberapa model, lihat Mengkueri model individual di belakang titik akhir.
SDK MLflow untuk Penyebaran Gunakan fungsi predict() MLflow Deployments SDK untuk mengkueri model.
Databricks Python SDK Databricks Python SDK adalah lapisan di atas REST API. Ini menangani detail tingkat rendah, seperti autentikasi, sehingga lebih mudah untuk berinteraksi dengan model.

Persyaratan

Penting

Sebagai praktik terbaik keamanan untuk skenario produksi, Databricks merekomendasikan agar Anda menggunakan token OAuth mesin-ke-mesin untuk autentikasi selama produksi.

Untuk pengujian dan pengembangan, Databricks merekomendasikan penggunaan token akses pribadi milik perwakilan layanan alih-alih pengguna ruang kerja. Untuk membuat token untuk perwakilan layanan, lihat Mengelola token untuk perwakilan layanan.

Memasang paket

Setelah memilih metode kueri, Anda harus terlebih dahulu menginstal paket yang sesuai ke kluster Anda.

Klien OpenAI

Untuk menggunakan klien OpenAI, databricks-sdk[openai] paket perlu diinstal pada kluster Anda. Databricks SDK menyediakan pembungkus untuk membangun klien OpenAI dengan otorisasi yang dikonfigurasi secara otomatis untuk mengkueri model AI generatif. Jalankan hal berikut ini di buku catatan atau terminal lokal Anda:

!pip install databricks-sdk[openai]>=0.35.0

Berikut ini hanya diperlukan saat menginstal paket pada Databricks Notebook

dbutils.library.restartPython()

REST API

Akses ke Serving REST API tersedia di Databricks Runtime untuk Machine Learning.

SDK MLflow untuk Penyebaran

!pip install mlflow

Berikut ini hanya diperlukan saat menginstal paket pada Databricks Notebook

dbutils.library.restartPython()

Databricks Python SDK

Databricks SDK untuk Python sudah diinstal pada semua kluster Azure Databricks yang menggunakan Databricks Runtime 13.3 LTS atau lebih tinggi. Untuk kluster Azure Databricks yang menggunakan Databricks Runtime 12.2 LTS dan di bawahnya, Anda harus menginstal Databricks SDK untuk Python terlebih dahulu. Lihat Databricks SDK untuk Python.

Permintaan model pelengkapan teks

Klien OpenAI

Penting

Mengkueri model penyelesaian teks yang disediakan menggunakan API Model Foundation bayar per token menggunakan klien OpenAI tidak didukung. Hanya mengkueri model eksternal menggunakan klien OpenAI yang didukung seperti yang ditunjukkan di bagian ini.

Untuk menggunakan klien OpenAI, tentukan nama titik akhir model sebagai model input. Contoh berikut mengkueri claude-2 model penyelesaian yang dihosting oleh Anthropic menggunakan klien OpenAI. Untuk menggunakan client OpenAI, isi model bidang dengan nama model yang melayani endpoint yang menghosting model yang ingin Anda query.

Contoh ini menggunakan endpoint yang telah dibuat sebelumnya, anthropic-completions-endpoint, yang dikonfigurasi untuk mengakses model eksternal dari penyedia model Anthropic. Lihat cara membuat titik akhir model eksternal.

Lihat Model yang didukung untuk model tambahan yang bisa Anda kueri dan penyedianya.


from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
openai_client = w.serving_endpoints.get_open_ai_client()

completion = openai_client.completions.create(
model="anthropic-completions-endpoint",
prompt="what is databricks",
temperature=1.0
)
print(completion)

SQL

Penting

Contoh berikut menggunakan fungsi SQL bawaan, ai_query. Fungsi ini adalah Pratinjau Publik dan definisinya mungkin berubah.

SELECT ai_query(
    "<completions-model-endpoint>",
    "Can you explain AI in ten words?"
  )

REST API

Berikut adalah permintaan komplit untuk menanyakan model penyelesaian yang tersedia menggunakan model eksternal.

Penting

Contoh berikut menggunakan parameter REST API untuk mengkueri titik akhir penyajian yang melayani model eksternal. Parameter ini ada di Pratinjau Umum dan definisinya mungkin berubah. Lihat POST /serving-endpoints/{name}/invocations.


curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{"prompt": "What is a quoll?", "max_tokens": 64}' \
https://<workspace_host>.databricks.com/serving-endpoints/<completions-model-endpoint>/invocations

SDK MLflow untuk Penyebaran

Berikut adalah permintaan komplit untuk menanyakan model penyelesaian yang tersedia menggunakan model eksternal.

Penting

Contoh berikut menggunakan predict() API dari MLflow Deployments SDK.


import os
import mlflow.deployments

# Only required when running this example outside of a Databricks Notebook

os.environ['DATABRICKS_HOST'] = "https://<workspace_host>.databricks.com"
os.environ['DATABRICKS_TOKEN'] = "dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

completions_response = client.predict(
    endpoint="<completions-model-endpoint>",
    inputs={
        "prompt": "What is the capital of France?",
        "temperature": 0.1,
        "max_tokens": 10,
        "n": 2
    }
)

# Print the response
print(completions_response)

Databricks Python SDK

Berikut ini adalah permintaan penyelesaian untuk mengkueri model penyelesaian yang disediakan menggunakan model eksternal.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="<completions-model-endpoint>",
    prompt="Write 3 reasons why you should train an AI model on domain specific data sets."
)
print(response.choices[0].text)

Berikut ini adalah format permintaan yang diharapkan untuk model penyelesaian. Untuk model eksternal, Anda dapat menyertakan parameter tambahan yang valid untuk penyedia dan konfigurasi titik akhir tertentu. Lihat Parameter kueri tambahan.

{
  "prompt": "What is mlflow?",
  "max_tokens": 100,
  "temperature": 0.1,
  "stop": [
    "Human:"
  ],
  "n": 1,
  "stream": false,
  "extra_params":
  {
    "top_p": 0.9
  }
}

Berikut ini adalah format respons yang diharapkan:

{
  "id": "cmpl-8FwDGc22M13XMnRuessZ15dG622BH",
  "object": "text_completion",
  "created": 1698809382,
  "model": "gpt-3.5-turbo-instruct",
  "choices": [
    {
      "text": "MLflow is an open-source platform for managing the end-to-end machine learning lifecycle. It provides tools for tracking experiments, managing and deploying models, and collaborating on projects. MLflow also supports various machine learning frameworks and languages, making it easier to work with different tools and environments. It is designed to help data scientists and machine learning engineers streamline their workflows and improve the reproducibility and scalability of their models.",
      "index": 0,
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 83,
    "total_tokens": 88
  }
}

Kueri model pemenuhan percakapan

Berikut ini adalah contoh-contoh untuk melakukan kueri model obrolan. Contoh ini berlaku untuk mengkueri model obrolan yang disediakan menggunakan salah satu kemampuan penyajian model: API Foundation Model atau Model Eksternal.

Untuk contoh inferensi batch, lihat Melakukan inferensi LLM batch menggunakan Fungsi AI.

Klien OpenAI

Berikut ini adalah permintaan obrolan untuk model Instruksi Meta Llama 3.3 70B yang disediakan oleh API Model Yayasan titik akhir bayar per token, databricks-meta-llama-3-3-70b-instruct di ruang kerja Anda.

Untuk menggunakan klien OpenAI, tentukan nama titik akhir model sebagai model input.


from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
openai_client = w.serving_endpoints.get_open_ai_client()

response = openai_client.chat.completions.create(
    model="databricks-meta-llama-3-3-70b-instruct",
    messages=[
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "What is a mixture of experts model?",
      }
    ],
    max_tokens=256
)

Untuk mengkueri model fondasi di luar ruang kerja, Anda harus menggunakan klien OpenAI secara langsung. Anda juga memerlukan instans ruang kerja Databricks untuk menghubungkan klien OpenAI ke Databricks. Contoh berikut mengasumsikan Anda memiliki token Databricks API dan openai diinstal pada komputasi Anda.


import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

response = client.chat.completions.create(
    model="databricks-meta-llama-3-3-70b-instruct",
    messages=[
      {
        "role": "system",
        "content": "You are a helpful assistant."
      },
      {
        "role": "user",
        "content": "What is a mixture of experts model?",
      }
    ],
    max_tokens=256
)

SQL

Penting

Contoh berikut menggunakan fungsi SQL bawaan, ai_query. Fungsi ini adalah Pratinjau Publik dan definisinya mungkin berubah.

Berikut ini adalah permintaan obrolan untuk meta-llama-3-3-70b-instruct, disediakan oleh titik akhir bayar per token API Model Fondasi, databricks-meta-llama-3-3-70b-instruct di dalam ruang kerja Anda.

Catatan

Fungsi ai_query() ini tidak mendukung titik akhir kueri yang melayani model DBRX atau DBRX Instruct.

SELECT ai_query(
    "databricks-meta-llama-3-3-70b-instruct",
    "Can you explain AI in ten words?"
  )

REST API

Penting

Contoh berikut menggunakan parameter REST API untuk mengkueri titik akhir penyajian yang melayani model fondasi. Parameter ini ada di Pratinjau Umum dan definisinya mungkin berubah. Lihat POST /serving-endpoints/{name}/invocations.

Berikut ini adalah permintaan obrolan untuk model Instruksi Meta Llama 3.3 70B yang disediakan oleh API Model Yayasan titik akhir bayar per token, databricks-meta-llama-3-3-70b-instruct di ruang kerja Anda.

curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d '{
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": " What is a mixture of experts model?"
    }
  ]
}' \
https://<workspace_host>.databricks.com/serving-endpoints/databricks-meta-llama-3-3-70b-instruct/invocations \

SDK MLflow untuk Penyebaran

Penting

Contoh berikut menggunakan predict() API dari MLflow Deployments SDK.

Berikut ini adalah permintaan obrolan untuk model Instruksi Meta Llama 3.3 70B yang disediakan oleh API Model Yayasan titik akhir bayar per token, databricks-meta-llama-3-3-70b-instruct di ruang kerja Anda.


import mlflow.deployments

# Only required when running this example outside of a Databricks Notebook
export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

chat_response = client.predict(
    endpoint="databricks-meta-llama-3-3-70b-instruct",
    inputs={
        "messages": [
            {
              "role": "user",
              "content": "Hello!"
            },
            {
              "role": "assistant",
              "content": "Hello! How can I assist you today?"
            },
            {
              "role": "user",
              "content": "What is a mixture of experts model??"
            }
        ],
        "temperature": 0.1,
        "max_tokens": 20
    }
)

Databricks Python SDK

Berikut ini adalah permintaan obrolan untuk model Instruksi Meta Llama 3.3 70B yang disediakan oleh API Model Yayasan titik akhir bayar per token, databricks-meta-llama-3-3-70b-instruct di ruang kerja Anda.

Kode ini harus dijalankan dalam buku catatan di ruang kerja Anda. Lihat Menggunakan Databricks SDK untuk Python dari buku catatan Azure Databricks.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="databricks-meta-llama-3-3-70b-instruct",
    messages=[
        ChatMessage(
            role=ChatMessageRole.SYSTEM, content="You are a helpful assistant."
        ),
        ChatMessage(
            role=ChatMessageRole.USER, content="What is a mixture of experts model?"
        ),
    ],
    max_tokens=128,
)
print(f"RESPONSE:\n{response.choices[0].message.content}")

LangChain

Untuk mengkueri titik akhir model fondasi menggunakan LangChain, Anda dapat menggunakan kelas ChatDatabricks ChatModel dan menentukan endpoint.

Contoh berikut menggunakan ChatDatabricks kelas ChatModel di LangChain untuk mengkueri titik akhir pay-per-token API Model Foundation, databricks-meta-llama-3-3-70b-instruct.

%pip install databricks-langchain

from langchain_core.messages import HumanMessage, SystemMessage
from databricks_langchain import ChatDatabricks

messages = [
    SystemMessage(content="You're a helpful assistant"),
    HumanMessage(content="What is a mixture of experts model?"),
]

llm = ChatDatabricks(endpoint_name="databricks-meta-llama-3-3-70b-instruct")
llm.invoke(messages)

Sebagai contoh, berikut ini adalah format permintaan yang diharapkan untuk model obrolan saat menggunakan REST API. Untuk model eksternal, Anda dapat menyertakan parameter tambahan yang valid untuk penyedia dan konfigurasi titik akhir tertentu. Lihat Parameter kueri tambahan.

{
  "messages": [
    {
      "role": "user",
      "content": "What is a mixture of experts model?"
    }
  ],
  "max_tokens": 100,
  "temperature": 0.1
}

Berikut ini adalah format respons yang diharapkan untuk permintaan yang dibuat menggunakan REST API:

{
  "model": "databricks-meta-llama-3-3-70b-instruct",
  "choices": [
    {
      "message": {},
      "index": 0,
      "finish_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 7,
    "completion_tokens": 74,
    "total_tokens": 81
  },
  "object": "chat.completion",
  "id": null,
  "created": 1698824353
}

Model penalaran

Mosaic AI Model Serving menyediakan API terpadu untuk berinteraksi dengan model penalaran. Penalaran memberikan model dasar kemampuan yang lebih baik untuk mengatasi tugas-tugas yang kompleks. Beberapa model juga memberikan transparansi dengan mengungkapkan proses pemikiran langkah demi langkah mereka sebelum memberikan jawaban akhir.

Ada dua jenis model: model hanya penalaran dan model hibrida. Model khusus penalaran seperti seri OpenAI o selalu menggunakan penalaran internal dalam respons mereka. Model hibrid, seperti databricks-claude-3-7-sonnet, mendukung balasan cepat dan instan dan penalaran yang lebih dalam saat diperlukan.

Untuk mengaktifkan penalaran dalam model hibrid, sertakan parameter pemikiran dan tetapkan budget_tokens nilai yang mengontrol berapa banyak token yang dapat digunakan model untuk pemikiran internal. Anggaran yang lebih tinggi dapat meningkatkan kualitas untuk tugas yang kompleks, meskipun penggunaan di atas 32K dapat bervariasi. budget_tokens harus kurang dari max_tokens.

Semua model penalaran diakses melalui endpoint penyelesaian percakapan.

from openai import OpenAI
import base64
import httpx

client = OpenAI(
  api_key=os.environ.get('YOUR_DATABRICKS_TOKEN'),
  base_url=os.environ.get('YOUR_DATABRICKS_BASE_URL')
  )

response = client.chat.completions.create(
    model="databricks-claude-3-7-sonnet",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    max_tokens=20480,
    extra_body={
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10240
        }
    }
)

msg = response.choices[0].message
reasoning = msg.content[0]["summary"][0]["text"]
answer = msg.content[1]["text"]

print("Reasoning:", reasoning)
print("Answer:", answer)

Respons API mencakup blok konten pemikiran dan teks:

ChatCompletionMessage(
    role="assistant",
    content=[
        {
            "type": "reasoning",
            "summary": [
                {
                    "type": "summary_text",
                    "text": ("The question is asking about the scientific explanation for why the sky appears blue... "),
                    "signature": ("EqoBCkgIARABGAIiQAhCWRmlaLuPiHaF357JzGmloqLqkeBm3cHG9NFTxKMyC/9bBdBInUsE3IZk6RxWge...")
                }
            ]
        },
        {
            "type": "text",
            "text": (
                "# Why the Sky Is Blue\n\n"
                "The sky appears blue because of a phenomenon called Rayleigh scattering. Here's how it works..."
            )
        }
    ],
    refusal=None,
    annotations=None,
    audio=None,
    function_call=None,
    tool_calls=None
)

Mengelola penalaran di beberapa percakapan

Bagian ini khusus untuk databricks-claude-3-7-sonnet model.

Dalam percakapan multi-giliran, hanya blok penalaran yang terkait dengan sesi giliran asisten terakhir atau penggunaan alat yang terlihat oleh model dan dihitung sebagai token input.

Jika Anda tidak ingin meneruskan token penalaran kembali ke model (misalnya, Anda tidak memerlukannya untuk alasan atas langkah-langkah sebelumnya), Anda dapat menghilangkan blok penalaran sepenuhnya. Contohnya:

response = client.chat.completions.create(
    model="databricks-claude-3-7-sonnet",
    messages=[
        {"role": "user", "content": "Why is the sky blue?"},
        {"role": "assistant", "content": text_content},
        {"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"}
    ],
    max_tokens=20480,
    extra_body={
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10240
        }
    }
)

answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)

Namun, jika Anda memerlukan model untuk beralasan atas proses penalaran sebelumnya - misalnya, jika Anda membangun pengalaman yang memunculkan penalaran menengahnya - Anda harus menyertakan pesan asisten lengkap yang tidak dimodifikasi, termasuk blok penalaran dari giliran sebelumnya. Berikut cara melanjutkan utas dengan pesan lengkap dari asisten:

assistant_message = response.choices[0].message

response = client.chat.completions.create(
    model="databricks-claude-3-7-sonnet",
    messages=[
        {"role": "user", "content": "Why is the sky blue?"},
        {"role": "assistant", "content": text_content},
        {"role": "user", "content": "Can you explain in a way that a 5-year-old child can understand?"},
        assistant_message,
        {"role": "user", "content": "Can you simplify the previous answer?"}
    ],
    max_tokens=20480,
    extra_body={
        "thinking": {
            "type": "enabled",
            "budget_tokens": 10240
        }
    }
)

answer = response.choices[0].message.content[1]["text"]
print("Answer:", answer)

Bagaimana cara kerja model penalaran?

Model penalaran memperkenalkan token penalaran khusus selain token input dan output standar. Token ini memungkinkan model "berpikir" melalui perintah, memecahnya dan mempertimbangkan berbagai cara untuk merespons. Setelah proses penalaran internal ini, model menghasilkan jawaban akhirnya sebagai token output yang terlihat. Beberapa model, seperti databricks-claude-3-7-sonnet, menampilkan token penalaran ini kepada pengguna, sementara yang lain, seperti seri OpenAI o, membuangnya dan tidak mengeksposnya dalam output akhir.

Model yang didukung

Model API Foundation (dihosting oleh Databricks)

  • databricks-claude-3-7-sonnet

Model eksternal

  • Model OpenAI dengan kemampuan penalaran
  • Model Claude Antropis dengan kemampuan penalaran
  • Model Google Gemini dengan kemampuan penalaran

Model visi

Mosaic AI Model Serving menyediakan API terpadu untuk memahami dan menganalisis gambar menggunakan berbagai model fondasi, membuka kemampuan multimodal yang kuat. Fungsionalitas ini tersedia melalui model yang dihosting Databricks tertentu sebagai bagian dari API Model Foundation dan melayani titik akhir yang melayani model eksternal.

Contoh kode


from openai import OpenAI
import base64
import httpx

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

# encode image
image_url = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
image_data = base64.standard_b64encode(httpx.get(image_url).content).decode("utf-8")

# OpenAI request
completion = client.chat.completions.create(
    model="databricks-claude-3-7-sonnet",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "what's in this image?"},
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/jpeg;base64,{image_data}"},
                },
            ],
        }
    ],
)

print(completion.choices[0].message.content)

API Penyelesaian Obrolan mendukung beberapa input gambar, memungkinkan model menganalisis setiap gambar dan mensintesis informasi dari semua input untuk menghasilkan respons terhadap perintah.


from openai import OpenAI
import base64
import httpx

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

# Encode multiple images

image1_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
image1_data = base64.standard_b64encode(httpx.get(image1_url).content).decode("utf-8")

image2_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg"
image2_data = base64.standard_b64encode(httpx.get(image1_url).content).decode("utf-8")

# OpenAI request

completion = client.chat.completions.create(
model="databricks-claude-3-7-sonnet",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "What are in these images? Is there any difference between them?"},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image1_data}"},
},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{image2_data}"},
},
],
}
],
)

print(completion.choices[0].message.content)

Model yang didukung

Model API Foundation (dihosting oleh Databricks)

  • databricks-claude-3-7-sonnet

Model Eksternal

  • Model OpenAI GPT dan seri O dengan kemampuan penglihatan
  • Model Claude antropis dengan kemampuan penglihatan
  • Model Google Gemini dengan kemampuan penglihatan
  • Model fondasi eksternal lainnya dengan kemampuan visi yang kompatibel dengan OpenAI API juga didukung.

Persyaratan gambar input

Bagian ini hanya berlaku untuk API Model Foundation. Untuk model eksternal, lihat dokumentasi penyedia.

Beberapa gambar per permintaan

  • Hingga 20 gambar untuk Claude.ai
  • Hingga 100 gambar untuk permintaan API
  • Semua gambar yang disediakan diproses dalam satu permintaan, yang berguna untuk membandingkan atau menentukan perbedaan di antara mereka.

Batasan ukuran

  • Gambar yang lebih besar dari 8000x8000 px akan ditolak.
  • Jika lebih dari 20 gambar dikirimkan dalam satu permintaan API, ukuran maksimum yang diizinkan per gambar adalah 2000 x 2000 px.

Rekomendasi mengubah ukuran gambar

  • Untuk performa optimal, mengubah ukuran gambar sebelum mengunggah jika terlalu besar.
  • Jika tepi panjang gambar melebihi 1568 piksel atau ukurannya melebihi ~ 1.600 token, itu akan secara otomatis diturunkan skalanya sambil mempertahankan rasio aspek.
  • Gambar yang sangat kecil (di bawah 200 piksel di tepi mana pun) dapat menurunkan performa.
  • Untuk mengurangi latensi, simpan gambar dalam 1,15 megapiksel dan paling banyak 1568 piksel di kedua dimensi.

Pertimbangan kualitas gambar

  • Format yang didukung: JPEG, PNG, GIF, WebP.
  • Kejelasan: Hindari gambar kabur atau piksel.
  • Teks dalam gambar:
    • Pastikan teks terbaca dan tidak terlalu kecil.
    • Hindari memotong konteks visual utama hanya untuk memperbesar teks.

Menghitung biaya

Bagian ini hanya berlaku untuk API Model Foundation. Untuk model eksternal, lihat dokumentasi penyedia.

Setiap gambar dalam permintaan ke model fondasi ditambahkan ke penggunaan token Anda.

Jumlah dan perkiraan token

Jika tidak diperlukan perubahan ukuran, perkirakan token dengan:
token = (lebar px × tinggi px) / 750

Perkiraan jumlah token untuk ukuran gambar yang berbeda:

Ukuran Gambar Beberapa Token
200×200 px (0,04 MP) ~54
1000×1000 px (1 MP) ~1334
1092×1092 px (1,19 MP) ~1590

Batasan pemahaman gambar

Bagian ini hanya berlaku untuk API Model Foundation. Untuk model eksternal, lihat dokumentasi penyedia.

Ada batasan untuk pemahaman gambar tingkat lanjut tentang model Claude di Databricks:

  • Identifikasi orang: Tidak dapat mengidentifikasi atau memberi nama orang dalam gambar.
  • Akurasi: Dapat salah menafsirkan gambar berkualitas rendah, diputar, atau sangat kecil (<200 px).
  • Penalaran spasial: Mengalami kesulitan dengan penempatan atau penyusunan yang tepat, seperti membaca jam analog atau posisi catur.
  • Penghitungan: Memberikan perkiraan jumlah, tetapi mungkin tidak akurat untuk banyak objek kecil.
  • Gambar yang dihasilkan AI: Tidak dapat mendeteksi gambar sintetis atau palsu dengan andal.
  • Konten yang tidak pantas: Memblokir gambar eksplisit atau melanggar kebijakan.
  • Layanan kesehatan: Tidak cocok untuk pemindaian medis yang kompleks (misalnya, CTs dan MRI). Ini bukan alat diagnostik.

Tinjau semua output dengan hati-hati, terutama untuk kasus penggunaan dengan taruhan tinggi. Hindari menggunakan Claude untuk tugas yang membutuhkan analisis presisi atau sensitif yang sempurna tanpa pengawasan manusia.

Menyematkan kueri model

Berikut adalah permintaan embedding untuk model gte-large-en yang disediakan oleh API Model Foundation. Contoh ini berlaku untuk melakukan kueri pada model penyematan yang disediakan menggunakan salah satu kemampuan Layanan Model: API Model Dasar atau model eksternal.

Klien OpenAI

Untuk menggunakan klien OpenAI, tentukan nama titik akhir model sebagai model input.


from databricks.sdk import WorkspaceClient

w = WorkspaceClient()
openai_client = w.serving_endpoints.get_open_ai_client()

response = openai_client.embeddings.create(
  model="databricks-gte-large-en",
  input="what is databricks"
)

Untuk mengkueri model fondasi di luar ruang kerja, Anda harus menggunakan klien OpenAI secara langsung, seperti yang ditunjukkan di bawah ini. Contoh berikut mengasumsikan Anda memiliki token Databricks API dan openai diinstal pada komputasi Anda. Anda juga memerlukan instans ruang kerja Databricks untuk menghubungkan klien OpenAI ke Databricks.


import os
import openai
from openai import OpenAI

client = OpenAI(
    api_key="dapi-your-databricks-token",
    base_url="https://example.staging.cloud.databricks.com/serving-endpoints"
)

response = client.embeddings.create(
  model="databricks-gte-large-en",
  input="what is databricks"
)

SQL

Penting

Contoh berikut menggunakan fungsi SQL bawaan, ai_query. Fungsi ini adalah Pratinjau Publik dan definisinya mungkin berubah.


SELECT ai_query(
    "databricks-gte-large-en",
    "Can you explain AI in ten words?"
  )

REST API

Penting

Contoh berikut menggunakan parameter REST API untuk mengkueri titik akhir penyajian yang melayani model fondasi atau model eksternal. Parameter ini ada di Pratinjau Umum dan definisinya mungkin berubah. Lihat POST /serving-endpoints/{name}/invocations.


curl \
-u token:$DATABRICKS_TOKEN \
-X POST \
-H "Content-Type: application/json" \
-d  '{ "input": "Embed this sentence!"}' \
https://<workspace_host>.databricks.com/serving-endpoints/databricks-gte-large-en/invocations

SDK MLflow untuk Penyebaran

Penting

Contoh berikut menggunakan predict() API dari MLflow Deployments SDK.


import mlflow.deployments

export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

embeddings_response = client.predict(
    endpoint="databricks-gte-large-en",
    inputs={
        "input": "Here is some text to embed"
    }
)

Databricks Python SDK


from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole

w = WorkspaceClient()
response = w.serving_endpoints.query(
    name="databricks-gte-large-en",
    input="Embed this sentence!"
)
print(response.data[0].embedding)

LangChain

Untuk menggunakan model API Model Databricks Foundation di LangChain sebagai model penyematan, impor DatabricksEmbeddings kelas dan tentukan endpoint parameter sebagai berikut:

%pip install databricks-langchain

from databricks_langchain import DatabricksEmbeddings

embeddings = DatabricksEmbeddings(endpoint="databricks-gte-large-en")
embeddings.embed_query("Can you explain AI in ten words?")

Berikut ini adalah format permintaan yang diinginkan untuk model penyematan. Untuk model eksternal, Anda dapat menyertakan parameter tambahan yang valid untuk penyedia dan konfigurasi titik akhir tertentu. Lihat Parameter kueri tambahan.


{
  "input": [
    "embedding text"
  ]
}

Berikut ini adalah format respons yang diharapkan:

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": []
    }
  ],
  "model": "text-embedding-ada-002-v2",
  "usage": {
    "prompt_tokens": 2,
    "total_tokens": 2
  }
}

Periksa apakah embeddings dinormalisasi

Gunakan yang berikut ini untuk memeriksa apakah embedding yang dihasilkan oleh model Anda sudah dinormalisasi.


  import numpy as np

  def is_normalized(vector: list[float], tol=1e-3) -> bool:
      magnitude = np.linalg.norm(vector)
      return abs(magnitude - 1) < tol

Pemanggilan fungsi

Pemanggilan Fungsi Databricks kompatibel dengan OpenAI dan hanya tersedia selama penyajian model sebagai bagian dari API Model Foundation dan titik akhir penyajian yang melayani model eksternal. Untuk detailnya, lihat Panggilan fungsi di Azure Databricks.

Output terstruktur

Output terstruktur kompatibel dengan OpenAI dan hanya tersedia selama model berfungsi sebagai bagian dari API Model Foundation. Untuk detailnya, lihat Output terstruktur di Azure Databricks.

Mengobrol dengan LLM yang didukung menggunakan AI Playground

Anda dapat berinteraksi dengan model bahasa besar yang didukung menggunakan AI Playground. AI Playground adalah lingkungan seperti obrolan tempat Anda dapat menguji, meminta, dan membandingkan LLM dari ruang kerja Azure Databricks Anda.

Taman bermain AI

Sumber Daya Tambahan: