> ## Content Index
> Fetch the complete content index at: https://www.hubwiz.com/blog/llms.txt
> Use this file to discover other available public pages before exploring further.

# AI工程师必备的7个开发框架
- URL: https://www.hubwiz.com/blog/top7-frameworks-for-ai-engineers/
- Published: 2025-12-06T10:08:31.000Z
- Updated: 2025-12-06T10:08:31.000Z
- Description: 我至今仍记得那个夜晚，我意识到自己一直以来都在走弯路。这七个框架彻底改变了我构建人工智能系统的方式。
- Author: admin
- Tags: LIBRARY, LANGCHAIN, TRANSFORMERS, LLAMAINDEX, GRADIO, W&B, STREAMLIT, FASTAPI, #Import 2026-10-14 14:41

凌晨 2 点。我的第四杯咖啡放在桌上，已经凉了。我花了整整三周时间构建了一个计算机视觉模型的自定义训练循环……结果却发现，有人已经用大约 47 行代码就构建了一个框架，完全满足了我的需求。

这真让人沮丧。

不是因为我浪费了三周时间……而是因为我意识到，我可能把很多其他事情都搞得太复杂了。关于人工智能开发，没人会在你刚开始的时候告诉你一个真相：了解有哪些框架可用，比从零开始构建一切更有价值。

让我来帮你避免我犯过的错误。这七个框架彻底改变了我构建人工智能系统的方式……说实话……有些框架用起来简直像作弊。

## 1、LangChain……让你不再为LLM API 而苦恼

还记得以前把语言模型集成到应用里，意味着要写几百行 API 封装代码吗？

我记得。去年我花了两个月时间为一个客户开发一个文档问答系统。代码简直一团糟。API 调用到处都是。提示管理分散在不同的文件中。想要在不同的模型之间切换，就得重写一半的代码。

然后我发现了 LangChain。

它不仅仅是一个 API 封装器。它是一个完整的框架，用于构建基于语言模型的应用。它支持顺序操作的链式结构，支持可以使用工具的智能体，以及真正有效的内存系统。无需更改核心逻辑，即可在 OpenAI、Anthropopic 或本地模型之间轻松切换。

这是我上周完成的一个项目，以前可能需要好几天才能完成……

```
from langchain.chat_models import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import TextLoader

# Load and process documents
loader = TextLoader("knowledge_base.txt")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
splits = text_splitter.split_documents(documents)
# Create vector store
vectorstore = FAISS.from_documents(
    documents=splits,
    embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()
# Build RAG chain
template = """Answer the question based only on the following context.....
{context}
Question..... {question}
"""
prompt = ChatPromptTemplate.from_template(template)
model = ChatOpenAI(model="gpt-4")
chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)
# Use it
response = chain.invoke("What are the main topics discussed?")
print(response)
```

这是一个完整的 RAG 系统。向量存储。文档检索。LLM 集成。所有功能都集成在一个简洁的流程中。

最棒的是什么？把 ChatOpenAI 换成 ChatAnthropic 或任何其他模型……一切依然运行正常。

## 2、Hugging Face Transformers……让 AI 民主化

我必须坦白一件事……在 Transformers 出现之前……我对使用预训练模型感到非常恐惧。

文档杂乱无章。每个模型都有不同的 API。加载权重就像做手术一样。微调模型需要 PyTorch 内部机制的博士学位。

Hugging Face 改变了一切。

超过 15 万个预训练模型。统一的 API。只需一行代码即可下载任何模型。只需少量代码即可进行微调。轻松部署到生产环境，无需辞职。

现在使用最先进的模型就是这么简单……

```
from transformers import pipeline
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Method 1..... Ultra simple pipeline
classifier = pipeline("sentiment-analysis")
result = classifier("I love building AI applications!")
print(result)
# Method 2..... More control
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)
# Tokenize and predict
inputs = tokenizer("This framework is incredible", return_tensors="pt")
with torch.no_grad():
    outputs = model(**inputs)
    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
    
print(f"Positive..... {predictions[0][1].item():.3f}")
print(f"Negative..... {predictions[0][0].item():.3f}")
# Fine-tuning is just as simple
from transformers import Trainer, TrainingArguments
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)
trainer.train()
```

上个月我用同样的模式微调了一个技术文档分类模型……两年前，这需要我花好几周的时间编写自定义的 PyTorch 代码……现在一个下午就搞定了。

## 3、LlamaIndex……因为 RAG 不应该这么难

你知道构建检索系统最让我沮丧的是什么吗？所有的一切。

毫无意义的分块策略。需要计算机科学学位才能配置的向量数据库。无法处理后续问题的查询引擎。代码总是变成一团乱麻。

LlamaIndex 解决了许多我之前甚至都没意识到的问题。

它可以处理来自任何来源的文档加载……PDF……网站……数据库……等等。它拥有智能分块功能，真正保留了上下文。它提供多种索引策略，查询引擎也极其强大。此外，它还能无缝整合不同的数据源。

```
from llama_index import VectorStoreIndex, SimpleDirectoryReader
from llama_index import ServiceContext
from llama_index.llms import OpenAI
from llama_index.embeddings import OpenAIEmbedding

# Load documents from a directory
documents = SimpleDirectoryReader("data").load_data()
# Configure the service
service_context = ServiceContext.from_defaults(
    llm=OpenAI(model="gpt-4", temperature=0.1),
    embed_model=OpenAIEmbedding()
)
# Create index
index = VectorStoreIndex.from_documents(
    documents,
    service_context=service_context
)
# Query with context awareness
query_engine = index.as_query_engine(
    similarity_top_k=3,
    response_mode="tree_summarize"
)
response = query_engine.query(
    "What are the key findings from the research papers?"
)
print(response)
# Follow-up questions just work
response2 = query_engine.query(
    "Can you elaborate on the methodology used?"
)
print(response2)
# Want to combine multiple indexes? Easy.....
from llama_index.composability import ComposableGraph
graph = ComposableGraph.from_indices(
    SimpleKeywordTableIndex,
    [index1, index2, index3],
    index_summaries=["Research papers", "Technical docs", "Blog posts"]
)
query_engine = graph.as_query_engine()
```

我第一次在客户项目中使用这个功能时，他们问我是否组建了团队。没有……我只是不再费力地进行自定义实现。

## 4、Gradio……制作不会让你尴尬的 AI 演示

这里有一个没人谈论的话题……大多数 AI 开发人员都不擅长构建界面。

我知道这一点，因为我曾经也是其中一员。我的演示程序看起来像是 1995 年的产物。命令行输出，没有错误处理，毫无视觉吸引力。想让利益相关者测试？想都别想。

Gradio 彻底改变了我的演示方式。

只需几行代码即可创建 Web 界面。自动生成 API。内置示例。真正有效的上传文件功能。而且界面专业，无需任何 CSS 噩梦。

```
import gradio as gr
from transformers import pipeline

# Load your model
sentiment_analyzer = pipeline("sentiment-analysis")
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
def analyze_text(text):
    sentiment = sentiment_analyzer(text)[0]
    return f"Sentiment..... {sentiment['label']} (confidence..... {sentiment['score']:.3f})"
def summarize_document(text):
    if len(text.split()) < 50:
        return "Text too short to summarize"
    summary = summarizer(text, max_length=130, min_length=30, do_sample=False)
    return summary[0]['summary_text']
# Create interface with multiple functions
with gr.Blocks() as demo:
    gr.Markdown("# AI Text Analysis Tool")
    
    with gr.Tab("Sentiment Analysis"):
        text_input = gr.Textbox(
            label="Enter text to analyze",
            placeholder="Type something here...",
            lines=3
        )
        sentiment_output = gr.Textbox(label="Result")
        sentiment_btn = gr.Button("Analyze Sentiment")
        sentiment_btn.click(
            fn=analyze_text,
            inputs=text_input,
            outputs=sentiment_output
        )
    
    with gr.Tab("Summarization"):
        doc_input = gr.Textbox(
            label="Enter document to summarize",
            placeholder="Paste your document here...",
            lines=10
        )
        summary_output = gr.Textbox(label="Summary")
        summary_btn = gr.Button("Generate Summary")
        summary_btn.click(
            fn=summarize_document,
            inputs=doc_input,
            outputs=summary_output
        )
    
    gr.Examples(
        examples=[
            ["This product exceeded my expectations!"],
            ["Terrible experience, would not recommend."]
        ],
        inputs=text_input
    )
demo.launch(share=True)
```

这段代码创建了一个专业的网页界面……包含标签页、示例和可分享的链接。我为每个客户都使用了这种模式。过去一年里，我从未见过这样的演示。

## 5、Weights & Bias……告别实验结果丢失的烦恼

我曾经丢失了三周的实验结果。

不是因为硬盘崩溃，也不是因为程序错误，而是因为我忘记了哪些超参数对应哪些结果……而我却像个疯子一样把所有数据都记录在一个文本文件里。

绝不再犯！

权重与偏差会自动追踪所有数据。每个指标、每个超参数、每个模型检查点，所有数据都会被记录。可视化图表能真正帮助你理解发生了什么。而且，你还能轻松比较数百个实验，而不会感到头疼。

```
import wandb
from transformers import Trainer, TrainingArguments
from transformers import AutoModelForSequenceClassification, AutoTokenizer

# Initialize tracking
wandb.init(
    project="text-classification",
    config={
        "learning_rate": 2e-5,
        "epochs": 3,
        "batch_size": 16,
        "model_name": "distilbert-base-uncased"
    }
)
config = wandb.config
# Load model
model = AutoModelForSequenceClassification.from_pretrained(
    config.model_name,
    num_labels=2
)
# Training arguments with W&B integration
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=config.epochs,
    per_device_train_batch_size=config.batch_size,
    learning_rate=config.learning_rate,
    logging_steps=10,
    evaluation_strategy="steps",
    eval_steps=50,
    save_steps=100,
    report_to="wandb"
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)
# Train and automatically log everything
trainer.train()
# Log custom metrics
wandb.log({
    "custom_metric": some_value,
    "validation_accuracy": accuracy
})
# Save model artifact
wandb.save("model.pth")
wandb.finish()
# Compare experiments later with W&B dashboard
```

控制面板显示了我运行过的所有实验。按超参数筛选。比较损失曲线。几秒钟内找到性能最佳的模型。

真希望五年前就发现了这个。

## 6、Streamlit……生产环境的 UI 不应该耗时数月

过去，构建生产环境界面意味着学习 React……搭建后端 API……处理状态管理……以及质疑自己的职业选择。

Streamlit 让您可以跳过所有这些步骤。

纯 Python 开发。无需 JavaScript、HTML 或 CSS。只需编写逻辑，即可获得一个可运行的 Web 应用。而且它看起来不像原型……而是可以直接用于生产环境。

```
import streamlit as st
from transformers import pipeline
import pandas as pd

st.set_page_config(page_title="AI Analysis Dashboard", layout="wide")
st.title("Real-time AI Analysis Dashboard")
# Sidebar configuration
with st.sidebar:
    st.header("Configuration")
    model_choice = st.selectbox(
        "Select Model",
        ["distilbert-base-uncased", "roberta-base", "albert-base-v2"]
    )
    confidence_threshold = st.slider(
        "Confidence Threshold",
        0.0, 1.0, 0.5
    )
# Load model with caching
@st.cache_resource
def load_model(model_name):
    return pipeline("sentiment-analysis", model=model_name)
classifier = load_model(model_choice)
# Main interface
tab1, tab2 = st.tabs(["Single Analysis", "Batch Analysis"])
with tab1:
    user_input = st.text_area("Enter text to analyze", height=150)
    
    if st.button("Analyze"):
        if user_input:
            with st.spinner("Analyzing..."):
                result = classifier(user_input)[0]
                
                col1, col2 = st.columns(2)
                with col1:
                    st.metric("Sentiment", result['label'])
                with col2:
                    st.metric("Confidence", f"{result['score']:.3f}")
                
                if result['score'] < confidence_threshold:
                    st.warning("Low confidence prediction")
        else:
            st.error("Please enter some text")
with tab2:
    uploaded_file = st.file_uploader("Upload CSV file", type=['csv'])
    
    if uploaded_file is not None:
        df = pd.read_csv(uploaded_file)
        st.write("Preview of data.....") 
        st.dataframe(df.head())
        
        if st.button("Analyze All"):
            results = []
            progress_bar = st.progress(0)
            
            for idx, text in enumerate(df['text']):
                result = classifier(text)[0]
                results.append(result)
                progress_bar.progress((idx + 1) / len(df))
            
            df['sentiment'] = [r['label'] for r in results]
            df['confidence'] = [r['score'] for r in results]
            
            st.success("Analysis complete!")
            st.dataframe(df)
            
            st.download_button(
                "Download Results",
                df.to_csv(index=False).encode('utf-8'),
                "analysis_results.csv",
                "text/csv"
            )
```

我用这个方法在两小时内构建了一个完整的分析仪表板。我的经理以为我为此工作了好几个星期。

## 7、FastAPI……轻松部署模型

最后一个框架……或许也是最重要的一个……它并非专门针对人工智能。但它改变了我部署模型的方式。

Flask 本来挺好用的。直到我需要异步支持。或者自动生成 API 文档。或者数据验证。或者 WebSocket 支持。或者现代机器学习 API 需要的其他数百种功能。

FastAPI 可以做到所有这些……而且它比 Python 中的任何其他框架都快。

```
from fastapi import FastAPI, File, UploadFile, HTTPException
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from transformers import pipeline
import uvicorn
from typing import List
import numpy as np

app = FastAPI(
    title="AI Model API",
    description="Production-ready ML model serving",
    version="1.0.0"
)
# Load model at startup
@app.on_event("startup")
async def load_models():
    global classifier, summarizer
    classifier = pipeline("sentiment-analysis")
    summarizer = pipeline("summarization")
# Request models with validation
class TextInput(BaseModel):
    text: str
    max_length: int = 130
    
class BatchInput(BaseModel):
    texts: List[str]
# Endpoints with automatic documentation
@app.post("/analyze/sentiment")
async def analyze_sentiment(input_data: TextInput):
    try:
        result = classifier(input_data.text)[0]
        return {
            "text": input_data.text,
            "sentiment": result['label'],
            "confidence": float(result['score'])
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
@app.post("/analyze/batch")
async def batch_analyze(input_data: BatchInput):
    try:
        results = []
        for text in input_data.texts:
            result = classifier(text)[0]
            results.append({
                "text": text,
                "sentiment": result['label'],
                "confidence": float(result['score'])
            })
        return {"results": results}
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
@app.post("/summarize")
async def summarize_text(input_data: TextInput):
    try:
        if len(input_data.text.split()) < 50:
            raise HTTPException(
                status_code=400,
                detail="Text too short for summarization"
            )
        
        summary = summarizer(
            input_data.text,
            max_length=input_data.max_length,
            min_length=30,
            do_sample=False
        )
        return {
            "original_text": input_data.text,
            "summary": summary[0]['summary_text']
        }
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))
@app.get("/health")
async def health_check():
    return {"status": "healthy", "models_loaded": True}
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

运行这段代码，你就能在 /docs 获得自动交互式文档……请求验证……错误处理……以及一个每秒可处理数千个请求的 API。

我上周就用这种模式将一个模型部署到了生产环境。从本地测试到生产环境，一天之内就完成了。

## 8、没人告诉你的模式

以下是我花了六个月时间从零开始构建一切后学到的东西……

最优秀的 AI 开发者并非能够实现所有算法的人，而是了解有哪些框架可用……以及如何有效地组合它们的人。

LangChain 用于 LLM 编排。Transformers 用于模型访问。LlamaIndex 用于数据检索。Gradio 用于快速演示。Streamlit 用于生产环境 UI。Weights & Biases 用于实验跟踪。FastAPI 用于部署。

每个框架都能比你独自解决一个更棘手的问题。

使用它们，组合它们，打造一年前还无法想象的东西。

别再浪费时间重复发明轮子了。

---

原文链接：[I Wasted 6 Months Building AI Models Before Learning These 7 Frameworks](https://pub.towardsai.net/i-wasted-6-months-building-ai-models-before-learning-these-7-frameworks-8acb02e9193b?ref=hubwiz.com)

汇智网翻译整理，转载请标明出处