利用GO和复制API的AI模型：综合指南

<code class="go">package main

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

    "github.com/hashicorp/go-retryablehttp" //  添加重试功能
)

// 配置结构体，用于存储Replicate API设置。
type config struct {
    token   string
    baseurl string
}

// newconfig 创建一个新的配置实例。
func newconfig() *config {
    return &config{
        token:   os.Getenv("replicate_api_token"),
        baseurl: "https://api.replicate.com/v1",
    }
}</code>

<code class="go">// client 代表我们的Replicate API客户端
type client struct {
    config *config
    http   *http.Client
}

// newclient 创建一个新的Replicate客户端实例，具有重试功能。
func newclient(config *config) *client {
    retryClient := retryablehttp.NewClient()
    retryClient.RetryMax = 3
    retryClient.RetryWaitMin = 1 * time.Second
    retryClient.RetryWaitMax = 30 * time.Second
    retryClient.HTTPClient.Timeout = 30 * time.Second

    return &client{
        config: config,
        http:   retryClient.StandardClient(),
    }
}

// createrequest 帮助构建具有适当标头的HTTP请求
func (c *client) createrequest(method, endpoint string, body any) (*http.Request, error) {
    var buf bytes.Buffer

    if body != nil {
        if err := json.NewEncoder(&buf).Encode(body); err != nil {
            return nil, fmt.Errorf("encoding request body: %w", err)
        }
    }

    req, err := http.NewRequest(method, c.config.baseurl+endpoint, &buf)
    if err != nil {
        return nil, fmt.Errorf("creating request: %w", err)
    }

    req.Header.Set("Authorization", "Token "+c.config.token)
    req.Header.Set("Content-Type", "application/json")

    return req, nil
}</code>

<code class="go">// predictioninput 代表Stable Diffusion的输入参数。
type stablediffusioninput struct {
    Prompt string `json:"prompt"`
    Width  int    `json:"width,omitempty"`
    Height int    `json:"height,omitempty"`
}

// createstablediffusionprediction 启动一个新的图像生成任务
func (c *client) createstablediffusionprediction(input *stablediffusioninput) (*prediction, error) {
    payload := map[string]interface{}{
        "version": "stable-diffusion-v1-5",
        "input":   input,
    }

    req, err := c.createrequest("POST", "/predictions", payload)
    if err != nil {
        return nil, err
    }

    resp, err := c.http.Do(req)
    if err != nil {
        return nil, fmt.Errorf("making request: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated {
        body, _ := ioutil.ReadAll(resp.Body)
        return nil, fmt.Errorf("api error: %s: %s", resp.Status, body)
    }

    var prediction prediction
    if err := json.NewDecoder(resp.Body).Decode(&prediction); err != nil {
        return nil, fmt.Errorf("decoding response: %w", err)
    }

    return &prediction, nil
}</code>

<code class="go">// predictionstatus 代表预测的当前状态
type predictionstatus string

const (
    statusstarting    predictionstatus = "starting"
    statusprocessing  predictionstatus = "processing"
    statussucceeded   predictionstatus = "succeeded"
    statusfailed      predictionstatus = "failed"
)

// pollprediction 持续检查预测的状态，直到完成
func (c *client) pollprediction(id string) (*prediction, error) {
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    timeout := time.After(10 * time.Minute)

    for {
        select {
        case <-ticker.C:
            // ... (获取预测状态的代码) ...
        case <-timeout:
            return nil, fmt.Errorf("prediction timed out")
        }
    }
}

// ... (prediction 结构体和获取预测状态的代码) ...

func main() {
    // ... (配置和客户端创建代码) ...

    input := &stablediffusioninput{
        Prompt: "A matte black sports car with purple neon wheels, low rider, neon lights, sunset, reflective puddles, sci-fi, concept car, sideview, tropical background, 35mm photograph, film grain, bokeh, professional, 4k, highly detailed",
        Width:  768,
        Height: 512,
    }

    prediction, err := client.createstablediffusionprediction(input)
    if err != nil {
        fmt.Printf("Error creating prediction: %v\n", err)
        return
    }

    result, err := client.pollprediction(prediction.id) //  调用轮询函数
    if err != nil {
        fmt.Printf("Error polling prediction: %v\n", err)
        return
    }

    // 处理结果
    if images, ok := result.output.([]string); ok && len(images) > 0 {
        fmt.Printf("Generated image URL: %s\n", images[0])
    }
}</code>

<code class="go">// 通用预测创建函数
func (c *client) CreatePrediction(version string, input any) (*prediction, error) {
    // ... (类似于 createstablediffusionprediction 的代码) ...
}</code>