Cách sử dụng GPT-4o Audio Preview với LangChain và ChatOpenAI

Môi trường ảo và phụ thuộc

Trước khi sử dụng mô hình gpt-4o-audio-preview của OpenAI, hãy thiết lập một môi trường ảo cho dự án của bạn. Việc này giúp mọi thứ gọn gàng và tránh xung đột phụ thuộc, đặc biệt hữu ích khi bạn làm việc với nhiều dự án.

Môi trường ảo là gì?

Hãy hình dung bạn có hai dự án khác nhau. Một dự án cần phiên bản 1.0 của một gói, trong khi dự án kia cần phiên bản 2.0. Nếu bạn cài mọi thứ toàn cục, bạn sẽ gặp xung đột.

Môi trường ảo tạo ra một không gian làm việc tách biệt, giống như một “bong bóng”, nơi bạn có thể cài đặt bất cứ thứ gì cần cho một dự án cụ thể. Khi tạo môi trường cho dự án, bạn không còn phải lo làm hỏng thiết lập Python của hệ thống hay xung đột gói nữa.

Tạo và kích hoạt môi trường ảo

Bắt đầu bằng cách tạo một môi trường ảo cho dự án. Chúng ta sẽ dùng mô-đun venv tích hợp sẵn của Python. Chúng ta sẽ cần:

1. Di chuyển đến thư mục dự án của bạn—đây là nơi bạn muốn môi trường “sống”. Nếu chưa có thư mục dự án, hãy tạo một thư mục.
2. Khi đã ở trong thư mục, hãy tạo môi trường ảo. Trên macOS hoặc Linux, chạy python3 -m venv env. Trên Windows, chạy python -m venv env.
1. Lưu ý venv là công cụ của Python để tạo môi trường ảo, và env là tên thư mục môi trường. Bạn có thể đặt bất kỳ tên nào bạn thích: env, venv, my_project_env, v.v. Thực hành tốt là giữ tên ngắn gọn, đơn giản
3. Bây giờ bạn đã tạo môi trường ảo, hãy kích hoạt nó. Bước này rất quan trọng vì đảm bảo mọi gói bạn cài đặt chỉ ảnh hưởng đến dự án cụ thể này.
1. Trên macOS hoặc Linux, kích hoạt bằng source env/bin/activate. Trên Windows, dùng: .\env\Scripts\activate

Bạn sẽ thấy prompt trên terminal đổi thành dạng như env—điều này cho biết bạn đang làm việc trong môi trường ảo. Từ giờ, mọi gói bạn cài và lệnh bạn chạy sẽ được cô lập trong dự án này.

Cài đặt langchain-openai

Khi môi trường đã được kích hoạt, hãy cài các công cụ cần thiết. Vì chúng ta làm việc với OpenAI và LangChain, hãy bắt đầu bằng cách cài gói langchain-openai. Gói này cho phép chúng ta tương tác với các mô hình của OpenAI.

Chạy lệnh này trong terminal: pip install langchain-openai.

Thiết lập biến môi trường

Bước tiếp theo là đảm bảo thông tin nhạy cảm như API key không bị viết cứng trong script. Chúng ta sẽ làm điều này bằng cách đặt biến môi trường.

Trước hết, bạn cần quyền truy cập các mô hình của OpenAI. Nếu chưa có, hãy vào nền tảng OpenAI và tạo tài khoản. Sau khi đăng ký, bạn cần tạo một API key. API key này là “tấm vé” để truy cập các mô hình của OpenAI, bao gồm gpt-4o-audio-preview.

Trong trường hợp này, chúng ta cần đặt OPENAI_API_KEY. Bạn có thể đặt thủ công mỗi lần làm việc với dự án, hoặc dùng tệp .env để lưu trữ cho tiện. Hãy xem cả hai cách.

Cách 1: Đặt biến môi trường thủ công

Nếu bạn chỉ làm tạm thời và muốn thiết lập nhanh, có thể đặt biến môi trường trực tiếp trong terminal.

• Trên macOS/Linux, chạy: export OPENAI_API_KEY='your-api-key-here'
• Trên Windows, dùng: set OPENAI_API_KEY='your-api-key-here'

Giờ API key của bạn đã sẵn sàng trong script, và bạn có thể truy cập nó bằng mô-đun os trong Python.

Cách 2: Dùng tệp .env

Nếu bạn muốn giải pháp lâu dài hơn, có thể dùng tệp .env để lưu biến môi trường. Tệp này sẽ nằm trong thư mục dự án và giữ khóa của bạn an toàn.

Đầu tiên, tạo tệp .env trong thư mục dự án, và bên trong thêm API key như sau:

OPENAI_API_KEY=your-api-key-hereĐược hỗ trợ bởi

Tiếp theo, cài gói python-dotenv:

pip install python-dotenvĐược hỗ trợ bởi

Bây giờ, trong script Python, nạp biến môi trường từ tệp .env như sau:

from dotenv import load_dotenv
import os
load_dotenv()  # Load variables from .env file
api_key = os.getenv('OPENAI_API_KEY')Được hỗ trợ bởi

Cách này đặc biệt hữu ích nếu bạn có nhiều biến môi trường cần quản lý, và nó giúp mã của bạn sạch và an toàn.

Tùy chọn: LangSmith để truy vết

Nếu bạn muốn theo dõi và giám sát các cuộc gọi API để gỡ lỗi hoặc tối ưu hiệu năng, OpenAI có một tính năng thú vị tên là LangSmith. Nó cung cấp nhật ký chi tiết cho từng cuộc gọi API do mô hình của bạn thực hiện, rất hữu ích khi bạn muốn tối ưu hoặc khắc phục sự cố quy trình.

Bạn có thể bật truy vết LangSmith như sau:

os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"Được hỗ trợ bởi

Một lần nữa, đây hoàn toàn là tùy chọn, nhưng là công cụ hữu ích nếu bạn làm ứng dụng phức tạp và muốn giám sát cách mô hình hoạt động.

Khởi tạo mô hình gpt-4o-audio-preview của OpenAI

Giờ môi trường đã sẵn sàng, đến phần thú vị—khởi tạo mô hình gpt-4o-audio-preview của OpenAI. Đây là lúc chúng ta bắt đầu tương tác với mô hình, gửi yêu cầu, xử lý đầu vào và đầu ra.

Trong phần này, chúng ta sẽ đi qua cách khởi tạo mô hình bằng khuôn khổ LangChain, tùy chỉnh một số tham số cơ bản và thiết lập mọi thứ cần để bắt đầu tạo phản hồi.

Khởi tạo mô hình nghĩa là gì?

Trước khi vào mã, hãy dành chút thời gian để hiểu “khởi tạo” mô hình nghĩa là gì. Khi nói khởi tạo mô hình, về bản chất là tạo một đối tượng trong Python cho phép chúng ta tương tác với mô hình gpt-4o-audio-preview. Đối tượng này giống như bảng điều khiển—nó giữ tất cả thiết lập, cấu hình và phương thức cần để gửi dữ liệu tới mô hình và nhận kết quả trả về.

Thiết lập mô hình cơ bản với LangChain

Bắt đầu bằng cách tạo đối tượng mô hình này. Vì làm việc trong khuôn khổ LangChain, chúng ta sẽ dùng lớp ChatOpenAI từ gói langchain_openai. Lớp này giúp truy cập dễ dàng các mô hình OpenAI và chức năng của chúng.

from langchain_openai import ChatOpenAI

# Create the model object
llm = ChatOpenAI(
    model="gpt-4o-audio-preview",  # Specifying the model
    temperature=0,  # Controls randomness in the output
    max_tokens=None,  # Unlimited tokens in output (or specify a max if needed)
    timeout=None,  # Optional: Set a timeout for requests
    max_retries=2  # Number of retries for failed requests
)Được hỗ trợ bởi

Một điểm tuyệt vời của mô hình này là mức độ tùy biến cao. Bạn có thể tinh chỉnh tham số tùy theo nhu cầu. Ví dụ, nếu bạn xây dựng ứng dụng cần chuyển âm thanh thành văn bản, bạn có thể điều chỉnh tham số để xử lý đầu vào lớn hơn hoặc giới hạn độ dài đầu ra.

Chẳng hạn, nếu bạn xử lý yêu cầu nhạy thời gian và muốn đảm bảo mô hình không mất quá lâu, bạn có thể đặt timeout:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    timeout=30  # Set timeout to 30 seconds
)Được hỗ trợ bởi

Gpt-4o-audio-preview với đầu vào và đầu ra âm thanh

Khi mô hình gpt-4o-audio-preview đã chạy, hãy đi vào khả năng xử lý đầu vào và đầu ra âm thanh.

Tải lên và mã hóa tệp âm thanh

Trước khi bắt đầu làm việc với âm thanh, bước đầu là nạp và mã hóa tệp âm thanh sang định dạng mà mô hình có thể hiểu. OpenAI yêu cầu dữ liệu âm thanh được gửi dưới dạng mã hóa base64, vì vậy chúng ta sẽ bắt đầu bằng việc tải tệp và mã hóa nó.

Giả sử bạn có một tệp .wav muốn mô hình xử lý — tôi đặt tên là gpt.wav. Bạn có thể thay bằng tệp của bạn với mã sau. Đây là cách nạp và chuẩn bị tệp đó:

import base64

# Open the audio file and convert to base64
with open("gpt.wav", "rb") as f:
   audio_data = f.read()

# Convert binary audio data to base64
audio_b64 = base64.b64encode(audio_data).decode()Được hỗ trợ bởi

Điều gì đang diễn ra ở đây? Chúng ta đọc tệp âm thanh dưới dạng dữ liệu nhị phân (chế độ "rb"), sau đó dùng thư viện base64 để mã hóa thành chuỗi base64. Đây là định dạng OpenAI yêu cầu để xử lý đầu vào âm thanh.

Gửi âm thanh đến mô hình để chuyển lời nói thành văn bản

Khi đã mã hóa âm thanh, hãy truyền nó vào mô hình. Mô hình gpt-4o-audio-preview có thể chuyển giọng nói trong tệp âm thanh thành văn bản—vì vậy nếu bạn từng cần biến podcast, ghi chú thoại hoặc ghi âm cuộc họp thành văn bản, đây chính là điều bạn mong đợi! Hãy xem cách hoạt động.

# Define the input message with audio
messages = [
    (
        "human",
        [
            {"type": "text", "text": "Transcribe the following:"},
            {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
        ],
    )
]

# Send the request to the model and get the transcription
output_message = llm.invoke(messages)
print(output_message.content)Được hỗ trợ bởi

Trong ví dụ này, chúng ta gửi hai phần dữ liệu cho mô hình:

• Một tin nhắn văn bản hướng dẫn: "Transcribe the following."
• Dữ liệu âm thanh mã hóa base64 với định dạng được chỉ định là .wav.

Mô hình xử lý đầu vào này và trả về văn bản chuyển âm. Ví dụ, nếu tệp âm thanh chứa một câu nói như "I’m learning how to use AI", mô hình sẽ trả về văn bản như: "I'm learning how to use AI."

Tạo đầu ra âm thanh với gpt-4o-audio-preview

Nhưng mô hình gpt-4o-audio-preview không chỉ hiểu âm thanh—nó còn có thể tạo âm thanh. Đây là cách cấu hình mô hình để tạo đầu ra âm thanh:

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    temperature=0,
    model_kwargs={
        "modalities": ["text", "audio"],  # We’re telling the model to handle both text and audio
        "audio": {"voice": "alloy", "format": "wav"},  # Configure voice and output format
    }
)

# Send a request and ask the model to respond with audio
messages = [("human", "Are you human? Reply either yes or no.")]
output_message = llm.invoke(messages)

# Access the generated audio data
audio_response = output_message.additional_kwargs['audio']['data']Được hỗ trợ bởi

Giải thích nhanh:

• modalities=["text", "audio"]: Chúng ta yêu cầu mô hình xử lý cả văn bản và âm thanh. Điều này cho phép nó tạo phản hồi bằng giọng nói.
• audio={"voice": "alloy", "format": "wav"}: Ở đây, chúng ta chỉ định giọng đọc (trong ví dụ này là "alloy") và định dạng đầu ra mong muốn (.wav). OpenAI cung cấp nhiều giọng, vì thế bạn có thể tùy biến trải nghiệm theo nhu cầu ứng dụng.

Âm thanh phản hồi mã hóa base64 được lưu trong output_message.additional_kwargs['audio']['data'], bạn có thể dễ dàng giải mã và lưu tệp để phát lại.

Lưu và phát lại tệp âm thanh

Giờ khi bạn đã tạo âm thanh, hẳn bạn muốn lưu và phát lại tệp, đúng không? Đây là cách lấy dữ liệu âm thanh mã hóa base64, giải mã và lưu thành tệp .wav:

# Decode the base64 audio data
audio_bytes = base64.b64decode(output_message.additional_kwargs['audio']['data'])

# Save the audio file
with open("output.wav", "wb") as f:
    f.write(audio_bytes)
print("Audio saved as output.wav")Được hỗ trợ bởi

.wav này giờ có thể phát trên máy của bạn bằng bất kỳ trình phát media nào. Vậy là khi bạn gọi mô hình, nó không chỉ tạo phản hồi văn bản mà còn tạo một tệp âm thanh nói nội dung phản hồi.

Các trường hợp sử dụng nâng cao của gpt-4o-audio-preview

Trong phần này, tôi sẽ đề cập cách gắn công cụ vào mô hình gpt-4o-audio-preview, xử lý quy trình phức tạp hơn và thậm chí chuỗi nhiều bước lại với nhau để tạo giải pháp tự động hoàn chỉnh. Nếu bạn từng muốn xây dựng một trợ lý giọng nói không chỉ chuyển âm thanh thành văn bản mà còn lấy thông tin từ nguồn bên ngoài, phần này sẽ hữu ích.

Gọi công cụ (tool calling)

Bắt đầu với gọi công cụ. Đây là việc “dạy” mô hình AI của bạn cách dùng các công cụ hoặc hàm bên ngoài để nâng cao năng lực. Thay vì chỉ xử lý văn bản hoặc âm thanh, mô hình có thể thực hiện tác vụ bổ sung như lấy dữ liệu từ API, tính toán, hoặc tra cứu thời tiết.

Mô hình gpt-4o-audio-preview của OpenAI có thể kết hợp với các công cụ và hàm khác bằng phương thức bind_tools của LangChain. Với phương thức này, bạn có thể tạo quy trình mượt mà, trong đó mô hình quyết định khi nào và cách dùng các công cụ bạn cung cấp.

Tôi sẽ hướng dẫn bạn ví dụ thực tế về việc gắn một công cụ vào mô hình. Trong trường hợp này, chúng ta sẽ gắn công cụ lấy thời tiết.

Đầu tiên, chúng ta định nghĩa một mô hình Pydantic đại diện cho công cụ muốn dùng. Sau đó, gắn công cụ đó vào mô hình gpt-4o-audio-preview để có thể được gọi khi cần. Cho việc này, bạn sẽ cần một API key từ OpenWeatherMap.

import requests
from pydantic import BaseModel, Field

# Define a tool schema using Pydantic
class GetWeather(BaseModel):
   """Get the current weather in a given location."""
   location: str = Field(..., description="The city and state, e.g. Edinburgh, UK")
   def fetch_weather(self):
       # Using OpenWeatherMap API to fetch real-time weather
       API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
       base_url = f"http://api.openweathermap.org/data/2.5/weather?q={self.location}&APPID={API_KEY}&units=metric"      
       response = requests.get(base_url)      
       if response.status_code == 200:
           data = response.json()
           weather_description = data['weather'][0]['description']
           temperature = data['main']['temp']
           return f"The weather in {self.location} is {weather_description} with a temperature of {temperature}°C."
       else:
           # Print the status code and response for debugging
           print(f"Error: {response.status_code}, {response.text}")
           return f"Could not fetch the weather for {self.location}."

# Example usage
weather_tool = GetWeather(location="Edinburgh, GB")  # Using city name and country code
ai_msg = weather_tool.fetch_weather()
print(ai_msg)Được hỗ trợ bởi

Xem điều gì đang diễn ra:

• Định nghĩa công cụ: Chúng ta định nghĩa công cụ GetWeather, nhận đầu vào là vị trí và trả về thời tiết hiện tại cho vị trí đó bằng API OpenWeatherMap.
• Lấy thời tiết ở Edinburgh: Lần này, chúng ta lấy thời tiết cho Edinburgh, Vương quốc Anh.
• Dữ liệu thời tiết theo thời gian thực: Công cụ truy xuất dữ liệu thời tiết thời gian thực qua API bên ngoài và trả về.

Trong ví dụ này, tôi muốn biết thời tiết ở Edinburgh. Khi chạy, tôi nhận được kết quả: The weather in Edinburgh, GB is broken clouds with a temperature of 13.48°C.

Chuỗi tác vụ: Xây dựng quy trình nhiều bước

Bằng cách chuỗi các tác vụ, bạn có thể tạo quy trình nhiều bước kết hợp nhiều công cụ và lần gọi mô hình để xử lý yêu cầu phức tạp. Hãy tưởng tượng tình huống bạn muốn trợ lý chuyển âm thanh thành văn bản rồi thực hiện hành động dựa trên địa điểm được nhắc trong âm thanh. Trong ví dụ này, chúng ta sẽ chuỗi tác vụ chuyển âm thanh thành văn bản với tra cứu thời tiết dựa trên địa điểm đã chuyển.

import base64
import requests
from pydantic import BaseModel, Field
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# Define the tool schema for fetching weather
class GetWeather(BaseModel):
   """Get the current weather in a given location."""
   location: str = Field(..., description="The city and state, e.g. Edinburgh, UK")
   def fetch_weather(self):
       # Using OpenWeatherMap API to fetch real-time weather
       API_KEY = "YOUR_API_KEY_HERE"  # Replace with your actual API key
       base_url = f"http://api.openweathermap.org/data/2.5/weather?q={self.location}&appid={API_KEY}&units=metric"       
       response = requests.get(base_url)
       if response.status_code == 200:
           data = response.json()
           weather_description = data['weather'][0]['description']
           temperature = data['main']['temp']
           return f"The weather in {self.location} is {weather_description} with a temperature of {temperature}°C."
       else:
           return f"Could not fetch the weather for {self.location}."

# Instantiate the LLM model
llm = ChatOpenAI(
   model="gpt-4o-audio-preview"
)
# Function to handle audio transcription using the LLM
def audio_to_text(audio_b64: str) -> str:
   # Define the message to send for transcription
   messages = [
       (
           "human",
           [
               {"type": "text", "text": "Transcribe the following:"},
               {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
           ],
       )
   ]
   # Invoke the model and get the transcription
   output_message = llm.invoke(messages)
   # Return the transcription from the model's output
   return output_message.content

# Create a prompt template for transcription and weather lookup
prompt = ChatPromptTemplate.from_messages(
   [
       ("system", "You are an assistant that transcribes audio and fetches weather information."),
       ("human", "Transcribe the following and tell me the weather in the location mentioned in the audio."),
   ]
)

# Bind the tool to the model
llm_with_tools = llm.bind_tools([GetWeather])

# Chain the transcription and weather tool
chain = prompt | llm_with_tools

# Read and encode the audio file in base64
audio_file = "weather_input.wav" #Replace with your audio file
with open(audio_file, "rb") as audio_file:
   audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Transcribe the audio to get the location
transcribed_location = audio_to_text(audio_b64)

# Print the transcription result for debugging
print(f"Transcribed location: {transcribed_location}")

# Check if transcription returned a valid result
if transcribed_location:
   # Fetch weather for the transcribed location
   weather_tool = GetWeather(location=transcribed_location)
   weather_result = weather_tool.fetch_weather()
   print(f"Weather result: {weather_result}")
else:
   print("No valid location was transcribed from the audio.")Được hỗ trợ bởi

Phân tích mã:

• Chuyển âm thanh thành văn bản: Người dùng cung cấp đầu vào âm thanh (mã hóa base64). Âm thanh này được gửi tới mô hình để chuyển nội dung. Ví dụ, kết quả có thể là "Edinburgh”.
• Tra cứu thời tiết: Sau khi chuyển âm thanh và xác định địa điểm, mô hình gọi công cụ GetWeather để lấy thời tiết cho địa điểm đó.
• Quy trình tự động hoàn chỉnh: Thiết lập này tạo một quy trình nhiều bước tự động, trong đó mô hình trước hết hiểu nội dung trong âm thanh (chuyển âm) rồi hành động dựa trên thông tin đó bằng cách truy xuất dữ liệu thời tiết liên quan.

Với ví dụ này, tôi đưa cho mô hình một tệp âm thanh trong đó tôi nói: “Edinburgh”. Đây là đầu ra tôi nhận được:Transcribed location: Edinburgh

Weather result: The weather in Edinburgh is broken clouds with a temperature of 13.47°C.

Fine-tuning gpt-4o-audio-preview

Trong một số trường hợp, bạn có thể muốn fine-tune mô hình để xử lý các tác vụ cụ thể hiệu quả hơn. Ví dụ, nếu bạn xây dựng ứng dụng chuyển âm thanh y khoa, bạn có thể muốn mô hình hiểu sâu các thuật ngữ và biệt ngữ y khoa. OpenAI cho phép bạn fine-tune mô hình bằng cách huấn luyện trên bộ dữ liệu tùy chỉnh.

Hãy xem cách thực hiện:

import base64
from langchain_openai import ChatOpenAI

# Step 1: Instantiate the fine-tuned audio-capable model
fine_tuned_model = ChatOpenAI(
    temperature=0,
    model="ft:gpt-4o-audio-preview:your-organization::model-id"
)

# Step 2: Capture and encode the input audio file (medical report)
audio_file = "medical_report.wav"
with open(audio_file, "rb") as audio_file:
    audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Step 3: Create the message structure for transcription request
messages = [
    (
        "human",
        [
            {"type": "text", "text": "Please transcribe this medical report audio."},
            {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
        ],
    )
]

# Step 4: Invoke the fine-tuned model to transcribe the audio
result = fine_tuned_model.invoke(messages)

# Step 5: Extract and print the transcribed text from the response
transcription = result.content  # This contains the transcription
print(f"Transcription: {transcription}")

# Debugging: Print the full structure of the additional_kwargs for inspection
print(result.additional_kwargs)Được hỗ trợ bởi

Đoạn trên sử dụng một mô hình đã fine-tune được huấn luyện riêng để xử lý âm thanh y khoa, nhưng bạn cũng có thể fine-tune mô hình cho các trường hợp khác như chuyển âm pháp lý, ghi âm chăm sóc khách hàng, hoặc chỉnh sửa podcast. 

Ví dụ thực tế: Xây dựng trợ lý kích hoạt bằng giọng nói

Cuối cùng, hãy xem một ví dụ thực tế nơi chúng ta xây dựng một trợ lý hỗ trợ giọng nói: lắng nghe truy vấn của người dùng qua âm thanh, tạo phản hồi và trả lời lại bằng âm thanh. 

Phân rã quy trình

Quy trình chúng ta sẽ theo là:

1. Người dùng nói vào micro và âm thanh được ghi lại.
2. Mô hình chuyển âm thanh thành văn bản.
3. Bản chuyển âm được xử lý để tạo câu trả lời.
4. Sau đó, mô hình tạo phản hồi âm thanh để phát lại cho người dùng.

Triển khai

Hãy xem cách viết mã cho quy trình này:

import base64
from langchain_openai import ChatOpenAI

# Step 1: Instantiate the audio-capable model with configuration for generating audio
llm = ChatOpenAI(
   model="gpt-4o-audio-preview",
   temperature=0,
   model_kwargs={
       "modalities": ["text", "audio"],  # Enable both text and audio modalities
       "audio": {"voice": "alloy", "format": "wav"},  # Set the desired voice and output format
   }
)

# Step 2: Capture and encode the audio 
audio_file = "math_joke_audio.wav" #You can replace your audio file here
with open(audio_file, "rb") as audio_file:
   audio_b64 = base64.b64encode(audio_file.read()).decode('utf-8')

# Step 3: Create the message structure for transcription and audio response
messages = [
   (
       "human",
       [
           {"type": "text", "text": "Answer the question."},
           {"type": "input_audio", "input_audio": {"data": audio_b64, "format": "wav"}},
       ],
   )
]

# Step 4: Invoke the model to transcribe the audio and generate a response
result = llm.invoke(messages)

# Step 5: Extract the audio response
audio_response = result.additional_kwargs.get('audio', {}).get('data')  # Safely check if audio exists

# Step 6: Save the audio response to a file if it exists
if audio_response:
   # Decode the base64 audio data and save it as a .wav file
   audio_bytes = base64.b64decode(audio_response)
   with open("response.wav", "wb") as f:
       f.write(audio_bytes)
   print("Audio response saved as 'response.wav'")
else:
   print("No audio response available")Được hỗ trợ bởi

Cách hoạt động

Phân tích cách hoạt động:

• Đầu vào âm thanh: Người dùng cung cấp đầu vào âm thanh, chẳng hạn đặt câu hỏi (ví dụ, "Tell me a math joke"). Âm thanh được mã hóa base64 và truyền cho trợ lý.
• Chuyển âm: Mô hình chuyển âm thanh thành văn bản. Bản chuyển âm có sẵn nếu bạn muốn ghi log hoặc hiển thị.
• Tạo phản hồi: Dựa trên bản chuyển âm, mô hình tạo phản hồi bằng kiến thức nội tại (ví dụ, "The capital of France is Paris")
• Đầu ra âm thanh: Phản hồi được chuyển thành định dạng âm thanh. Âm thanh được lưu thành tệp (ví dụ, "response.wav") và có thể phát lại bằng bất kỳ trình phát âm thanh nào.

Trợ lý này được tạo để trò chuyện bằng âm thanh. Nó lắng nghe giọng nói của người dùng, hiểu câu hỏi, rồi trả lời bằng chính “giọng” của nó. Thiết lập này rất phù hợp để xây dựng trợ lý giọng nói đơn giản, và bạn có thể nâng cấp phức tạp hơn khi cần!

Kết luận

Trong hướng dẫn này, chúng ta đã khám phá mô hình gpt-4o-audio-preview của OpenAI, bao gồm thiết lập, đầu vào/đầu ra âm thanh, các trường hợp nâng cao, và thậm chí xây dựng trợ lý giọng nói cơ bản. Mô hình mạnh mẽ này cung cấp nền tảng vững chắc để tạo ra các ứng dụng hỗ trợ âm thanh trong thế giới thực.

Nếu bạn muốn nâng cao kiến thức thực hành với LangChain, tôi gợi ý các bài blog sau:

• Cách xây dựng giao diện người dùng cho ứng dụng AI bằng Streamlit và LangChain
• RAG với Llama 3.1 8B, Ollama và LangChain: Hướng dẫn
• Xây dựng LangChain Agents để tự động hóa tác vụ trong Python