企业官网建设流程全解析

1. BERT模型基础解析

BERT（Bidirectional Encoder Representations from Transformers）是自然语言处理领域里程碑式的突破。作为首个真正实现双向上下文理解的预训练语言模型，它彻底改变了传统NLP任务的解决方式。想象一下，当人类阅读"银行"这个词时，我们会根据上下文自动区分"河岸"和"金融机构"的不同含义——这正是BERT赋予计算机的能力。

1.1 核心架构原理

BERT基于Transformer编码器堆叠而成，其核心创新在于：

• 双向上下文编码：与传统的单向语言模型不同，BERT通过掩码语言模型(MLM)任务，同时学习左右两侧的上下文信息。例如在预测"cloud"时，它能利用"Microsoft"和"Azure"的双向信息。

• 注意力机制：12层Transformer编码器（Base版本）每层包含12个自注意力头，可自动学习不同位置词汇间的关联权重。这种机制让模型能动态关注句子中最重要的部分。

• 预训练+微调范式：先在无标注大数据（如Wikipedia）上进行预训练，再针对具体任务用少量标注数据微调。这种迁移学习方式大幅提升了小数据场景下的表现。

1.2 输入输出处理

BERT的输入需要特殊处理才能被模型理解：

from transformers import BertTokenizer tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') text = "Natural language processing is fascinating!" inputs = tokenizer(text, return_tensors="pt") print(inputs) # 输出示例： # { # 'input_ids': tensor([[ 101, 3019, 2653, 6364, 2003, 10471, 999, 102]]), # 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0]]), # 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1]]) # }

关键处理步骤：

1. Tokenization：将文本拆分为WordPiece子词单元
2. 添加特殊标记：
   • [CLS]（分类任务使用）
   • [SEP]（句子分隔符）
3. 生成注意力掩码：区分真实token与padding
4. 段标识（对于句子对任务）

注意：BERT的词汇表大小约3万，未登录词会被拆分为子词。例如"unhappiness"→"un", "##happy", "##ness"

2. Hugging Face生态实战

2.1 环境配置

推荐使用conda创建Python 3.8+环境：

conda create -n bert python=3.8 conda activate bert pip install transformers torch sentencepiece

对于GPU加速，需额外安装对应版本的CUDA工具包。可通过nvidia-smi查看支持的CUDA版本，然后安装匹配的PyTorch：

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu113

2.2 管道(Pipeline)快速入门

Hugging Face提供的pipeline API让BERT应用变得极其简单：

from transformers import pipeline # 情感分析 classifier = pipeline("sentiment-analysis") result = classifier("I'm thrilled to learn about BERT!") print(result) # [{'label': 'POSITIVE', 'score': 0.9993}] # 问答系统 qa_pipeline = pipeline("question-answering") answer = qa_pipeline({ 'context': "BERT is a language model developed by Google in 2018", 'question': "Who created BERT?" }) print(answer) # {'answer': 'Google', 'score': 0.98}

常用预置管道：

• "text-classification"：文本分类
• "ner"：命名实体识别
• "text-generation"：文本生成
• "summarization"：文本摘要

2.3 自定义模型加载

对于需要精细控制的场景，可以分别加载tokenizer和model：

from transformers import AutoTokenizer, AutoModelForSequenceClassification model_name = "bert-base-uncased" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2) # 处理输入 inputs = tokenizer("This is a sample text", return_tensors="pt") outputs = model(**inputs) logits = outputs.logits

3. 生产级情感分析系统实现

3.1 完整类实现

import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification class SentimentAnalyzer: def __init__(self, model_path="distilbert-base-uncased-finetuned-sst-2-english"): self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.tokenizer = AutoTokenizer.from_pretrained(model_path) self.model = AutoModelForSequenceClassification.from_pretrained(model_path).to(self.device) self.labels = ["NEGATIVE", "POSITIVE"] def analyze(self, texts, batch_size=8): # 批量处理提高GPU利用率 results = [] for i in range(0, len(texts), batch_size): batch = texts[i:i+batch_size] inputs = self.tokenizer( batch, padding=True, truncation=True, max_length=512, return_tensors="pt" ).to(self.device) with torch.no_grad(): outputs = self.model(**inputs) probs = torch.nn.functional.softmax(outputs.logits, dim=-1) for j, prob in enumerate(probs): results.append({ "text": batch[j], "prediction": self.labels[prob.argmax().item()], "confidence": prob.max().item(), "details": dict(zip(self.labels, prob.tolist())) }) return results

3.2 性能优化技巧

1. 动态批处理：根据文本长度自动调整batch_size

def calculate_batch_size(texts, max_tokens=4096): lengths = [len(t.split()) for t in texts] batch_size = 0 total = 0 for l in lengths: if total + l > max_tokens: break total += l batch_size += 1 return batch_size or 1

2. 混合精度训练：减少显存占用

from torch.cuda.amp import autocast with autocast(): outputs = model(**inputs)

3. 缓存机制：对重复查询使用LRU缓存

from functools import lru_cache @lru_cache(maxsize=1000) def cached_analyze(text): return analyzer.analyze([text])[0]

3.3 常见问题排查

问题1：出现CUDA out of memory错误

• 解决方案：减小batch_size或使用梯度累积

# 梯度累积示例 for i, batch in enumerate(batches): outputs = model(**batch) loss = outputs.loss / accumulation_steps loss.backward() if (i+1) % accumulation_steps == 0: optimizer.step() optimizer.zero_grad()

问题2：预测结果置信度始终接近0.5

• 可能原因：输入文本与预训练领域不匹配
• 解决方案：进行领域适配训练

from transformers import Trainer, TrainingArguments training_args = TrainingArguments( output_dir='./results', num_train_epochs=3, per_device_train_batch_size=16, evaluation_strategy="epoch" ) trainer = Trainer( model=model, args=training_args, train_dataset=train_dataset, eval_dataset=val_dataset ) trainer.train()

4. 命名实体识别高级应用

4.1 定制化NER实现

class NERSystem: ENTITY_TYPES = { 'PER': '人物', 'ORG': '组织', 'LOC': '地点', 'MISC': '其他' } def __init__(self): self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.tokenizer = AutoTokenizer.from_pretrained("dslim/bert-base-NER") self.model = AutoModelForTokenClassification.from_pretrained("dslim/bert-base-NER").to(self.device) def postprocess(self, tokens, predictions): entities = [] current_entity = None for token, pred in zip(tokens, predictions): label = self.model.config.id2label[pred.item()] if label.startswith('B-'): if current_entity: entities.append(current_entity) current_entity = { 'type': self.ENTITY_TYPES.get(label[2:], label[2:]), 'text': token.replace('##', '') } elif label.startswith('I-') and current_entity: current_entity['text'] += token.replace('##', '') elif label == 'O' and current_entity: entities.append(current_entity) current_entity = None if current_entity: entities.append(current_entity) return entities def extract_entities(self, text): inputs = self.tokenizer(text, return_tensors="pt").to(self.device) with torch.no_grad(): outputs = self.model(**inputs) predictions = torch.argmax(outputs.logits, dim=-1)[0] tokens = self.tokenizer.convert_ids_to_tokens(inputs["input_ids"][0]) return self.postprocess(tokens, predictions)

4.2 实体链接实战

将识别出的实体链接到知识库：

from wikidata.client import Client class EntityLinker: def __init__(self): self.wd = Client() self.cache = {} def link_entity(self, entity_text, entity_type): if entity_text in self.cache: return self.cache[entity_text] # 根据类型构建查询条件 if entity_type == '人物': instance_of = self.wd.get('Q5') # human elif entity_type == '组织': instance_of = self.wd.get('Q43229') # organization else: instance_of = None # 实际应用中这里应调用Wikidata API进行查询 result = { 'id': 'Q12345', 'label': entity_text, 'description': f"{entity_type} entity", 'url': f"https://www.wikidata.org/wiki/Q12345" } self.cache[entity_text] = result return result # 使用示例 ner = NERSystem() linker = EntityLinker() text = "Apple announced new products in Cupertino" entities = ner.extract_entities(text) for entity in entities: linked = linker.link_entity(entity['text'], entity['type']) print(f"{entity['text']} ({entity['type']}) → {linked['url']}")

4.3 性能优化对比

实际选择建议：根据业务需求平衡精度与速度。对实时性要求高的场景可考虑知识蒸馏得到的轻量模型。

5. 模型微调实战指南

5.1 数据准备

构建自定义数据集示例：

from datasets import Dataset import pandas as pd # 情感分析数据集示例 data = { 'text': [ "This product works great!", "Terrible customer service", "Average performance, not worth the price" ], 'label': [1, 0, 0] # 1=POSITIVE, 0=NEGATIVE } dataset = Dataset.from_pandas(pd.DataFrame(data)) # 数据集拆分 dataset = dataset.train_test_split(test_size=0.2)

5.2 训练配置

from transformers import TrainingArguments, Trainer training_args = TrainingArguments( output_dir="./results", evaluation_strategy="steps", eval_steps=500, learning_rate=2e-5, per_device_train_batch_size=16, per_device_eval_batch_size=16, num_train_epochs=3, weight_decay=0.01, logging_dir='./logs', logging_steps=100, save_steps=1000, fp16=True # 启用混合精度训练 ) def compute_metrics(eval_pred): predictions, labels = eval_pred predictions = np.argmax(predictions, axis=1) return {"accuracy": (predictions == labels).mean()} trainer = Trainer( model=model, args=training_args, train_dataset=dataset["train"], eval_dataset=dataset["test"], compute_metrics=compute_metrics )

5.3 高级训练技巧

1. 渐进式学习率预热：

training_args = TrainingArguments( warmup_steps=500, warmup_ratio=0.1, ... )

2. 动态填充：

from transformers import DataCollatorWithPadding data_collator = DataCollatorWithPadding( tokenizer=tokenizer, padding='longest' ) trainer = Trainer( data_collator=data_collator, ... )

3. 早停机制：

from transformers import EarlyStoppingCallback trainer = Trainer( callbacks=[EarlyStoppingCallback(early_stopping_patience=3)], ... )

5.4 模型评估与部署

评估训练好的模型：

eval_results = trainer.evaluate() print(f"Validation accuracy: {eval_results['eval_accuracy']:.2%}") # 保存模型 trainer.save_model("./custom_bert_model") # 转换为ONNX格式便于部署 from transformers.convert_graph_to_onnx import convert convert( framework="pt", model="./custom_bert_model", output="./model.onnx", opset=12 )

实际部署时建议使用Triton推理服务器或FastAPI构建服务：

from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class TextRequest(BaseModel): text: str @app.post("/analyze") async def analyze(request: TextRequest): inputs = tokenizer(request.text, return_tensors="pt") outputs = model(**inputs) return {"sentiment": "POSITIVE" if outputs.logits.argmax() == 1 else "NEGATIVE"}

6. 前沿扩展与优化方向

6.1 模型压缩技术

1. 知识蒸馏：

from transformers import DistilBertForSequenceClassification teacher = AutoModelForSequenceClassification.from_pretrained("bert-large-uncased") student = DistilBertForSequenceClassification.from_pretrained("distilbert-base-uncased") # 使用蒸馏训练器 trainer = Trainer( model=student, teacher=teacher, ... )

2. 量化压缩：

from transformers import BertForSequenceClassification, BertConfig # 动态量化 quantized_model = torch.quantization.quantize_dynamic( model, {torch.nn.Linear}, dtype=torch.qint8 ) # 静态量化需要校准数据 calibration_dataset = ... # 准备校准数据集 quantized_model = prepare(model) quantized_model = calibrate(quantized_model, calibration_dataset) quantized_model = convert(quantized_model)

6.2 多语言与领域适配

加载多语言BERT：

multilingual_bert = AutoModel.from_pretrained("bert-base-multilingual-cased")

领域适配训练建议：

1. 继续预训练（Continue Pretraining）：

from transformers import BertForMaskedLM mlm_model = BertForMaskedLM.from_pretrained("bert-base-uncased") trainer = Trainer( model=mlm_model, args=TrainingArguments( per_device_train_batch_size=32, max_steps=10000, save_steps=2000, output_dir="./domain_bert" ), train_dataset=domain_corpus # 领域特定文本数据集 ) trainer.train()

6.3 模型解释性分析

使用Captum库进行注意力可视化：

from captum.attr import LayerIntegratedGradients def forward_func(input_ids, attention_mask): return model(input_ids, attention_mask).logits lig = LayerIntegratedGradients(forward_func, model.bert.embeddings) attributions = lig.attribute( inputs=input_ids, baselines=baseline_ids, additional_forward_args=(attention_mask,) ) # 可视化 import matplotlib.pyplot as plt plt.imshow(attributions[0].sum(dim=-1).detach().numpy()) plt.show()

7. 生产环境最佳实践

7.1 性能监控指标

建议监控的关键指标：

7.2 自动扩展策略

Kubernetes部署示例配置：

apiVersion: apps/v1 kind: Deployment metadata: name: bert-service spec: replicas: 3 strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 0 template: spec: containers: - name: bert image: bert-api:latest resources: limits: nvidia.com/gpu: 1 requests: cpu: 2 memory: 8Gi readinessProbe: httpGet: path: /health port: 8000 initialDelaySeconds: 10 periodSeconds: 5 --- apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: name: bert-hpa spec: scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: bert-service minReplicas: 2 maxReplicas: 10 metrics: - type: Resource resource: name: cpu target: type: Utilization averageUtilization: 60

7.3 安全防护措施

1. 输入净化：

import re def sanitize_text(text): # 移除特殊字符 text = re.sub(r'[^\w\s]', '', text) # 限制最大长度 return text[:1000]

2. 速率限制（使用FastAPI中间件）：

from fastapi import Request from fastapi.middleware import Middleware from slowapi import Limiter from slowapi.util import get_remote_address limiter = Limiter(key_func=get_remote_address) app.state.limiter = limiter @app.middleware("http") async def rate_limit_middleware(request: Request, call_next): if request.url.path.startswith("/api"): # 每个IP每分钟100次请求 if await limiter.check(f"{get_remote_address(request)}:100/60"): return await call_next(request) return JSONResponse({"error": "Too many requests"}, status_code=429) return await call_next(request)

3. 模型水印：在输出中加入隐蔽标识，便于追踪泄露模型

8. 典型问题解决方案

8.1 长文本处理策略

BERT原生最大长度限制为512token，处理长文档的方案：

1. 滑动窗口法：

def chunk_text(text, window_size=400, stride=200): tokens = tokenizer.tokenize(text) chunks = [] for i in range(0, len(tokens), stride): chunk = tokens[i:i+window_size] chunks.append(tokenizer.convert_tokens_to_string(chunk)) return chunks

2. 层次化处理：

• 先用BERT处理每个句子
• 再用LSTM/Transformer聚合句子级表示

3. 使用长文本变体模型：

longformer = AutoModel.from_pretrained("allenai/longformer-base-4096")

8.2 类别不平衡处理

1. 加权损失函数：

from torch.nn import CrossEntropyLoss weights = torch.tensor([1.0, 5.0]) # 给少数类更高权重 loss_fct = CrossEntropyLoss(weight=weights.to(device))

2. 过采样/欠采样：

from imblearn.over_sampling import RandomOverSampler ros = RandomOverSampler() X_resampled, y_resampled = ros.fit_resample( np.array(features).reshape(-1, 1), labels )

3. Focal Loss：

from transformers import Trainer import torch.nn as nn class FocalLossTrainer(Trainer): def compute_loss(self, model, inputs, return_outputs=False): labels = inputs.pop("labels") outputs = model(**inputs) logits = outputs.logits # Focal Loss实现 ce_loss = nn.CrossEntropyLoss(reduction='none')(logits, labels) pt = torch.exp(-ce_loss) loss = ((1 - pt) ** self.args.focal_alpha * ce_loss).mean() return (loss, outputs) if return_outputs else loss

8.3 领域迁移技巧

1. 对抗训练：

from transformers import Trainer import torch class AdversarialTrainer(Trainer): def training_step(self, model, inputs): # 常规前向传播 loss = super().training_step(model, inputs) # 对抗扰动 embeddings = model.get_input_embeddings() input_ids = inputs["input_ids"] inputs_embeds = embeddings(input_ids) inputs_embeds.requires_grad_() adv_outputs = model(inputs_embeds=inputs_embeds) adv_loss = adv_outputs.loss grad = torch.autograd.grad(adv_loss, inputs_embeds)[0] # 应用扰动 perturb = 0.01 * grad / (grad.norm(dim=-1, keepdim=True) + 1e-12) inputs_embeds = inputs_embeds + perturb # 计算最终损失 outputs = model(inputs_embeds=inputs_embeds.detach()) return 0.8 * loss + 0.2 * outputs.loss

2. 领域自适应预训练：

from transformers import BertForMaskedLM, LineByLineTextDataset dataset = LineByLineTextDataset( tokenizer=tokenizer, file_path="./domain_text.txt", block_size=128 ) model = BertForMaskedLM.from_pretrained("bert-base-uncased") trainer = Trainer( model=model, args=TrainingArguments( output_dir="./domain_bert", overwrite_output_dir=True, num_train_epochs=10, per_device_train_batch_size=32, save_steps=10_000, save_total_limit=2 ), data_collator=DataCollatorForLanguageModeling( tokenizer=tokenizer, mlm=True, mlm_probability=0.15 ), train_dataset=dataset ) trainer.train()

9. 模型优化对比实验

9.1 量化对比测试

我们在IMDB情感分析任务上测试了不同优化技术的效果：

9.2 批处理效率测试

不同批处理大小对GPU利用率的影响：

最佳实践：根据业务延迟要求选择最大可接受的batch_size

10. 扩展应用场景

10.1 多模态应用

结合视觉信息的BERT变体：

from transformers import BertModel, ViTModel class MultimodalModel(torch.nn.Module): def __init__(self): super().__init__() self.text_encoder = BertModel.from_pretrained("bert-base-uncased") self.image_encoder = ViTModel.from_pretrained("google/vit-base-patch16-224") self.classifier = torch.nn.Linear(768*2, 2) def forward(self, input_ids, attention_mask, pixel_values): text_features = self.text_encoder( input_ids=input_ids, attention_mask=attention_mask ).pooler_output image_features = self.image_encoder( pixel_values=pixel_values ).last_hidden_state[:, 0, :] combined = torch.cat([text_features, image_features], dim=-1) return self.classifier(combined)

10.2 序列生成任务

使用BERT进行文本生成：

from transformers import BertLMHeadModel, BertTokenizer tokenizer = BertTokenizer.from_pretrained("bert-base-uncased") model = BertLMHeadModel.from_pretrained("bert-base-uncased") input_text = "The future of AI is" input_ids = tokenizer.encode(input_text, return_tensors="pt") # 使用核采样(nucleus sampling) output = model.generate( input_ids, max_length=50, do_sample=True, top_p=0.92, top_k=0, temperature=0.7 ) print(tokenizer.decode(output[0], skip_special_tokens=True))

10.3 知识增强型BERT

结合外部知识库：

class KnowledgeEnhancedBERT(torch.nn.Module): def __init__(self): super().__init__() self.bert = BertModel.from_pretrained("bert-base-uncased") self.knowledge_embed = torch.nn.Embedding(10000, 768) # 假设知识库有1w条 self.combine = torch.nn.Linear(768*2, 768) def forward(self, input_ids, knowledge_ids): text_emb = self.bert(input_ids).last_hidden_state[:, 0, :] know_emb = self.knowledge_embed(knowledge_ids) combined = self.combine(torch.cat([text_emb, know_emb], dim=-1)) return combined

11. 模型解释与可解释性

11.1 注意力可视化

import matplotlib.pyplot as plt def plot_attention(text, layer=0, head=0): inputs = tokenizer(text, return_tensors="pt") outputs = model(**inputs, output_attentions=True) attention = outputs.attentions[layer][0, head].detach().numpy() tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0]) fig, ax = plt.subplots(figsize=(10, 6)) im = ax.imshow(attention, cmap='viridis') ax.set_xticks(range(len(tokens))) ax.set_yticks(range(len(tokens))) ax.set_xticklabels(tokens, rotation=90) ax.set_yticklabels(tokens) plt.colorbar(im) plt.title(f"Layer {layer+1} Head {head+1} Attention") plt.show() plot_attention("The cat sat on the mat")

11.2 特征重要性分析

使用SHAP值解释模型决策：

import shap def predict_proba(texts): inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt") with torch.no_grad(): outputs = model(**inputs) return torch.nn.functional.softmax(outputs.logits, dim=-1).numpy() explainer = shap.Explainer( predict_proba, tokenizer, output_names=["NEGATIVE", "POSITIVE"] ) shap_values = explainer(["This movie was terrible!"]) shap.plots.text(shap_values[:, :, "POSITIVE"])

12. 持续学习与更新

12.1 增量训练策略

from transformers import Trainer, TrainingArguments from datasets import load_dataset # 加载新数据 new_data = load_dataset("csv", data_files={"train": "new_reviews.csv"}) # 继续训练现有模型 trainer = Trainer( model=model, args=TrainingArguments( output_dir="./continued_model", per_device_train_batch_size=16, num_train_epochs=1, save_steps=500 ), train_dataset=new_data["train"] ) trainer.train()

12.2 模型版本管理

推荐使用MLflow进行模型版本控制：

import mlflow mlflow.set_tracking_uri("http://localhost:5000") with mlflow.start_run(): mlflow.transformers.log_model( transformers_model={ "model": model, "tokenizer": tokenizer }, artifact_path="sentiment_model", registered_model_name="bert-sentiment" ) # 记录性能指标 mlflow.log_metrics({ "accuracy": eval_results["eval_accuracy"], "f1": eval_results["eval_f1"] })

13. 硬件选型指南

13.1 不同硬件性能对比

13.2 成本效益分析

注：成本估算基于按需实例价格，长期使用预留实例可降低30-50%

14. 行业应用案例

14.1 客户服务自动化

场景：自动分类客户邮件并路由到对应部门

class CustomerServiceRouter: def __init__(self): self.classifier = pipeline( "zero-shot-classification", model="facebook/bart-large-mnli" ) def route_email(self, text): candidate_labels = [ "billing", "technical support", "product feedback", "account issue" ] result = self.classifier(text, candidate_labels) return result["labels"][0] # 使用示例 router = CustomerServiceRouter() category = router.route_email( "I can't login to my account despite resetting password" ) print(f"Route to: {category}") # 输出: "account issue"

14.2 智能文档处理

场景：合同关键信息提取

class ContractAnalyzer: def __init__(self): self.ner_pipeline = pipeline( "ner", model="dslim/bert-base-NER", aggregation_strategy="simple" ) def extract_contract_info(self, text): entities = self.ner_pipeline(text) result = { "parties": [], "dates": [], "amounts": [] } for entity in entities: if entity["entity_group"] == "ORG": result["parties"].append(entity["word"]) elif entity["entity_group"] == "DATE": result["dates"].append(entity["word"]) elif "$" in entity["word"]: result["amounts"].append(entity["word"]) return result

15. 模型监控与维护

15.1 数据漂移检测

from alibi_detect import KSDrift # 初始化检测器 drift_detector = KSDrift( p_val=0.05, X_ref=train_embeddings # 训练集的特征向量 ) # 监控新数据 new_embeddings = get_embeddings(new_data) preds = drift_detector.predict(new_embeddings) if preds["data"]["is_drift"]: alert("Data drift detected!")

15.2 模型性能衰减监测

import numpy as np from scipy import stats def performance_decay_test(old_scores, new_scores, alpha=0.01): """ old_scores: 历史准确率列表 new_scores: 新准确率列表 alpha: 显著性水平 """ t_stat, p_val = stats.ttest_ind(old_scores, new_scores) if p_val < alpha and np.mean(new_scores) < np.mean(old_scores): return True # 存在显著衰减 return False

16. 伦理与偏差缓解

16.1 偏差检测方法

from alibi_detect import AdversarialDebiasing # 定义敏感属性（如性别相关词） sensitive_cols = ["gender", "she", "