Python 自动化脚本系列：第7集

61. 使用抽象方法进行文本摘要

抽象文本摘要是指生成一个捕捉原始文本主要思想的摘要，同时可能会使用不在原文中的新词或短语。其目标是创建一个简洁而连贯的摘要，传达关键信息。你可以使用深度学习模型如 T5 或 BART 来自动化抽象文本摘要。

示例：使用 T5 进行新闻文章摘要

假设你有一篇新闻文章，想使用 T5 模型生成该文章的抽象摘要。以下是如何使用 Transformers 库自动化这一任务的步骤：

from transformers import T5Tokenizer, T5ForConditionalGeneration  
  
# 新闻文章  
article = """  
政府宣布了一项新的经济刺激计划，以促进国家经济。该计划包括减税、基础设施投资和对小企业的支持。专家认为，这些措施将有助于创造就业机会并刺激经济增长。然而，一些批评人士认为，该计划可能不足以应对经济面临的长期挑战。  
  
刺激计划出台之际，人们对持续的疫情导致的经济活动放缓感到担忧。政府希望这些措施能为消费者支出和商业信心提供急需的提振。减税预计会把更多的钱放到个人和企业手中，而基础设施投资旨在创造就业机会并提高国家的竞争力。  
  
受疫情严重打击的小企业将通过补助和贷款获得额外支持。政府认识到小企业在推动经济增长和就业方面的重要性。该计划还包括支持旅游和酒店业的措施，这些行业因旅行限制而受到严重影响。  
  
刺激计划的批评者认为，这可能不足以解决经济面临的结构性问题。他们指出，国家的高债务水平和生产率增长的下降需要长期解决方案。一些经济学家还警告，如果管理不当，刺激措施可能导致通胀压力。  
  
尽管存在担忧，政府对刺激计划的影响持乐观态度。他们认为，这些措施将为经济提供显著的提振，帮助国家从疫情引发的衰退中恢复过来。政府还承诺将继续监测经济状况，并在必要时采取进一步行动。  
"""  
  
# 加载 T5 tokenizer 和模型  
tokenizer = T5Tokenizer.from_pretrained('t5-small')  
model = T5ForConditionalGeneration.from_pretrained('t5-small')  
  
# 准备输入  
input_text = "summarize: " + article  
input_ids = tokenizer.encode(input_text, return_tensors='pt', max_length=512, truncation=True)  
  
# 生成摘要  
summary_ids = model.generate(input_ids, num_beams=4, max_length=100, early_stopping=True)  
summary = tokenizer.decode(summary_ids, skip_special_tokens=True)  
  
# 打印摘要  
print("Summary:", summary)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

这段代码定义了一篇新闻文章作为字符串。它使用 from_pretrained() 方法从 Transformers 库加载 T5 tokenizer 和模型。输入文本通过连接 "summarize: " 前缀和文章内容来准备。输入文本然后通过 tokenizer 的 encode() 方法编码成输入 ID。使用 T5 模型的 generate() 方法生成摘要。num_beams 参数指定了 beam search 的 beam 数量，max_length 设置了生成摘要的最大长度，early_stopping 启用在模型生成结束序列标记时提前停止。生成的摘要 ID 通过 tokenizer 的 decode() 方法解码，任何特殊标记都会被跳过。最后，生成的摘要被打印出来。

62. 文本转语音转换

文本转语音（ TTS ）转换涉及将书面文本转换为语音音频。它允许你以编程方式从文本生成语音。你可以使用 gTTS（ Google Text-to-Speech ）或 pyttsx3 等库自动化文本转语音转换。

示例：使用 gTTS 进行文本转语音转换

假设你有一段文本，想使用 Google Text-to-Speech API 将其转换为语音。以下是如何使用 gTTS 库自动化这一任务的步骤：

from gtts import gTTS  
import os  
  
# 要转换为语音的文本  
text = "Hello, this is an example of text-to-speech conversion using Python."  
  
# 创建 gTTS 对象  
tts = gTTS(text=text, lang='en')  
  
# 将语音保存为音频文件  
tts.save("output.mp3")  
  
# 播放音频文件  
os.system("start output.mp3")
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这段代码定义了一段要转换为语音的文本。它使用 gtts 库的 gTTS 类创建一个 gTTS 对象，指定文本和语言（‘en’ 表示英语）。使用 save() 方法将生成的语音保存为名为 “output.mp3” 的音频文件。最后，使用 os.system() 函数播放音频文件，默认使用系统的媒体播放器。

63. 语音转文本转换

语音转文本（ STT ）转换涉及将语音音频转录为书面文本。它允许你以编程方式将语音转换为文本。你可以使用 SpeechRecognition 库或 Google Cloud Speech-to-Text API 自动化语音转文本转换。

示例：使用 SpeechRecognition 进行语音转文本转换

假设你有一个包含语音的音频文件，想使用 SpeechRecognition 库将其转录为文本。以下是如何自动化这一任务的步骤：

import speech_recognition as sr  
  
# 创建识别器对象  
recognizer = sr.Recognizer()  
  
# 加载音频文件  
with sr.AudioFile("audio.wav") as source:  
    # 读取音频数据  
    audio = recognizer.record(source)  
  
# 执行语音识别  
try:  
    text = recognizer.recognize_google(audio)  
    print("Transcription:", text)  
except sr.UnknownValueError:  
    print("Speech recognition could not understand the audio.")  
except sr.RequestError as e:  
    print("Could not request results from the speech recognition service; {0}".format(e))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这段代码使用 speech_recognition 库的 Recognizer 类创建一个识别器对象。它使用 AudioFile 类加载名为 “audio.wav” 的音频文件，并使用识别器的 record() 方法读取音频数据。然后，使用 recognize_google() 方法调用 Google 语音识别 API 对音频数据进行语音识别。成功识别后，转录文本会被打印出来。如果语音识别无法理解音频，则会引发 UnknownValueError。如果请求结果时出错，则会引发 RequestError 并打印错误信息。

64. 语言检测

语言检测涉及识别给定文本的语言。它有助于确定用户生成内容的语言或将文本路由到适当的语言特定处理管道。你可以使用 langdetect 或 spaCy 等库自动化语言检测。

示例：使用 langdetect 进行文本语言检测

假设你有一段文本，想使用 langdetect 库检测其语言。以下是如何自动化这一任务的步骤：

from langdetect import detect  
  
# 要检测语言的文本  
text = "Bonjour, comment allez-vous?"  
  
# 检测语言  
language = detect(text)  
  
# 打印检测到的语言  
print("Detected Language:", language)
1
2
3
4
5
6
7
8
9
10

这段代码定义了一段法语文本。它使用 langdetect 库的 detect() 函数检测文本的语言。检测到的语言被存储在 language 变量中并打印出来。

65. 数据预处理

数据预处理是机器学习管道中的关键步骤。它涉及清理、转换和准备原始数据以进行进一步分析和建模。你可以使用 pandas、NumPy 和 scikit-learn 等库自动化数据预处理任务。

示例：预处理数据集

假设你有一个包含缺失值、分类变量和数值特征的数据集。以下是如何自动化数据预处理步骤：

import pandas as pd  
from sklearn.impute import SimpleImputer  
from sklearn.preprocessing import OneHotEncoder, StandardScaler  
  
# 加载数据集  
data = pd.read_csv('dataset.csv')  
  
# 处理缺失值  
imputer = SimpleImputer(strategy='mean')  
data_imputed = imputer.fit_transform(data)  
  
# 编码分类变量  
encoder = OneHotEncoder(handle_unknown='ignore')  
data_encoded = encoder.fit_transform(data_imputed[:, :-1])  
  
# 缩放数值特征  
scaler = StandardScaler()  
data_scaled = scaler.fit_transform(data_encoded)  
  
# 创建预处理后数据集  
preprocessed_data = pd.DataFrame(data_scaled)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这段代码使用 pandas 加载数据集。然后执行以下预处理步骤：

1. 处理缺失值：使用 scikit-learn 的 SimpleImputer 类，通过均值填补缺失值。
2. 编码分类变量：使用 scikit-learn 的 OneHotEncoder 类对分类变量进行独热编码。
3. 缩放数值特征：使用 scikit-learn 的 StandardScaler 类标准化数值特征。

最后，创建一个预处理后的数据集 preprocessed_data，其中包含经过所有预处理步骤处理后的特征。

66. 特征选择

特征选择是从原始特征集中选出相关特征的过程。它有助于减少数据的维度，提高模型性能，并减少过拟合。你可以使用像 scikit-learn 这样的库来自动化特征选择。

示例：使用递归特征消除选择特征

假设你有一个包含大量特征的数据集，你想用递归特征消除 (RFE) 来选择最相关的特征。下面是如何自动完成这项任务的代码：

from sklearn.feature_selection import RFE  
from sklearn.linear_model import LogisticRegression  

# 加载数据集  
X = ...  # 特征  
y = ...  # 目标变量  

# 创建一个逻辑回归模型  
model = LogisticRegression()  

# 创建一个 RFE 对象  
rfe = RFE(estimator=model, n_features_to_select=10)  

# 将 RFE 对象拟合到数据上  
rfe.fit(X, y)  

# 获取选定的特征  
selected_features = X.columns[rfe.support_]  

# 打印选定的特征  
print("Selected Features:", selected_features)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

这段代码假设你已经将数据集加载到 X（特征）和 y（目标变量）中。它创建了一个逻辑回归模型和一个 RFE 对象，指定要选择的特征数量。使用 fit() 方法将 RFE 对象拟合到数据上。选定的特征可以通过 RFE 对象的 support_ 属性获取，这是一个布尔掩码，指示选定的特征。最后，打印出选定的特征。

67. 模型训练与评估

模型训练与评估是机器学习流程中必不可少的步骤。你可以使用像 scikit-learn 这样的库来自动化模型训练与评估过程。

示例：训练和评估分类模型

假设你有一个包含特征和目标标签的数据集，你想训练并评估一个分类模型。下面是如何自动完成这项任务的代码：

from sklearn.model_selection import train_test_split  
from sklearn.ensemble import RandomForestClassifier  
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score  

# 加载数据集  
X = ...  # 特征  
y = ...  # 目标标签  

# 将数据分成训练集和测试集  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  

# 创建一个随机森林分类器  
model = RandomForestClassifier(n_estimators=100, random_state=42)  

# 训练模型  
model.fit(X_train, y_train)  

# 对测试集进行预测  
y_pred = model.predict(X_test)  

# 评估模型  
accuracy = accuracy_score(y_test, y_pred)  
precision = precision_score(y_test, y_pred)  
recall = recall_score(y_test, y_pred)  
f1 = f1_score(y_test, y_pred)  

# 打印评估指标  
print("Accuracy:", accuracy)  
print("Precision:", precision)  
print("Recall:", recall)  
print("F1 Score:", f1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

这段代码假设你已经将数据集加载到 X（特征）和 y（目标标签）中。使用 scikit-learn 的 train_test_split() 函数将数据分成训练集和测试集。创建一个包含100个决策树的随机森林分类器。使用 fit() 方法在训练数据上训练模型。使用 predict() 方法对测试集进行预测。通过准确率、精确率、召回率和 F1 分数等指标评估模型。最后，打印这些评估指标。

68. 超参数调优

超参数调优是为机器学习模型找到最优超参数的过程。它有助于提高模型的性能和泛化能力。你可以使用像 scikit-learn 这样的库来自动化超参数调优过程。

示例：使用网格搜索调优超参数

假设你有一个数据集和一个机器学习模型，你想用网格搜索来找到模型的最佳超参数。下面是如何自动完成这项任务的代码：

from sklearn.model_selection import GridSearchCV  
from sklearn.svm import SVC  

# 加载数据集  
X = ...  # 特征  
y = ...  # 目标标签  

# 定义超参数网格  
param_grid = {  
    'C': [0.1, 1, 10],  
    'kernel': ['linear', 'rbf'],  
    'gamma': [0.1, 1, 10]  
}  

# 创建一个 SVM 分类器  
model = SVC()  

# 创建一个网格搜索对象  
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=5)  

# 将网格搜索对象拟合到数据上  
grid_search.fit(X, y)  

# 获取最佳超参数  
best_params = grid_search.best_params_  

# 打印最佳超参数  
print("Best Hyperparameters:", best_params)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

这段代码假设你已经将数据集加载到 X（特征）和 y（目标标签）中。为 SVM 分类器定义了一个超参数网格，指定了 C、kernel 和 gamma 的不同值。使用 scikit-learn 的 GridSearchCV 类创建一个网格搜索对象，指定 SVM 分类器、超参数网格和交叉验证次数。使用 fit() 方法将网格搜索对象拟合到数据上。通过 grid_search 对象的 best_params_ 属性获取最佳超参数并打印出来。

69. 模型持久化

模型持久化是指将训练好的机器学习模型保存到磁盘，并在以后加载它以进行预测。这样可以重复使用训练好的模型，而无需每次都重新训练。你可以使用像 pickle 或 joblib 这样的库来自动化模型持久化过程。

示例：保存和加载训练好的模型

假设你已经训练好一个机器学习模型，并想将其保存到磁盘以供将来使用。下面是如何自动完成这项任务的代码：

import pickle  

# 训练一个模型  
model = ...  # 训练好的模型  

# 将模型保存到磁盘  
with open('model.pkl', 'wb') as file:  
    pickle.dump(model, file)  

# 从磁盘加载模型  
with open('model.pkl', 'rb') as file:  
    loaded_model = pickle.load(file)  

# 使用加载的模型进行预测  
predictions = loaded_model.predict(...)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这段代码假设你已经训练好一个机器学习模型并将其存储在 model 变量中。使用 pickle.dump() 函数将训练好的模型序列化并写入名为 ‘model.pkl’ 的文件中。使用 pickle.load() 函数从磁盘加载模型，反序列化模型对象。然后，可以使用加载的模型对新数据进行预测。

70. 模型部署

模型部署是指将训练好的机器学习模型用于生产环境的过程。它涉及将模型集成到应用程序或系统中，以便接收输入数据并提供预测结果。你可以使用像 Flask 或 Django 这样的框架来自动化模型部署过程。

示例：将模型部署为 REST API

假设你已经训练好一个机器学习模型，并想用 Flask 将其部署为 REST API。下面是如何自动完成这项任务的代码：

from flask import Flask, request, jsonify  
import pickle  

app = Flask(__name__)  

# 加载训练好的模型  
with open('model.pkl', 'rb') as file:  
    model = pickle.load(file)  

@app.route('/predict', methods=['POST'])  
def predict():  
    # 从请求中获取输入数据  
    data = request.json['data']  
      
    # 使用加载的模型进行预测  
    predictions = model.predict(data)  
      
    # 将预测结果作为 JSON 响应返回  
    return jsonify({'predictions': predictions.tolist()})  

if __name__ == '__main__':  
    app.run(debug=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这段代码假设你已经训练好一个机器学习模型，并将其保存为 ‘model.pkl’ 文件。使用 Flask 框架创建一个 REST API。使用 pickle.load() 从磁盘加载训练好的模型。定义一个名为 /predict 的 API 端点，使用 @app.route 装饰器。这个端点期望一个包含输入数据的 POST 请求 JSON 格式。当收到请求时，从请求 JSON 中提取输入数据。使用加载的模型对输入数据进行预测。然后，使用 jsonify() 函数将预测结果作为 JSON 响应返回。最后，使用 app.run() 运行 Flask 应用程序。