from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import numpy as np
# 情景：我们要做一个中文情感分析应用
# 选择模型考虑因素：
# 1. 任务：情感分析 → 序列分类
# 2. 语言：中文 → 需要中文预训练模型
# 3. 资源：希望快速响应 → 选择轻量模型
# 从 Hugging Face Hub 选择模型
model_name = "bert-base-chinese"  # 基础中文BERT模型
print(f"正在加载模型: {model_name}")
print("这个模型适合处理中文文本的分类任务")
# 加载分词器 - 为什么需要分词器？
# 中文文本 → 模型理解的数字ID
tokenizer = AutoTokenizer.from_pretrained(model_name)
# 加载模型 - 为什么用 AutoModelForSequenceClassification？
# 因为我们要做分类任务，这个类在BERT基础上添加了分类头
model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=3,  # 3个分类：正面、负面、中性
    id2label={0: "负面", 1: "中性", 2: "正面"},  # ID到标签的映射
    label2id={"负面": 0, "中性": 1, "正面": 2}   # 标签到ID的映射
)
print("模型加载完成！")
print(f"模型架构: {type(model).__name__}")
print(f"分类类别数: {model.num_labels}")

# 输入文本 - 用户评论
texts = [
    "这个产品非常好用，我非常喜欢！",
    "质量很差，完全不推荐购买。",
    "还可以，没什么特别的感觉。"
]
print("原始文本:", texts)
# 分词处理 - 逐步分析
print("\n=== 分词过程详解 ===")
for i, text in enumerate(texts):
    print(f"\n文本 {i+1}: '{text}'")
    
    # 1. 基础分词
    tokens = tokenizer.tokenize(text)
    print(f"分词结果: {tokens}")
    
    # 2. 转换为ID
    input_ids = tokenizer.encode(text)
    print(f"输入ID: {input_ids}")
    
    # 3. 完整预处理（生产环境使用）
    inputs = tokenizer(
        text,
        padding=True,        # 填充到相同长度
        truncation=True,     # 截断到模型最大长度
        max_length=512,      # 最大长度
        return_tensors="pt"  # 返回PyTorch张量
    )
    
    print(f"输入字典结构: {list(inputs.keys())}")
    print(f"input_ids形状: {inputs['input_ids'].shape}")
    print(f"attention_mask形状: {inputs['attention_mask'].shape}")
# 批量处理所有文本
batch_inputs = tokenizer(
    texts,
    padding=True,
    truncation=True, 
    max_length=128,
    return_tensors="pt"
)
print(f"\n批量输入形状:")
print(f"Input IDs: {batch_inputs['input_ids'].shape}")
print(f"Attention Mask: {batch_inputs['attention_mask'].shape}")

# 模型推理 - 详细步骤
print("\n=== 模型推理过程 ===")
# 设置为评估模式（关闭dropout等训练专用层）
model.eval()
# 不计算梯度，节省内存和计算资源
with torch.no_grad():
    # 模型前向传播
    outputs = model(**batch_inputs)
    
    print("模型输出类型:", type(outputs))
    print("输出属性:", outputs.keys())
    
    # 获取logits（未归一化的分数）
    logits = outputs.logits
    print(f"Logits形状: {logits.shape}")  # [批次大小, 类别数]
    
    # 转换为概率
    probabilities = torch.nn.functional.softmax(logits, dim=-1)
    print(f"概率分布: {probabilities}")
    
    # 获取预测结果
    predictions = torch.argmax(logits, dim=-1)
    print(f"预测类别ID: {predictions}")
print("\n=== 结果解析 ===")
# 详细解析每个预测结果
for i, (text, pred_id, prob) in enumerate(zip(texts, predictions, probabilities)):
    predicted_label = model.config.id2label[pred_id.item()]
    confidence = prob[pred_id].item()
    
    print(f"\n文本 {i+1}: '{text}'")
    print(f"预测情感: {predicted_label}")
    print(f"置信度: {confidence:.3f}")
    print(f"所有类别概率: { {model.config.id2label[j]: prob[j].item():.3f} for j in range(len(prob)) }")

from transformers import AutoTokenizer
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
text = "Hello, my dog is cute."
inputs = tokenizer(text, padding=True, truncation=True, return_tensors="pt") # 返回PyTorch张量
# 如果是TensorFlow，则使用 return_tensors="tf"
print(inputs)
# {
#   'input_ids': tensor([[ 101, 7592, 1010, 2026, 3899, 2003, 10140, 1012,  102]]),
#   'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0]]),
#   'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1]])
# }

from transformers import AutoModelForSequenceClassification
import torch
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
with torch.no_grad():
    outputs = model(**inputs)
logits = outputs.logits
print(logits)
# tensor([[ 0.1, -0.2]]) # 假设是二分类，输出两个类别的原始分数
# 通过 softmax 得到概率
probabilities = torch.softmax(logits, dim=1)
print(probabilities)
# tensor([[0.5744, 0.4256]])

predicted_class_id = logits.argmax().item()
model.config.id2label[predicted_class_id] # 通过模型配置将id映射回标签名，例如 ‘POSITIVE’

from transformers import pipeline
# 创建命名实体识别管道
ner = pipeline('ner')
# 内部步骤：
# 1. 自动选择默认模型 
# 2. 加载对应的 tokenizer
# 3. 加载对应的模型
# 4. 设置任务特定的后处理器
# 对文本进行命名实体识别
result = ner('Hugging Face is a company based in New York.')
for entity in result:
    print(entity)

classifier = pipeline("text-classification", model="模型名称")

from transformers import pipeline
# 最基本的初始化
classifier = pipeline(
    task="sentiment-analysis",           # 必需：任务类型
    model="distilbert-base-uncased-finetuned-sst-2-english",  # 可选：模型名称
    tokenizer=None,                      # 可选：分词器（默认使用模型的）
    framework=None,                      # 可选：框架 "pt" 或 "tf"
    device=None,                         # 可选：设备 -1(CPU), 0(GPU0), 1(GPU1)
    device_map="auto",                   # 可选：多GPU设备映射
)

# 设备管理参数
pipe = pipeline(
    "text-generation",
    device=0,                           # 使用第一个GPU，-1表示CPU
    device_map="auto",                  # 自动在多GPU间分配模型层
    # device_map="balanced"             # 平衡分配到所有GPU
    # device_map={"transformer.h.0": 0, "transformer.h.1": 1}  # 手动指定层到设备
)
# 模型精度与内存优化
pipe = pipeline(
    "text2text-generation",
    model="t5-base",
    torch_dtype=torch.float16,          # 半精度，减少内存使用
    # torch_dtype=torch.bfloat16,       # Brain Float 16，在某些硬件上性能更好
    low_cpu_mem_usage=True,             # 减少模型加载时的CPU内存占用
    trust_remote_code=True,             # 信任自定义模型代码
)

pipe = pipeline(
    "feature-extraction",
    batch_size=32,                      # 批次大小，影响内存使用和速度
    model_kwargs={                      # 传递给模型初始化的参数
        "output_attentions": True,
        "output_hidden_states": True
    }
)

from transformers import pipeline
# 1. 文本分类 Pipeline
print("=== 文本分类 ===")
classifier = pipeline("text-classification", 
                     model="bert-base-chinese")
result = classifier("这部电影的剧情非常精彩，演员表演出色！")
print(f"情感分析结果: {result}")
# 2. 文本生成 Pipeline
print("\n=== 文本生成 ===")
generator = pipeline("text-generation", 
                    model="gpt2",
                    tokenizer="gpt2")
result = generator("人工智能的未来发展", 
                  max_length=50,
                  num_return_sequences=1)
print(f"生成文本: {result[0]['generated_text']}")
# 3. 命名实体识别 Pipeline
print("\n=== 命名实体识别 ===")
ner = pipeline("ner",
              model="dslim/bert-base-NER",
              aggregation_strategy="simple")
result = ner("马云在杭州创办了阿里巴巴集团。")
print("识别到的实体:")
for entity in result:
    print(f"- {entity['word']} ({entity['entity_group']}) - 置信度: {entity['score']:.3f}")
# 4. 问答系统 Pipeline
print("\n=== 问答系统 ===")
qa = pipeline("question-answering",
             model="bert-large-uncased-whole-word-masking-finetuned-squad")
context = """
华为技术有限公司成立于1987年，总部位于中国深圳市。
创始人任正非最初投资了2.1万元人民币创建了这家公司。
华为是全球领先的信息与通信技术解决方案提供商。
"""
question = "华为公司是哪一年成立的？"
result = qa(question=question, context=context)
print(f"问题: {question}")
print(f"答案: {result['answer']}")
print(f"置信度: {result['score']:.3f}")
# 5. 文本摘要 Pipeline
print("\n=== 文本摘要 ===")
summarizer = pipeline("summarization",
                     model="facebook/bart-large-cnn")
long_text = """
人工智能是计算机科学的一个分支，它企图了解智能的实质，
并生产出一种新的能以人类智能相似的方式做出反应的智能机器，
该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。
人工智能从诞生以来，理论和技术日益成熟，应用领域也不断扩大，
可以设想，未来人工智能带来的科技产品，将会是人类智慧的容器。
"""
result = summarizer(long_text, 
                   max_length=50, 
                   min_length=25,
                   do_sample=False)
print(f"原文长度: {len(long_text)} 字符")
print(f"摘要结果: {result[0]['summary_text']}")
# 6. 翻译 Pipeline
print("\n=== 机器翻译 ===")
# 英译中
translator = pipeline("translation", 
                     model="Helsinki-NLP/opus-mt-en-zh")
result = translator("Hello, how are you today? I hope you're doing well.")
print(f"英文原文: Hello, how are you today?")
print(f"中文翻译: {result[0]['translation_text']}")
# 7. 特征提取 Pipeline
print("\n=== 文本特征提取 ===")
feature_extractor = pipeline("feature-extraction",
                           model="bert-base-uncased")
result = feature_extractor("这是一个示例文本")
print(f"特征形状: {np.array(result).shape}")  # [序列长度, 隐藏维度]

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import RobertaTokenizer, RobertaForSequenceClassification
from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
model_name = "bert-base-uncased"  # 可能是 "roberta-base" 或 "distilbert-base-uncased"
if "bert" in model_name:
    tokenizer = BertTokenizer.from_pretrained(model_name)
    model = BertForSequenceClassification.from_pretrained(model_name)
elif "roberta" in model_name:
    tokenizer = RobertaTokenizer.from_pretrained(model_name)
    model = RobertaForSequenceClassification.from_pretrained(model_name)
elif "distilbert" in model_name:
    tokenizer = DistilBertTokenizer.from_pretrained(model_name)
    model = DistilBertForSequenceClassification.from_pretrained(model_name)

from transformers import AutoTokenizer, AutoModelForSequenceClassification
model_name = "bert-base-uncased"  # 也可以是 "roberta-base" 或 "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
text = "Hello, world!"
encoded_input = tokenizer(text, padding=True, truncation=True, return_tensors="pt")

from transformers import AutoConfig
config = AutoConfig.from_pretrained("bert-base-uncased")
print(config)

from transformers import AutoModel
model = AutoModel.from_pretrained("bert-base-uncased")

from transformers import AutoModelForSequenceClassification
# 加载分类模型
model = AutoModelForSequenceClassification.from_pretrained(
    "uer/roberta-base-finetuned-dianping-chinese"
)
# 推理示例
inputs = tokenizer("今天的天气特别晴朗!", return_tensors="pt")
outputs = model(**inputs)
# 输出是 logits，需要 softmax 转换为概率
logits = outputs.logits
probabilities = torch.softmax(logits, dim=-1)
print(f"分类概率: {probabilities}")

from transformers import AutoModelForTokenClassification
# 加载 NER 模型
model = AutoModelForTokenClassification.from_pretrained(
    "uer/roberta-base-finetuned-dianping-chinese"
)
# NER 推理
text = "今天天气晴好，我们去爬山."
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)
predictions = torch.argmax(outputs.logits, dim=-1)
tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
print("Token 级别预测:")
for token, pred in zip(tokens, predictions[0]):
    print(f"{token:15} -> {model.config.id2label[pred.item()]}")

from transformers import AutoModelForQuestionAnswering
from transformers import AutoTokenizer
import torch
# 基本用法
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
# 加载 QA 模型
model = AutoModelForQuestionAnswering.from_pretrained(
    "distilbert-base-cased-distilled-squad"
)
# 问答示例
question = "What is the capital of France?"
context = "Paris is the capital and most populous city of France."
inputs = tokenizer(question, context, return_tensors="pt")
outputs = model(**inputs)
start_scores = outputs.start_logits
end_scores = outputs.end_logits
# 找到答案的起始和结束位置
start_idx = torch.argmax(start_scores)
end_idx = torch.argmax(end_scores) + 1
answer_tokens = inputs["input_ids"][0][start_idx:end_idx]
answer = tokenizer.decode(answer_tokens)
print(f"问题: {question}")
print(f"答案: {answer}")

from transformers import AutoModelForCausalLM
from transformers import AutoTokenizer
import torch
# 基本用法
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
# 加载文本生成模型
model = AutoModelForCausalLM.from_pretrained("gpt2")
# 文本生成
input_text = "The future of artificial intelligence"
inputs = tokenizer(input_text, return_tensors="pt")
# 生成文本
outputs = model.generate(
    inputs["input_ids"],
    max_length=100,
    num_return_sequences=1,
    temperature=0.7,
    do_sample=True
)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"生成文本: {generated_text}")

from transformers import AutoModelForCausalLM
from transformers import AutoTokenizer
import torch
# 基本用法
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
# 加载文本生成模型
model = AutoModelForCausalLM.from_pretrained("gpt2")
# 文本生成
input_text = "The future of artificial intelligence"
inputs = tokenizer(input_text, return_tensors="pt")
# 生成文本
outputs = model.generate(
    inputs["input_ids"],
    max_length=100,
    num_return_sequences=1,
    temperature=0.7,
    do_sample=True
)
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"生成文本: {generated_text}")

from transformers import AutoModelForSeq2SeqLM
from transformers import AutoTokenizer
import torch
# 基本用法
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
# 加载序列到序列模型
model = AutoModelForSeq2SeqLM.from_pretrained("t5-small")
# 摘要示例
text = """
The Hugging Face Transformers library provides thousands of pretrained models 
to perform tasks on different modalities such as text, vision, and audio.
"""
inputs = tokenizer("summarize: " + text, return_tensors="pt", max_length=512, truncation=True)
outputs = model.generate(
    inputs["input_ids"],
    max_length=150,
    min_length=40,
    length_penalty=2.0,
    num_beams=4,
    early_stopping=True
)
summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"原文: {text}")
print(f"摘要: {summary}")

from transformers import AutoModel, AutoTokenizer
import time
from typing import List, Dict
class ModelBenchmark:
    """模型性能基准测试"""
    
    def __init__(self):
        self.results = {}
    
    def benchmark_models(self, model_names: List[str], text: str, num_runs: int = 10):
        """对多个模型进行基准测试"""
        
        for model_name in model_names:
            print(f"\n🧪 测试模型: {model_name}")
            
            try:
                # 加载模型和分词器
                tokenizer = AutoTokenizer.from_pretrained(model_name)
                model = AutoModel.from_pretrained(model_name)
                
                # 预热
                inputs = tokenizer(text, return_tensors="pt")
                _ = model(**inputs)
                
                # 计时推理
                start_time = time.time()
                for _ in range(num_runs):
                    inputs = tokenizer(text, return_tensors="pt")
                    outputs = model(**inputs)
                end_time = time.time()
                
                avg_time = (end_time - start_time) / num_runs
                self.results[model_name] = {
                    'avg_time': avg_time,
                    'throughput': 1 / avg_time,
                    'success': True
                }
                
                print(f" 平均推理时间: {avg_time:.4f}s")
                print(f" 吞吐量: {1/avg_time:.2f} requests/s")
                
            except Exception as e:
                print(f" 测试失败: {e}")
                self.results[model_name] = {'success': False, 'error': str(e)}
        
        return self.results
# 使用示例
benchmark = ModelBenchmark()
models = ["bert-base-uncased", "distilbert-base-uncased", "roberta-base"]
text = "This is a sample text for benchmarking transformer models."
results = benchmark.benchmark_models(models, text)