ืืื ื ืืืืืืชืืช
GPT-4o ืฉื OpenAI: ืืืื ืืืื ื ืืืืืืืชืืช ืืจื-ืืืืืืืช ืฉืืฉื ื ืืช ืืืื ืืจืืงืฆืื ืืื ืืื ืืืืื ื
OpenAI ืคืจืกืื ืืช ืืืื ืืฉืคื ืืขืืื ื ืืืืชืงืื ืืืืชืจ ืฉืื ืขื ืื โ GPT-4o, ืืืืื ื ืื "ืืืื ืืืืื ". ืืขืจืืช ืืื ื ืืืืืืชืืช ืืืคืื ืืช ืื ืืืืฆืืช ืงืคืืฆืช ืืืจืื ืขื ืงืืช, ืขื ืืืืืืช ืฉืืืฉืืฉืืช ืืช ืืืืื ืืื ืืื ื ืื ืืฉืืช ืืืื ื ืืืืืืชืืช.
ืืื ืืืื ืฉื GPT-4o ืืืื ืืืคืื ืืจื-ืืืืืื, ืืืืคืฉืจ ืื ืืขืื ืืืืฆืืจ ืชืืื ืืฆืืจื ืืืงื ืขื ืคื ื ืืงืกื, ืืืืื, ืชืืื ืืช ืืืืืื. ืฉืืืื ืื ืฉื ืืกืคืจ ืืืืืื ืืืืื ืืืื ืืื ืจืืฉืื ืืกืืื, ืืืืืื ืืขืฆื ืืืืฉ ืืช ืืืืคื ืฉืื ืื ื ืืงืืืืื ืืื ืืจืืงืฆืื ืขื ืขืืืจื ืืื ื ืืืืืืชืืช.
ืืื GPT-4o ืืื ืืจืื ืืืชืจ ืืกืชื ืืขืจืืช ืจื-ืืืืืืืช. ืืื ืืชืืื ืืฉืืคืืจ ืืืฆืืขืื ืืืืื ืืขืืืช ืงืืืืชื, GPT-4, ืืืฉืืืจื ืืืืื ืืชืืจืื ืืื Gemini 1.5 Pro, Claude 3 ื-Llama 3-70B ืืืคืก ืืงืื. ืืืื ื ืฆืืื ืืขืืืง ืืื ืฉืืืคื ืืช ืืืื ืืืื ื ืืืืืืืชืืช ืืื ืืคืืจืฅ ืืจื ืืืืช.
ืืืฆืืขืื ืืืขืืืืช ืืื ืชืืจืืช
ืืื ืืืืืืื ืืืจืฉืืืื ืืืืชืจ ืฉื GPT-4o ืืื ืืืืืืช ืืืืฆืืขืื ืืกืจืืช ืืชืงืืื ืฉืื. ืขื ืคื ืืขืจืืืช OpenAI, ืืืื ืืฉ ืืชืจืื ืืืืื ืฉื 60 ื ืงืืืืช Elo ืขื ืคื ื ืืืื ืืขื ืืืืฆืืขืื ืืืืืืืื ืืงืืื, GPT-4 Turbo. ืืชืจืื ืืฉืืขืืชื ืื ืืฆืื ืืช GPT-4o ืืืืื ืืฉืื, ืืขืืื ืืคืืื ืขื ืืืื ืืืื ื ืืืืืืืชืืช ืืืชืงืืืื ืืืืชืจ ืืืืื ืื ืืืื.
ืืื ืืืฆืืขืื ืืืืืืื ืืื ื ืืชืืื ืืืืื ืฉืื GPT-4o ืืืจื. ืืืื ืืชืืื ืื ืืืขืืืืช ืืจืฉืืื, ืคืืขื ืืืืืจืืช ืืคืืื ืืื ืฉื GPT-4 Turbo, ืชืื ืขืืืช ืชืคืขืื ื ืืืื ืจืง ืืืฆื. ืฉืืืื ืื ืฉื ืืืฆืืขืื ืืขืืืื ืืืกืืื ืืขืืืช ืืืคื ืืช GPT-4o ืืืฆืขื ืืืจืงืืืืืช ืืืืชืจ ืขืืืจ ืืคืชืืื ืืขืกืงืื ืืืขืื ืืื ืื ืืฉืื ืืืืืืช ืืื ื ืืืืืืชืืช ืืชืงืืืืช ืืืืฉืืืื ืฉืืื.
ืืืืืืช ืจื-ืืืืืืืืช: ืฉืืืื ืืงืกื, ืืืืื ืืกืจืืื
ืืืื ืืืืื ืคืืจืฅ ืืืจื ืืืืชืจ ืฉื GPT-4o ืืื ืืืคืื ืืจื-ืืืืืื, ืืืืคืฉืจ ืื ืืขืื ืืืืฆืืจ ืชืืื ืืฆืืจื ืืืงื ืขื ืคื ื ืืืืื ืฉืืืืช, ืืืื ืืงืกื, ืืืืื ืืจืืืื. ืฉืืืื ืื ืฉื ืืกืคืจ ืฉืืืืช ืืืืื ืืืื ืืื ืจืืฉืื ืืกืืื, ืืืื ืืืืื ืืืืื ืืืคืื ืืืืคื ืฉืื ืื ื ืืงืืืืื ืืื ืืจืืงืฆืื ืขื ืขืืืจื ืืื ื ืืืืืืชืืช.
ืืขืืจืช GPT-4o, ืืฉืชืืฉืื ืืืืืื ืื ืื ืฉืืืืช ืืืขืืืช ืืืื ืืืช ืืืืฆืขืืช ืืืืืจ, ืืืฉืจ ืืืืื ืืืื ืืืืื ืืืืคื ืืืืื ืืงืืื ืฉืืข. ืืื ืืืืืืืช ืื ื ืืืจืืช ืฉื - GPT-4o ืืืื ืื ืืคืจืฉ ืืืืฆืืจ ืชืืื ืืืืชื, ืืืคืชืื ืขืืื ืฉื ืืคืฉืจืืืืช ืืืืฉืืืื ืืื ืื ืืชืื ืืืฆืืจืช ืชืืื ืืช ืืขื ืืืื ื ืืืฆืืจืช ืืืืื.
ืืืช ืืืืืืืช ืืืจืฉืืืืช ืืืืชืจ ืฉื ืืืืืืชืื ืืจื-ืืืืืืืืช ืฉื GPT-4o ืืื ืืืืืชื ืื ืชื ืกืฆื ื ืื ืชืืื ื ืืืื ืืืช, ืืชืืจ ืืืคืจืฉ ืืืืืืง ืืช ืืืืื ืืื ืืืืืชืืื ืฉืืื ืชืืคืก. ืืชืืื ื ืื ืืฉืืืืช ืขืืืงืืช ืขื ืืืฉืืืื ืืืื ืืื ืืืืืืืช ืืกืืืขืืช ืืื ืฉืื ืขื ืืงืืืืช ืจืืืื, ืืื ืื ืืชืืืืื ืืื ืืืืื, ืืขืงื ืืืืืืืฆืื.
ืืื ืืืืืืืช ืืจื-ืืืืืืืืช ืฉื GPT-4o ืืืจืืืช ืืขืืจ ืืืื ื ืืืฆืืจืช ืชืืื ืขื ืคื ื ืฉืืืืช ืฉืื ืืช. ืืืืื ืืืื ืื ืืฉืื ืืฆืืจื ืืืงื ืืช ืืฉืืืืช ืืืื, ืืืืฆืืจ ืืืืืืช ืกืืืคืืช ืืืจืชืงืืช ืืืืช. ืืืืืื, ืืืืื ืืืืืื ืืืื ืฉื OpenAI, GPT-4o ืืฆืืืื ืืืฆืืจ ืฉืืจ ืืืืืกืก ืขื ืชื ืื ืงืื, ืืืฉืื ืืช ืืื ืชื ืืช ืืฉืคื, ืชืืจืช ืืืืืืงื ืืืฆืืจืช ืืืืืื ืืคืื ืงืืืจื ืื ืืืจืฉืื.
ืฉืืืืฉ ื-GPT0 ืืืืฆืขืืช Python
import openai
# Replace with your actual API key
OPENAI_API_KEY = "your_openai_api_key_here"
# Function to extract the response content
def get_response_content(response_dict, exclude_tokens=None):
if exclude_tokens is None:
exclude_tokens = []
if response_dict and response_dict.get("choices") and len(response_dict["choices"]) > 0:
content = response_dict["choices"][0]["message"]["content"].strip()
if content:
for token in exclude_tokens:
content = content.replace(token, '')
return content
raise ValueError(f"Unable to resolve response: {response_dict}")
# Asynchronous function to send a request to the OpenAI chat API
async def send_openai_chat_request(prompt, model_name, temperature=0.0):
openai.api_key = OPENAI_API_KEY
message = {"role": "user", "content": prompt}
response = await openai.ChatCompletion.acreate(
model=model_name,
messages=[message],
temperature=temperature,
)
return get_response_content(response)
# Example usage
async def main():
prompt = "Hello!"
model_name = "gpt-4o-2024-05-13"
response = await send_openai_chat_request(prompt, model_name)
print(response)
if __name__ == "__main__":
import asyncio
asyncio.run(main())
ืืฉ ืื:
- ืืืืืชื ืืช ืืืืื openai ืืฉืืจืืช ืืืงืื ืืืฉืชืืฉ ืืืืืงื ืืืชืืืช ืืืฉืืช.
- ืฉื ืืคืื ืงืฆืื openai_chat_resolve ืฉืื ื ื- get_response_content ืืืืฆืขื ืืื ืฉืื ืืืื ืงืืื ืืืืฉืื ืฉืื.
- ืืืืคืชื ืืช ืืืืืงื AsyncOpenAI ืืคืื ืงืฆืื openai.ChatCompletion.acreate, ืฉืืื ืืฉืืื ืืืกืื ืืจืื ืืช ืืจืฉืืืช ืืืกืืคืงืช ืขื ืืื ืกืคืจืืืช OpenAI Python.
- ื ืืกืคื ืืืืื ืืคืื ืงืฆืื ืจืืฉืืช ืฉืืืืืื ืืืฆื ืืืฉืชืืฉ ืืคืื ืงืฆืื send_openai_chat_request.
ืฉืืื ืื ืฉืขืืืื ืืืืืืฃ ืืช "your_openai_api_key_here" ืืืคืชื ื-API ืฉื OpenAI ืืคืืขื ืืื ืฉืืงืื ืืคืขื ืืืืื.
















