Go 语言如何调用OpenAI API，包括 ChatGPT、GPT-3、GPT-4、DALL·E 3 和 Whisper-51CTO.COM

要在 Go 语言中调用 OpenAI 的 API（包括 ChatGPT、GPT-3、GPT-4、DALL·E 3 和 Whisper），可以通过使用 HTTP 请求来与 OpenAI 的 API 进行交互。你需要做的是：

获取 OpenAI API Key：你可以通过 OpenAI 官方网站申请一个 API 密钥。
安装必要的 Go 包：你可以使用 Go 的内置 net/http 库来发送 HTTP 请求，也可以选择使用第三方的库来简化开发。
构建 API 请求：根据 API 文档构建请求并解析响应。

1. 获取 OpenAI API Key

你需要一个 OpenAI API 密钥来访问 API。你可以在 OpenAI 官网注册账号并生成你的 API Key。

2. 安装必要的 Go 包

可以使用 net/http 库，也可以选择安装像 resty 这样的第三方 HTTP 客户端库。

使用标准库 net/http：

go get net/http1.

如果想使用 resty，可以安装它：

go get github.com/go-resty/resty/v21.

3. 调用 API 的示例代码

调用 ChatGPT、GPT-3、GPT-4 的示例

以调用 gpt-3.5-turbo 为例，使用 net/http 发送请求：

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions"

func main() {
    // OpenAI API Key
    apiKey := os.Getenv("OPENAI_API_KEY")

    // 请求的载荷
    requestBody, err := json.Marshal(map[string]interface{}{
        "model": "gpt-3.5-turbo",  // 或者 "gpt-4" 
        "messages": []map[string]string{
            {
                "role":    "system",
                "content": "You are a helpful assistant.",
            },
            {
                "role":    "user",
                "content": "Tell me a joke.",
            },
        },
    })
    if err != nil {
        panic(err)
    }

    // 创建 HTTP 请求
    req, err := http.NewRequest("POST", OPENAI_API_URL, bytes.NewBuffer(requestBody))
    if err != nil {
        panic(err)
    }

    // 设置请求头
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    // 发送请求
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    // 读取响应
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println("Response from OpenAI:")
    fmt.Println(string(body))
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.

调用 DALL·E 3 的示例

DALL·E 3 的 API 也是通过 POST 请求生成图像的。基本上请求结构和 GPT 的很类似，只是请求体的参数不同。

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

const DALL_E_API_URL = "https://api.openai.com/v1/images/generations"

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY")

    // 构建 DALL·E 的请求体
    requestBody, err := json.Marshal(map[string]interface{}{
        "prompt": "A futuristic city with flying cars",
        "n":      1,
        "size":   "1024x1024",
    })
    if err != nil {
        panic(err)
    }

    req, err := http.NewRequest("POST", DALL_E_API_URL, bytes.NewBuffer(requestBody))
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println("DALL·E response:")
    fmt.Println(string(body))
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

调用 Whisper API 的示例

Whisper 是 OpenAI 的语音转文字 API，调用时需要上传音频文件。

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
)

const WHISPER_API_URL = "https://api.openai.com/v1/audio/transcriptions"

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY")

    // 打开音频文件
    audioFilePath := "audio_sample.mp3"
    file, err := os.Open(audioFilePath)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    // 创建 multipart form 文件上传
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile("file", filepath.Base(audioFilePath))
    if err != nil {
        panic(err)
    }

    _, err = io.Copy(part, file)
    if err != nil {
        panic(err)
    }

    writer.WriteField("model", "whisper-1") // Whisper 模型
    err = writer.Close()
    if err != nil {
        panic(err)
    }

    // 构建 HTTP 请求
    req, err := http.NewRequest("POST", WHISPER_API_URL, body)
    if err != nil {
        panic(err)
    }

    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

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

    fmt.Println("Whisper response:")
    fmt.Println(string(respBody))
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.

通过使用 Go 语言调用 OpenAI API，可以轻松地与 GPT 系列、DALL·E 和 Whisper 进行交互。基本的步骤包括：

获取 API Key。
构建 HTTP 请求。
处理 API 的响应。

你可以根据需求在请求中调整不同的参数，例如 model、prompt、n、size 等等，来实现不同的功能。

常见的问题

Go OpenAI 是否提供一个方法来计算令牌？

是的，OpenAI 并没有直接为 Go 提供计算令牌的官方方法，但你可以使用以下几种方式来计算令牌：

使用第三方库
通过 API 响应的 usage 字段来获取已用令牌数量
自己实现简单的令牌计数算法

1. 使用第三方库

虽然 OpenAI 官方没有为 Go 提供现成的令牌计算方法，但是社区有一些非官方的库，可以帮助你计算令牌数量。例如，可以使用 Go 语言的 tiktoken 库。tiktoken 是 OpenAI 官方的 Python 库，它用于处理 OpenAI 模型的令牌化。虽然目前 OpenAI 没有为 Go 提供直接的库，你可以参考类似的实现逻辑。

目前 Go 社区有非官方的 tiktoken 实现，例如：

go-tiktoken：Go 的非官方实现。

使用 go-tiktoken 示例：

package main

import (
	"fmt"
	tiktoken_go "github.com/pkoukk/tiktoken-go"
)

func main() {
	// 创建编码器，基于模型
	enc, err := tiktoken_go.EncodingForModel("gpt-3.5-turbo")
	if err != nil {
		panic(err)
	}

	// 需要计算令牌的文本
	text := "OpenAI provides cutting-edge AI technologies."
	
	// 使用编码器对文本进行编码，得到令牌数组
	tokens := enc.Encode(text, nil, nil)

	fmt.Printf("Token count: %d\n", len(tokens))  // 输出令牌数量
	fmt.Println("Tokens:", tokens)                // 输出令牌数组
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

2. 通过 API 响应的 usage 字段

如果你只是想在调用 OpenAI API 时查看消耗了多少令牌，可以通过 API 响应中的 usage 字段来获取。例如，在调用 ChatGPT 时，响应中包含令牌的使用信息：

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "usage": {
    "prompt_tokens": 20,
    "completion_tokens": 30,
    "total_tokens": 50
  }
}1.
2.
3.
4.
5.
6.
7.
8.
9.

这意味着，提示（prompt）使用了 20 个令牌，回复（completion）使用了 30 个令牌，总共 50 个令牌。

在 Go 中，你可以通过解析这个响应来获取 prompt_tokens 和 total_tokens：

package main

import (
    "encoding/json"
    "fmt"
)

type APIResponse struct {
    Usage struct {
        PromptTokens     int `json:"prompt_tokens"`
        CompletionTokens int `json:"completion_tokens"`
        TotalTokens      int `json:"total_tokens"`
    } `json:"usage"`
}

func main() {
    response := `{
        "usage": {
            "prompt_tokens": 20,
            "completion_tokens": 30,
            "total_tokens": 50
        }
    }`

    var apiResponse APIResponse
    err := json.Unmarshal([]byte(response), &apiResponse)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Prompt Tokens: %d\n", apiResponse.Usage.PromptTokens)
    fmt.Printf("Completion Tokens: %d\n", apiResponse.Usage.CompletionTokens)
    fmt.Printf("Total Tokens: %d\n", apiResponse.Usage.TotalTokens)
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.

3. 自己实现令牌计数算法

如果你不想依赖第三方库，或不关心高精度的令牌计数，可以手动基于字符或单词数量进行简单的估算。OpenAI 的令牌化方式大致上是按照单词、标点符号、空格等计算的。

但是准确的令牌计数方式依赖于模型的编码方式。对于精确的令牌计算，建议使用类似 tiktoken 的实现。