Python 如何调用 AI：全面指南

🚀 引言

在当今快速发展的技术浪潮中，人工智能（AI）已经渗透到我们生活的方方面面，从智能语音助手到自动驾驶汽车，AI 的应用无处不在。Python 作为一门功能强大且易于学习的编程语言，凭借其丰富的库和活跃的社区支持，已成为 AI 领域最受欢迎的语言之一。无论是数据科学家、机器学习工程师，还是对 AI 感兴趣的开发者，掌握如何使用 Python 调用 AI 模型和 API 都至关重要。

本指南旨在为读者提供一个全面的视角，详细介绍如何使用 Python 调用本地 AI 模型以及云端 AI API。我们将从基础概念入手，逐步深入到具体的代码实现，帮助读者轻松驾驭 AI 技术，将其应用于实际项目中。无论您是希望在本地环境中部署和运行 AI 模型，还是利用云端强大的计算能力和预训练模型，本指南都将为您提供清晰的指引和实用的代码示例。

让我们一起踏上这段探索 Python 调用 AI 的旅程吧！

🏠 一、调用本地 AI 模型

在许多场景下，我们可能需要在本地环境中运行 AI 模型，例如数据隐私要求高、网络连接不稳定或需要低延迟推理的场景。Python 提供了多种方式来调用本地 AI 模型，本节将重点介绍如何使用 Hugging Face 的 Transformers 库以及 TensorFlow 或 PyTorch 来实现。

🤗 1.1 使用 Hugging Face 的 Transformers 库调用预训练模型

Hugging Face 的 Transformers 库是一个功能强大且广泛使用的库，它提供了大量预训练的自然语言处理（NLP）模型，如 BERT、GPT-2、T5 等。使用该库，我们可以轻松地进行文本分类、命名实体识别、文本生成等任务。

安装依赖库

在使用 Transformers 库之前，我们需要先安装它以及相关的依赖库。推荐使用 pip 进行安装：

pip install transformers torch

这里我们同时安装了 torch，因为 Transformers 库通常与 PyTorch 或 TensorFlow 配合使用。如果您更倾向于 TensorFlow，可以将 torch 替换为 tensorflow。

代码示例：文本生成

下面是一个使用 Hugging Face Transformers 库进行文本生成的简单示例。我们将使用 pipeline 功能，它提供了一个高级 API，可以非常方便地使用预训练模型进行各种任务。

from transformers import pipeline

# 加载一个文本生成模型
generator = pipeline('text-generation', model='gpt2')

# 生成文本
result = generator("Hello, I'm a language model,", max_length=50, num_return_sequences=1)

# 打印生成结果
print(result[0]['generated_text'])

代码解释

1. from transformers import pipeline: 导入 pipeline 函数，它是 Hugging Face Transformers 库中一个非常实用的工具，可以快速加载和使用各种预训练模型。
2. generator = pipeline('text-generation', model='gpt2'): 创建一个文本生成器。'text-generation' 指定了任务类型为文本生成，model='gpt2' 指定了使用的预训练模型为 GPT-2。pipeline 会自动下载并加载模型及其对应的分词器（tokenizer）。
3. result = generator("Hello, I'm a language model,", max_length=50, num_return_sequences=1): 调用生成器进行文本生成。我们提供了一个起始文本（prompt），max_length=50 限制了生成文本的最大长度为 50 个词元（tokens），num_return_sequences=1 表示只生成一个结果。
4. print(result[0]['generated_text']): 打印生成的文本。result 是一个列表，每个元素是一个字典，其中包含了生成的文本。

🔧 1.2 使用 TensorFlow 或 PyTorch 调用自定义训练的模型

除了使用预训练模型，我们还经常需要使用自己训练的自定义模型。TensorFlow 和 PyTorch 是目前最流行的两个深度学习框架，它们都提供了完善的模型保存和加载机制。

保存模型

在训练完模型后，我们需要将其保存到磁盘，以便后续加载和使用。以下是 TensorFlow 和 PyTorch 保存模型的示例：

TensorFlow 保存模型示例：

import tensorflow as tf
from tensorflow.keras import layers, models

# 构建一个简单的模型
model = models.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dense(10, activation='softmax')
])

# 编译模型（这里只是示例，实际训练时需要配置优化器、损失函数等）
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# 保存模型
model.save('my_tf_model.h5')
print("TensorFlow 模型已保存到 my_tf_model.h5")

PyTorch 保存模型示例：

import torch
import torch.nn as nn

# 定义一个简单的神经网络
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 64)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 实例化模型
model = SimpleNN()

# 保存模型的状态字典
torch.save(model.state_dict(), 'my_pytorch_model.pth')
print("PyTorch 模型状态字典已保存到 my_pytorch_model.pth")

# 如果要保存整个模型（包括模型结构），可以使用以下方式：
# torch.save(model, 'my_pytorch_model_full.pth')

加载并使用模型

保存模型后，我们可以在需要时将其加载到内存中，并用于推理或进一步训练。

TensorFlow 加载并使用模型示例：

import tensorflow as tf
import numpy as np

# 加载模型
loaded_model = tf.keras.models.load_model('my_tf_model.h5')
print("TensorFlow 模型已加载")

# 准备一些虚拟输入数据（例如，一个手写数字图像的展平向量）
# 假设输入数据是28x28像素的图像，展平后是784维
input_data = np.random.rand(1, 784).astype(np.float32)

# 使用加载的模型进行预测
predictions = loaded_model.predict(input_data)
print("TensorFlow 模型预测结果：", predictions)

代码解释 (TensorFlow)

1. loaded_model = tf.keras.models.load_model('my_tf_model.h5'): 使用 tf.keras.models.load_model() 函数加载之前保存的 TensorFlow 模型。该函数会自动识别模型的格式并加载其结构和权重。
2. input_data = np.random.rand(1, 784).astype(np.float32): 创建一个模拟的输入数据。这里假设模型接受一个形状为 (1, 784) 的浮点数数组作为输入，代表一个样本的特征。
3. predictions = loaded_model.predict(input_data): 使用加载的模型对输入数据进行预测。predict() 方法会返回模型的输出，通常是每个类别的概率或回归值。

PyTorch 加载并使用模型示例：

import torch
import torch.nn as nn
import numpy as np

# 重新定义模型结构，这与保存模型时定义的结构必须一致
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(784, 64)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 实例化模型
model = SimpleNN()

# 加载模型状态字典
model.load_state_dict(torch.load('my_pytorch_model.pth'))

# 将模型设置为评估模式（这对于推理很重要，因为它会关闭Dropout等层）
model.eval()
print("PyTorch 模型状态字典已加载，并设置为评估模式")

# 准备一些虚拟输入数据
input_data = torch.randn(1, 784) # PyTorch通常使用Tensor作为输入

# 使用加载的模型进行预测
with torch.no_grad(): # 在推理时禁用梯度计算，可以节省内存并加速计算
    output = model(input_data)
    # 如果是分类任务，通常会使用softmax获取概率，然后arg_max获取预测类别
    probabilities = torch.softmax(output, dim=1)
    predicted_class = torch.argmax(probabilities, dim=1)
    print("PyTorch 模型预测结果（原始输出）：", output)
    print("PyTorch 模型预测类别：", predicted_class.item())

代码解释 (PyTorch)

1. 重新定义模型结构：与 TensorFlow 不同，PyTorch 在加载模型状态字典时，需要先定义好模型的结构。这意味着 SimpleNN 类的定义必须与保存模型时使用的类定义完全一致。
2. model = SimpleNN(): 实例化一个新的模型对象，这个对象将用于加载保存的权重。
3. model.load_state_dict(torch.load('my_pytorch_model.pth')): 使用 torch.load() 加载保存的状态字典，然后通过模型的 load_state_dict() 方法将权重加载到模型实例中。
4. model.eval(): 将模型设置为评估模式。这对于推理非常重要，因为它会关闭诸如 Dropout 和 BatchNorm 等在训练时才启用的层，确保模型在推理时行为一致。
5. input_data = torch.randn(1, 784): 创建一个模拟的输入数据，这里使用 torch.randn 生成一个随机张量。
6. with torch.no_grad():: 这是一个上下文管理器，用于在推理时禁用梯度计算。这可以显著减少内存消耗并加速计算，因为我们不需要在推理过程中进行反向传播。
7. output = model(input_data): 将输入数据传递给模型进行前向传播，获取模型的原始输出。
8. probabilities = torch.softmax(output, dim=1) 和 predicted_class = torch.argmax(probabilities, dim=1): 如果是分类任务，通常会对模型的原始输出应用 softmax 函数来获取每个类别的概率，然后使用 argmax 来确定预测的类别。dim=1 表示在第二个维度（类别维度）上进行操作。

☁️ 二、调用云端 AI API

除了在本地运行 AI 模型，我们还可以利用云端强大的计算资源和预训练模型。云端 AI API 提供了便捷的方式来访问各种先进的 AI 功能，而无需自己管理复杂的模型和基础设施。本节将介绍如何调用 OpenAI 的 GPT 模型和百度的文心一言 API。

✨ 2.1 调用 OpenAI 的 GPT 模型

OpenAI 的 GPT（Generative Pre-trained Transformer）系列模型是目前最先进的语言模型之一，能够执行各种复杂的自然语言任务，如文本生成、翻译、摘要、问答等。

安装依赖库

要调用 OpenAI 的 API，我们需要安装 openai 库：

pip install openai

代码示例：文本生成

以下是一个使用 OpenAI API 进行文本生成的示例。请注意，您需要一个 OpenAI API 密钥才能运行此代码。

import openai

# 设置您的 OpenAI API 密钥
# 建议从环境变量中读取，而不是硬编码在代码中
# openai.api_key = "YOUR_OPENAI_API_KEY"

# 创建一个聊天补全请求
response = openai.ChatCompletion.create(
  model="gpt-3.5-turbo",
  messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Who won the world series in 2020?"},
        {"role": "assistant", "content": "The Los Angeles Dodgers won the World Series in 2020."},
        {"role": "user", "content": "Where was it played?"}
    ]
)

# 打印助手的回复
print(response.choices[0].message["content"])

代码解释

1. import openai: 导入 openai 库。
2. openai.api_key = "YOUR_OPENAI_API_KEY": 设置您的 OpenAI API 密钥。为了安全起见，强烈建议将 API 密钥存储在环境变量中，而不是直接写在代码里。
3. response = openai.ChatCompletion.create(...): 调用 ChatCompletion.create 方法来创建一个聊天补全请求。这是与 GPT-3.5-turbo 及更高版本模型交互的标准方式。
4. model="gpt-3.5-turbo": 指定要使用的模型。gpt-3.5-turbo 是一个功能强大且经济高效的模型。
5. messages=[...]: 提供一个消息列表作为对话历史。每个消息都是一个字典，包含 role（角色，可以是 system、user 或 assistant）和 content（消息内容）。这种格式允许模型理解对话的上下文。
6. print(response.choices[0].message["content"]): 打印模型的回复。API 的响应是一个 JSON 对象，其中 choices 是一个列表，包含了可能的回复。我们通常取第一个回复（choices[0]），并提取其 message 中的 content。

🔄 2.2 调用百度的文心一言 API

百度的文心一言是另一个强大的中文语言模型，提供了丰富的 API 来支持各种应用场景。

安装依赖库

要调用文心一言的 API，您通常需要使用 requests 库来发送 HTTP 请求。此外，百度智能云也可能提供专门的 SDK。

pip install requests

代码示例：文本生成

以下是一个使用 requests 库调用文心一言 API 的示例。请注意，您需要一个百度智能云的 API Key 和 Secret Key 来获取 access_token。

import requests
import json

# 1. 获取 Access Token
def get_access_token(api_key, secret_key):
    """
    使用 AK，SK 生成鉴权签名（Access Token）
    :return: access_token，或是None(如果错误)
    """
    url = f"https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id={api_key}&client_secret={secret_key}"
    
    payload = json.dumps("")
    headers = {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    }
    
    response = requests.request("POST", url, headers=headers, data=payload)
    return response.json().get("access_token")

# 2. 调用文心一言 API
def main():
    # 替换为您的 API Key 和 Secret Key
    api_key = "YOUR_API_KEY"
    secret_key = "YOUR_SECRET_KEY"
    
    access_token = get_access_token(api_key, secret_key)
    if not access_token:
        print("获取 access_token 失败")
        return

    url = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions?access_token=" + access_token
    
    payload = json.dumps({
        "messages": [
            {
                "role": "user",
                "content": "你好，请做个自我介绍"
            }
        ]
    })
    headers = {
        'Content-Type': 'application/json'
    }
    
    response = requests.request("POST", url, headers=headers, data=payload)
    
    print(response.json())

if __name__ == '__main__':
    main()

代码解释

1. get_access_token(api_key, secret_key): 这个函数用于获取访问文心一言 API 所需的 access_token。它向百度智能云的认证服务器发送一个 POST 请求，并携带您的 API Key 和 Secret Key。成功后，服务器会返回一个 access_token。
2. main(): 主函数首先调用 get_access_token 获取 access_token，然后构造一个向文心一言 API 发送的 POST 请求。
3. url = "https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions?access_token=" + access_token: 这是文心一言的 API 端点，access_token 作为 URL 参数传递。
4. payload = json.dumps(...): 请求体中包含了 messages 字段，与 OpenAI 的 API 类似，它提供了一个对话历史。这里我们只发送了一个用户的消息。
5. response = requests.request("POST", url, headers=headers, data=payload): 使用 requests 库发送 POST 请求。
6. print(response.json()): 打印 API 的响应。响应通常是一个 JSON 对象，其中包含了模型的回复和其他信息。

⚠️ 三、注意事项

在使用 Python 调用 AI 模型和 API 时，有一些重要的注意事项需要牢记，以确保您的应用高效、安全、稳定地运行。

API 密钥管理

无论是 OpenAI 还是百度文心一言，使用云端 AI API 都需要 API 密钥。这些密钥是您访问服务的凭证，务必妥善保管，切勿将其硬编码在代码中或公开暴露。推荐的做法是：

• 使用环境变量：将 API 密钥存储在操作系统的环境变量中，然后在代码中读取。这样可以避免密钥泄露，并且方便在不同环境中部署。
• 使用配置文件：对于更复杂的项目，可以使用 .env 文件或专门的配置文件来存储敏感信息，并通过版本控制工具（如 Git）忽略这些文件。
• 避免在客户端代码中使用：如果您的应用包含前端部分，切勿将 API 密钥直接暴露在客户端代码中，这会带来严重的安全风险。所有 API 调用都应该通过后端服务器进行代理。

错误处理

在与外部服务（如云端 AI API）交互时，网络问题、API 调用限制、无效参数等都可能导致错误。良好的错误处理机制是构建健壮应用的关键：

• 使用 try-except 块：捕获可能发生的异常，例如网络连接错误、API 返回的错误码等。
• 日志记录：详细记录错误信息，包括错误类型、错误消息、请求参数等，以便于调试和问题排查。
• 重试机制：对于临时的网络问题或 API 速率限制，可以实现指数退避（exponential backoff）的重试机制，提高调用的成功率。

性能优化

AI 模型，尤其是大型语言模型，通常计算资源消耗较大。在调用时，需要考虑性能优化：

• 批量处理：如果可能，尽量将多个请求合并为批量请求，减少网络往返时间。
• 异步调用：对于需要同时处理多个请求的场景，可以使用异步编程（如 asyncio）来提高并发性能。
• 选择合适的模型：根据您的需求和预算，选择大小和性能最匹配的模型。例如，对于简单的任务，可能不需要使用最大的 GPT 模型。
• 本地缓存：对于重复的请求或不经常变化的模型输出，可以考虑在本地进行缓存，减少对 API 的调用。

📝 四、总结

本指南全面介绍了如何使用 Python 调用 AI 模型，涵盖了本地部署和云端 API 两种主要方式。我们探讨了 Hugging Face Transformers 库在预训练模型调用中的便捷性，以及 TensorFlow 和 PyTorch 在自定义模型保存与加载方面的灵活性。同时，我们也深入了解了如何通过 OpenAI 和百度文心一言等云端服务，利用其强大的 AI 能力。

每种方法都有其独特的优势和适用场景：

• 本地 AI 模型：适用于对数据隐私有严格要求、网络环境受限或需要极低延迟的场景。它提供了对模型更细粒度的控制，但需要更多的本地计算资源和环境配置。
• 云端 AI API：提供了便捷的访问方式，无需管理底层基础设施，可以快速集成先进的 AI 能力。它通常具有强大的计算能力和可扩展性，但依赖于网络连接，并涉及 API 密钥管理和成本考量。

在选择合适的 AI 调用方式时，建议您综合考虑以下因素：

1. 项目需求：您的应用需要什么样的 AI 能力？是文本生成、图像识别还是其他？
2. 数据敏感性：您的数据是否包含敏感信息？是否允许上传到云端？
3. 性能要求：对响应时间、吞吐量是否有严格要求？
4. 成本预算：云端 API 通常按使用量计费，本地部署则需要考虑硬件投入。
5. 开发效率：哪种方式能让您更快地实现功能并投入使用？

希望本指南能帮助您更好地理解和应用 Python 在 AI 领域的强大能力，祝您在 AI 之旅中取得丰硕的成果！