110 个 Agent Skills 盘点（十一）：AI/ML 专用技能

1
# Agent 使用 HuggingFace 推理 API
2
import requests
3

4
def analyze_sentiment(text):
5
    """使用 HuggingFace 模型进行情感分析"""
6
    API_URL = "https://api-inference.huggingface.co/models/finiteautomata/bertweet-base-sentiment-analysis"
7
    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
8

9
    response = requests.post(API_URL, headers=headers, json={"inputs": text})
10
    result = response.json()
11

12
    return {
13
        "label": result[0][0]["label"],
14
        "score": result[0][0]["score"]
15
    }
16

17
# Agent 批量分析用户评论
18
def analyze_reviews(reviews):
19
    results = []
20
    for review in reviews:
21
        sentiment = analyze_sentiment(review["text"])
22
        results.append({
23
            "review": review["text"][:50],
24
            "sentiment": sentiment["label"],
25
            "confidence": f"{sentiment['score']:.2%}"
26
        })
27
    return results

1
// Agent 使用 HuggingFace 搜索模型
2
async function findBestModel(task, language) {
3
  const models = await huggingface.searchModels({
4
    task: task,  // e.g., "text-classification"
5
    language: language,  // e.g., "zh"
6
    sort: "downloads",
7
    limit: 5
8
  });
9

10
  return models.map(m => ({
11
    name: m.id,
12
    downloads: m.downloads,
13
    likes: m.likes,
14
    description: m.description
15
  }));
16
}

1
# Agent 使用 OpenAI API 进行复杂推理
2
from openai import OpenAI
3

4
client = OpenAI()
5

6
def analyze_contract(contract_text):
7
    """使用 GPT-4 分析合同条款"""
8
    response = client.chat.completions.create(
9
        model="gpt-4o",
10
        response_format={"type": "json_object"},
11
        messages=[
12
            {
13
                "role": "system",
14
                "content": "你是一个专业的法律顾问，擅长分析合同条款。请以 JSON 格式返回分析结果。"
15
            },
16
            {
17
                "role": "user",
18
                "content": f"""分析以下合同，提取关键信息：
19

20
{contract_text}
21

22
返回格式：
23
{{
24
  "parties": ["甲方", "乙方"],
25
  "duration": "合同期限",
26
  "amount": "金额",
27
  "risks": ["风险点1", "风险点2"],
28
  "suggestions": ["建议1", "建议2"]
29
}}"""
30
            }
31
        ]
32
    )
33

34
    return json.loads(response.choices[0].message.content)

1
// Agent 使用 Function Calling 调用工具
2
const response = await openai.chat.completions.create({
3
  model: "gpt-4o",
4
  messages: [{ role: "user", content: "帮我查一下北京今天的天气" }],
5
  tools: [{
6
    type: "function",
7
    function: {
8
      name: "get_weather",
9
      description: "获取指定城市的天气信息",
10
      parameters: {
11
        type: "object",
12
        properties: {
13
          city: { type: "string", description: "城市名称" },
14
          date: { type: "string", description: "日期，格式 YYYY-MM-DD" }
15
        },
16
        required: ["city"]
17
      }
18
    }
19
  }]
20
});

1
# Agent 使用 Ollama 运行本地模型
2
import requests
3

4
def local_chat(prompt, model="llama3"):
5
    """使用本地 Ollama 模型"""
6
    response = requests.post("http://localhost:11434/api/generate", json={
7
        "model": model,
8
        "prompt": prompt,
9
        "stream": False
10
    })
11

12
    return response.json()["response"]
13

14
# Agent 用本地模型处理敏感数据
15
def analyze_private_data(data):
16
    # 敏感数据不发送到云端
17
    prompt = f"""分析以下内部数据，找出异常模式：
18

19
{data}
20

21
请用中文回答，列出发现的问题。"""
22
    return local_chat(prompt)

1
# Agent 使用 DALL-E 生成产品图
2
from openai import OpenAI
3

4
client = OpenAI()
5

6
def generate_product_image(product_name, style, background):
7
    """生成产品营销图片"""
8
    prompt = f"""一张专业的{product_name}产品照片，
9
    {style}风格，{background}背景，
10
    高品质，商业摄影，8K 分辨率"""
11

12
    response = client.images.generate(
13
        model="dall-e-3",
14
        prompt=prompt,
15
        size="1024x1024",
16
        quality="hd",
17
        n=1
18
    )
19

20
    return response.data[0].url
21

22
# Agent 批量生成社交媒体配图
23
def generate_social_images(topics):
24
    images = []
25
    for topic in topics:
26
        url = generate_product_image(
27
            product_name=topic["product"],
28
            style="现代简约",
29
            background="纯色渐变"
30
        )
31
        images.append({"topic": topic["title"], "image_url": url})
32
    return images

1
# Agent 使用 Whisper 进行语音转文字
2
import whisper
3

4
def transcribe_audio(audio_path, language="zh"):
5
    """将音频转为文字"""
6
    model = whisper.load_model("medium")
7
    result = model.transcribe(audio_path, language=language)
8

9
    # 带时间戳的转录
10
    segments = []
11
    for segment in result["segments"]:
12
        segments.append({
13
            "start": segment["start"],
14
            "end": segment["end"],
15
            "text": segment["text"]
16
        })
17

18
    return {
19
        "text": result["text"],
20
        "segments": segments,
21
        "language": result["language"]
22
    }
23

24
# Agent 生成会议纪要
25
def generate_meeting_minutes(audio_path):
26
    # 1. 语音转文字
27
    transcript = transcribe_audio(audio_path)
28

29
    # 2. 用 LLM 生成纪要
30
    minutes = llm.generate(f"""
31
    根据以下会议转录生成会议纪要：
32

33
    {transcript['text']}
34

35
    包含：主题、讨论要点、决议、待办事项。
36
    """)
37

38
    return {"transcript": transcript, "minutes": minutes}

1
# Agent 使用 ElevenLabs 生成语音
2
import requests
3

4
def text_to_speech(text, voice_id="alloy"):
5
    """将文字转为语音"""
6
    response = requests.post(
7
        "https://api.elevenlabs.io/v1/text-to-speech/{voice_id}",
8
        headers={"xi-api-key": ELEVENLABS_API_KEY},
9
        json={
10
            "text": text,
11
            "model_id": "eleven_multilingual_v2",
12
            "voice_settings": {
13
                "stability": 0.5,
14
                "similarity_boost": 0.75
15
            }
16
        }
17
    )
18

19
    with open("output.mp3", "wb") as f:
20
        f.write(response.content)
21

22
    return "output.mp3"

1
# Agent 使用 OpenAI Embedding
2
from openai import OpenAI
3
import numpy as np
4

5
client = OpenAI()
6

7
def get_embedding(text, model="text-embedding-3-small"):
8
    """获取文本的向量表示"""
9
    response = client.embeddings.create(
10
        input=text,
11
        model=model
12
    )
13
    return response.data[0].embedding
14

15
def cosine_similarity(vec1, vec2):
16
    """计算余弦相似度"""
17
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
18

19
# Agent 语义搜索
20
def semantic_search(query, documents, top_k=5):
21
    """在文档中进行语义搜索"""
22
    query_vec = get_embedding(query)
23

24
    scores = []
25
    for doc in documents:
26
        doc_vec = get_embedding(doc["content"])
27
        score = cosine_similarity(query_vec, doc_vec)
28
        scores.append({"doc": doc, "score": score})
29

30
    scores.sort(key=lambda x: x["score"], reverse=True)
31
    return scores[:top_k]

1
# Agent 使用 FAISS 进行高效向量搜索
2
import faiss
3
import numpy as np
4

5
def build_index(vectors):
6
    """构建 FAISS 索引"""
7
    dimension = len(vectors[0])
8
    index = faiss.IndexFlatIP(dimension)  # 内积相似度
9

10
    # 转换为 float32
11
    vectors = np.array(vectors, dtype='float32')
12
    faiss.normalize_L2(vectors)  # L2 归一化
13

14
    index.add(vectors)
15
    return index
16

17
def search(index, query_vector, top_k=10):
18
    """搜索最相似的向量"""
19
    query = np.array([query_vector], dtype='float32')
20
    faiss.normalize_L2(query)
21

22
    distances, indices = index.search(query, top_k)
23
    return list(zip(indices[0], distances[0]))
24

25
# Agent 构建百万级向量索引
26
def build_large_index(vectors, index_path):
27
    """构建大规模索引"""
28
    dimension = len(vectors[0])
29

30
    # 使用 IVF 索引加速搜索
31
    nlist = 1000  # 聚类数
32
    quantizer = faiss.IndexFlatIP(dimension)
33
    index = faiss.IndexIVFFlat(quantizer, dimension, nlist)
34

35
    # 训练索引
36
    vectors = np.array(vectors, dtype='float32')
37
    faiss.normalize_L2(vectors)
38
    index.train(vectors)
39
    index.add(vectors)
40

41
    # 保存索引
42
    faiss.write_index(index, index_path)
43
    return index

1
# Agent 使用 LoRA 微调模型
2
from transformers import AutoModelForCausalLM, AutoTokenizer
3
from peft import LoraConfig, get_peft_model
4
from datasets import load_dataset
5

6
def fine_tune_model(base_model, dataset_path, output_dir):
7
    """使用 LoRA 微调语言模型"""
8
    # 加载基础模型
9
    model = AutoModelForCausalLM.from_pretrained(base_model)
10
    tokenizer = AutoTokenizer.from_pretrained(base_model)
11

12
    # 配置 LoRA
13
    lora_config = LoraConfig(
14
        r=16,  # 秩
15
        lora_alpha=32,
16
        target_modules=["q_proj", "v_proj"],
17
        lora_dropout=0.05,
18
        bias="none",
19
        task_type="CAUSAL_LM"
20
    )
21

22
    # 应用 LoRA
23
    model = get_peft_model(model, lora_config)
24

25
    # 加载数据集
26
    dataset = load_dataset("json", data_files=dataset_path)
27

28
    # 训练配置
29
    training_args = TrainingArguments(
30
        output_dir=output_dir,
31
        num_train_epochs=3,
32
        per_device_train_batch_size=4,
33
        gradient_accumulation_steps=4,
34
        learning_rate=2e-4,
35
        fp16=True,
36
        logging_steps=10,
37
        save_strategy="epoch"
38
    )
39

40
    # 开始训练
41
    trainer = Trainer(
42
        model=model,
43
        args=training_args,
44
        train_dataset=dataset["train"]
45
    )
46

47
    trainer.train()
48
    model.save_pretrained(output_dir)

1
# Agent 使用 LangChain 构建复杂应用
2
from langchain.agents import AgentExecutor, create_react_agent
3
from langchain.tools import Tool
4
from langchain_openai import ChatOpenAI
5

6
# 定义工具
7
tools = [
8
    Tool(name="搜索", func=search_web, description="搜索互联网"),
9
    Tool(name="数据库", func=query_db, description="查询数据库"),
10
    Tool(name="计算", func=calculator, description="数学计算"),
11
]
12

13
# 创建 Agent
14
llm = ChatOpenAI(model="gpt-4o")
15
agent = create_react_agent(llm, tools, prompt)
16
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
17

18
# 运行
19
result = executor.invoke({
20
    "input": "分析最近一个月的销售趋势，找出增长最快的产品"
21
})

1
# Agent 使用 LlamaIndex 构建 RAG 应用
2
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
3

4
# 加载文档
5
documents = SimpleDirectoryReader('./data').load_data()
6

7
# 创建索引
8
index = VectorStoreIndex.from_documents(documents)
9

10
# 创建查询引擎
11
query_engine = index.as_query_engine()
12

13
# 查询
14
response = query_engine.query("这个项目的架构是怎样的？")
15
print(response)

1
# Agent 使用 GPT-4o Vision 分析图片
2
from openai import OpenAI
3

4
client = OpenAI()
5

6
def analyze_image(image_url, question):
7
    """分析图片内容"""
8
    response = client.chat.completions.create(
9
        model="gpt-4o",
10
        messages=[
11
            {
12
                "role": "user",
13
                "content": [
14
                    {"type": "text", "text": question},
15
                    {
16
                        "type": "image_url",
17
                        "image_url": {"url": image_url}
18
                    }
19
                ]
20
            }
21
        ]
22
    )
23

24
    return response.choices[0].message.content
25

26
# Agent 分析截图中的 UI 问题
27
def analyze_screenshot(screenshot_path):
28
    """分析 UI 截图"""
29
    with open(screenshot_path, "rb") as f:
30
        image_data = base64.b64encode(f.read()).decode()
31

32
    result = analyze_image(
33
        image_url=f"data:image/png;base64,{image_data}",
34
        question="分析这个 UI 截图，找出可能的用户体验问题和改进建议。"
35
    )
36

37
    return result

1
# Agent 使用 Claude Vision 分析文档
2
import anthropic
3

4
client = anthropic.Anthropic()
5

6
def analyze_document(image_path, question):
7
    """分析文档图片"""
8
    with open(image_path, "rb") as f:
9
        image_data = base64.b64encode(f.read()).decode()
10

11
    response = client.messages.create(
12
        model="claude-3-opus-20240229",
13
        max_tokens=1024,
14
        messages=[
15
            {
16
                "role": "user",
17
                "content": [
18
                    {
19
                        "type": "image",
20
                        "source": {
21
                            "type": "base64",
22
                            "media_type": "image/png",
23
                            "data": image_data
24
                        }
25
                    },
26
                    {
27
                        "type": "text",
28
                        "text": question
29
                    }
30
                ]
31
            }
32
        ]
33
    )
34

35
    return response.content[0].text