数据挖掘与分析部分实验内容

news2024/12/23 13:20:25

一、机器学习算法的应用

1. 朴素贝叶斯分类器

相关代码

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB, MultinomialNB
from sklearn.metrics import accuracy_score
# 将数据加载到DataFrame中,删除ID和ZIP Code列
df = pd.read_csv('universalbank.csv')
df = df.drop(columns=['ID', 'ZIP Code'])
# 以下是使用高斯朴素贝叶斯分类器的代码
# 分离特征和目标变量
X = df.drop(columns=['Personal Loan'])
y = df['Personal Loan']
# 划分数据集
# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
# 创建高斯朴素贝叶斯分类器实例
gnb = GaussianNB()
# 训练模型
gnb.fit(X_train, y_train)
# 预测测试集
y_pred = gnb.predict(X_test)
# 输出预测结果和模型准确度
print("高斯朴素贝叶斯分类器的预测结果:", y_pred)
print("高斯朴素贝叶斯分类器的准确度:", accuracy_score(y_test, y_pred))
# 以下是使用多项式朴素贝叶斯分类器的代码
# 筛选出离散型特征
X_discrete = df[['Family', 'Education', 'Securities Account', 'CD Account', 'Online', 'CreditCard']]
# 划分数据集
# X_train_discrete, X_test_discrete, y_train, y_test = train_test_split(X_discrete, y, test_size=0.3, random_state=42)
X_train_discrete, X_test_discrete, y_train, y_test = train_test_split(X_discrete, y, test_size=0.3, random_state=0)
# 创建多项式朴素贝叶斯分类器实例
mnb = MultinomialNB()
# 训练模型
mnb.fit(X_train_discrete, y_train)
# 预测测试集
y_pred_discrete = mnb.predict(X_test_discrete)
# 输出预测结果和模型准确度
print("多项式朴素贝叶斯分类器的预测结果:", y_pred_discrete)
print("多项式朴素贝叶斯分类器的准确度:", accuracy_score(y_test, y_pred_discrete))

运行结果

2.K近邻分类器(KNN)

相关代码

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 将数据加载到DataFrame中,删除ID和ZIP Code列
df = pd.read_csv('universalbank.csv')
df = df.drop(columns=['ID', 'ZIP Code'])
# 分离特征和目标变量
X = df.drop(columns=['Personal Loan'])
y = df['Personal Loan']
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
# 创建KNN分类器实例,设置最近邻的数量K为5
knn = KNeighborsClassifier(n_neighbors=5)
# 训练模型
knn.fit(X_train, y_train)
# 预测测试集
y_pred = knn.predict(X_test)
# 输出预测结果和模型准确度
print("KNN分类器的预测结果:", y_pred)
print("KNN分类器的准确度:", accuracy_score(y_test, y_pred))

运行结果

3. CART决策树

相关代码

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.tree import export_graphviz
import graphviz
# 将数据加载到DataFrame中,删除ID和ZIP Code列
df = pd.read_csv('universalbank.csv')
df = df.drop(columns=['ID', 'ZIP Code'])
# 分离特征和目标变量
X = df.drop(columns=['Personal Loan'])
y = df['Personal Loan']
# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
# 创建CART决策树分类器实例,设置决策树的深度限制为10层
dt = DecisionTreeClassifier(max_depth=10, random_state=42)
# 训练模型
dt.fit(X_train, y_train)
# 预测测试集
y_pred = dt.predict(X_test)
# 输出预测结果和模型准确度
print("CART决策树分类器的预测结果:", y_pred)
print("CART决策树分类器的准确度:", accuracy_score(y_test, y_pred))

# 可视化训练好的CART决策树模型
dot_data = export_graphviz(dt, out_file=None,
                           feature_names=X.columns,
                           class_names=['0', '1'],
                           filled=True, rounded=True,
                           special_characters=True)
graph = graphviz.Source(dot_data)
graph.render("universalbank_decision_tree")  # 保存为PDF文件
graph.view()  # 在默认PDF查看器中打开

运行结果

4.神经网络回归任务

相关代码

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPRegressor

data = pd.read_csv('house-price.csv')
X = data.iloc[:, 2:14]
y = data.iloc[:, [1]]

# 划分数据集,70%为训练集,30%为测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# 创建多层感知机回归模型实例,设置隐藏层层数和神经元数量
regressor = MLPRegressor(hidden_layer_sizes=(100, 10), activation="relu")

# 使用训练集数据训练模型
regressor.fit(X_train, y_train)

# 使用训练好的模型对测试集进行预测
y_pred = regressor.predict(X_test)

# 计算模型的均方误差(MSE)
mse = np.sum(np.square(y_pred - y_test.values)) / len(y_test)
# 计算模型的平均绝对误差(MAE)
mae = np.sum(np.abs(y_pred - y_test.values)) / len(y_test)

# 输出测试数据的预测结果和模型的MSE和MAE
print('测试数据的预测结果:', y_pred)
print("预测结果和模型的MSE:", mse)
print("预测结果和模型的MAE:", mae)
# 使用训练好的模型对给定的数据进行房价预测
y_ = regressor.predict(np.array([[3.0, 2.5, 1490, 8102, 2.0, 0, 0, 4, 1490, 0, 1990, 0]]))
print('数据[3.0,2.5,1490,8102,2.0,0,0,4,1490,0,1990,0]的预测结果为:', y_)

运行结果

5.神经网络分类任务

相关代码

import pandas as pd
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score

# 将数据加载到DataFrame中
df = pd.read_excel('企业贷款审批数据表.xlsx')
# 选择特征列和目标列
X = df.iloc[:, 1:4]  # 特征列X1, X2, X3
y = df.iloc[:, 4]    # 目标列Y
# 使用前10行数据作为训练集,11-20行数据作为测试集
X_train = X.iloc[:10]
y_train = y.iloc[:10]
X_test = X.iloc[10:20]
y_test = y.iloc[10:20]
# 创建MLP分类模型实例,设置隐藏层层数和神经元数量
mlp = MLPClassifier(hidden_layer_sizes=(10,5), max_iter=1000, random_state=0,verbose=1)
# 训练模型
mlp.fit(X_train, y_train)
# 使用训练好的模型对测试集进行预测
y_pred = mlp.predict(X_test)
# 计算模型的准确度
accuracy = accuracy_score(y_test, y_pred)
# 输出预测结果和模型准确度
print("测试集的预测结果:", y_pred)
print("模型准确度:", accuracy)
# 使用训练好的模型对21-25行数据进行预测
# 给定的数据
new_data = df.iloc[20:, 1:4]
predicted_results = mlp.predict(new_data)
# 输出评估结果
print("21-25行数据的评估结果:", predicted_results)

运行结果

6. 关联规则分析

相关代码

import pandas as pd
from mlxtend.preprocessing import TransactionEncoder
from tabulate import tabulate
from mlxtend.frequent_patterns import apriori, fpgrowth, association_rules

# (2)数据读取与预处理
data = pd.read_excel('tr.xlsx', keep_default_na=False)
# 将数据转换为适合TransactionEncoder的格式
te = TransactionEncoder()
te_ary = te.fit(data.values).transform(data.values)
# 创建DataFrame
df = pd.DataFrame(te_ary, columns=te.columns_)
# 剔除第3列到第6列
df = df.drop(columns=df.columns[0:9])
# 将True和False替换为1和0
df = df.replace({True: 1, False: 0})
# 使用tabulate库打印DataFrame
# print(tabulate(df, headers='keys', tablefmt='psql'))

# (3)使用apriori算法挖掘频繁项集(最小支持度为0.3)
frequent_itemsets_apriori = apriori(df, min_support=0.3, use_colnames=True)

# (4)使用FP-growth算法挖掘频繁项集(最小支持度为0.3)
frequent_itemsets_fpgrowth = fpgrowth(df, min_support=0.3, use_colnames=True)

# (5)生成强规则(最小置信度为0.5, 提升度>1)
rules = association_rules(frequent_itemsets_apriori, metric='confidence', min_threshold=0.5, support_only=False)
rules = rules[rules['lift'] > 1]

# 输出结果
print("频繁项集(Apriori算法):")
# print(frequent_itemsets_apriori)
print(tabulate(frequent_itemsets_apriori, headers='keys', tablefmt='psql'))
print("\n频繁项集(FP-growth算法):")
# print(frequent_itemsets_fpgrowth)
print(tabulate(frequent_itemsets_fpgrowth, headers='keys', tablefmt='psql'))
print("\n强规则:")
print(rules)

运行结果

7.时间序列分析

相关代码

import pandas as pd
import warnings
from matplotlib import MatplotlibDeprecationWarning
import matplotlib.pyplot as plt
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
from statsmodels.tsa.stattools import adfuller as ADF
from statsmodels.tsa.arima.model import ARIMA

# 屏蔽所有FutureWarning类型的警告
warnings.filterwarnings("ignore", category=FutureWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="statsmodels")
warnings.filterwarnings("ignore", category=MatplotlibDeprecationWarning)

# 读取数据
data = pd.read_csv('shampoo.csv')

# 假设数据框中日期列名为'Month'
data['Month'] = '2024-' + data['Month']

# 如果需要转换为日期类型(可选)
data['Month'] = pd.to_datetime(data['Month'], format='%Y-%m-%d')
data.rename(columns={'Month': 'Date'}, inplace=True)

# (3)检测序列的平稳性
# 时序图判断法
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.plot(data['Sales'])
plt.legend(['Sales'])
plt.show()

# 制自相关图判断法
plot_acf(data['Sales'])
plt.show()

# 使用ADF单位根检测法
print('原始序列的ADF检验结果为:', ADF(data['Sales']))

# (4)差分处理
# 注意:根据上一步结果判断数据序列为非平稳序列,如想使用模型对数据进行建模,
# 则需将数据转换为平稳序列。所以在这一步使用差分处理对序列进行处理。
Date_data = data['Sales'].diff().dropna()

# 对处理后的序列进行平稳性检测(自相关图法、偏相关图法、ADF检测法)
plot_acf(Date_data)
plt.show()
plot_pacf(Date_data)
plt.show()

print('差分序列的ADF检验结果为:', ADF(Date_data))

# (5)使用ARIMA模型对差分处理后的序列进行建模
# 选择合适的p和q值
pmax = int(len(Date_data)/10)
qmax = int(len(Date_data)/10)
bic_matrix = []
for p in range(pmax + 1):
    tmp = []
    for q in range(qmax + 1):
        try:
            tmp.append(ARIMA(data['Sales'].values, order=(p,1,q)).fit().bic)
        except:
            tmp.append(None)
    bic_matrix.append(tmp)
bic_matrix = pd.DataFrame(bic_matrix)

p, q = bic_matrix.stack().idxmin()
print('BIC最小的p值和q值为:%s、%s' % (p, q))

# 使用模型预测未来5个月的销售额
model = ARIMA(data['Sales'].values, order=(p,1,q)).fit()
print('模型基本报告', model.summary())
print('预测未来5个月的销售额:', model.forecast(5))

运行结果

二、深度学习算法应用

1. TensorFlow框架的基本使用

(1)获取训练数据

构建一个简单的线性模型:W,b为参数,W=2,b=1,运用tf.random.normal() 产生1000个随机数,产生x,y数据。

用matplotlib库,用蓝色绘制训练数据。

import tensorflow as tf
import numpy as np
import warnings
from matplotlib import MatplotlibDeprecationWarning

# 屏蔽所有FutureWarning类型的警告
warnings.filterwarnings("ignore", category=FutureWarning)
warnings.filterwarnings("ignore", category=UserWarning, module="statsmodels")
warnings.filterwarnings("ignore", category=MatplotlibDeprecationWarning)
W = 3.0   # W参数设置
b =1.0    # b参数设置
num = 1000
# x随机输入
x = tf.random.normal(shape=[num])
# 随机偏差
c = tf.random.normal(shape=[num])
# 构造y数据
y = W * x + b + c
# print(x)

# 画图观察
import matplotlib.pyplot as plt    #加载画图库
plt.scatter(x, y, c='b')    # 画离散图
plt.show()    # 展示图
(2)定义模型

通过对样本数据的离散图可以判断,呈线性规律变化,因此可以建立一个线性模型,即 ,把该线性模型定义为一个简单的类,里面封装了变量和计算,变量设置用tf.Variable()。

#定义模型
class LineModel(object):   # 定义一个LineModel的类
    def __init__(self):
        # 初始化变量
        self.W = tf.Variable(5.0)
        self.b = tf.Variable(0.0)
        
    def __call__(self, x):   #定义返回值
        return self.W * x + self.b
    
    def train(self, x, y, learning_rate):   #定义训练函数
        with tf.GradientTape() as t:
            current_loss = loss(self.__call__(x), y)  #损失函数计算
            # 对W,b求导
            d_W, d_b = t.gradient(current_loss, [self.W, self.b])
            # 减去梯度*学习率
            self.W.assign_sub(d_W*learning_rate)  #减法操作
            self.b.assign_sub(d_b*learning_rate)
(3)定义损失函数

损失函数是衡量给定输入的模型输出与期望输出的匹配程度,采用均方误差(L2范数损失函数)。

# 定义损失函数
def loss(predicted_y, true_y):   # 定义损失函数
    return tf.reduce_mean(tf.square(true_y - predicted_y))  # 返回均方误差值
(4)模型训练

运用数据和模型来训练得到模型的变量(W和b),观察W和b的变化(使用matplotlib绘制W和b的变化情况曲线)。

# 求解过程     
model= LineModel()  #运用模型实例化
# 计算W,b参数值的变化
W_s, b_s = [], []    #增加新中间变量
for epoch in range(15):    #循环15次
    W_s.append(model.W.numpy())  #提取模型的W参数添加到中间变量w_s
    b_s.append(model.b.numpy())
    print('model.W.numpy():',model.W.numpy())
    # 计算损失函数loss
    current_loss = loss(model(x), y)
    model.train(x, y, learning_rate=0.1)   # 运用定义的train函数训练
    print('Epoch %2d: W=%1.2f b=%1.2f, loss=%2.5f' %
        (epoch, W_s[-1], b_s[-1], current_loss))    #输出训练情况
# 画图,把W,b的参数变化情况画出来
epochs = range(15)   #这个迭代数据与上面循环数据一样
plt.figure(1)
plt.scatter(x, y, c='b')    # 画离散图
plt.plot(x,model(x),c='r')
plt.figure(2)
plt.plot(epochs, W_s, 'r',
         epochs, b_s, 'b')  #画图
plt.plot([W] * len(epochs), 'r--',
         [b] * len(epochs), 'b-*')
plt.legend(['pridect_W', 'pridet_b', 'true_W', 'true_b'])  # 图例
plt.show()

运行结果

2. 多层神经网络分类

(1)数据获取与预处理

MNIST 数据集来自美国国家标准与技术研究所, National Institute of Standards and Technology (NIST). 训练集 (training set) 由来自 250 个不同人手写的数字构成, 其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据。

每张图像的大小都是28x28像素。MNIST数据集有60000张图像用于训练和10000张图像用于测试,其中每张图像都被标记了对应的数字(0-9)。

(2)加载数据集
import tensorflow as tf
import matplotlib.pyplot as plt
# 1. 数据获取与预处理
# 加载数据集
mnist = tf.keras.datasets.mnist
(x_train_all, y_train_all), (x_test, y_test) = mnist.load_data()
(3)查看数据集
def show_single_image(img_arr):
    plt.imshow(img_arr, cmap='binary')
    plt.show()

show_single_image(x_train_all[0])
(4)归一化处理
x_train_all, x_test = x_train_all / 255.0, x_test / 255.0

模型构建

(5)模型定义

# 模型定义
model = tf.keras.models.Sequential([  
    #输入层  
    tf.keras.layers.Flatten(input_shape=(28, 28)),  
    #隐藏层1  
    tf.keras.layers.Dense(256, activation=tf.nn.relu),  
    #百分之20的神经元不工作,防止过拟合  
    tf.keras.layers.Dropout(0.2),  
    #隐藏层2  
    tf.keras.layers.Dense(128, activation=tf.nn.relu),  
    #隐藏层3  
    tf.keras.layers.Dense(64, activation=tf.nn.relu),  
    #输出层  
    tf.keras.layers.Dense(10, activation=tf.nn.softmax)  
])
(6)编译模型
#定义优化器,损失函数,训练效果中计算准确率  
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['sparse_categorical_accuracy'])
(7)输出模型参数
# 打印网络参数
print(model.summary())

模型训练

(8)训练
# 训练模型
history = model.fit(x_train_all, y_train_all, epochs=50, validation_split=0.2, verbose=1)
(9)获取训练历史数据中的各指标值
acc = history.history['sparse_categorical_accuracy']
val_acc = history.history['val_sparse_categorical_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
(10)绘制指标在训练过程中的变化图
plt.figure(1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()
plt.figure(2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()
(11)模型评估

使用测试集对模型进行评估

loss, accuracy = model.evaluate(x_test, y_test, verbose=1)
print(f"Test Loss: {loss}, Test Accuracy: {accuracy}")

3. 多层神经网络回归

(1)数据获取与预处理

Auto MPG 数据集,它记录了各种汽车效能指标MPG(Mile Per Gallon)与气缸数、重量、马力等因素的真实数据。除了产地的数字字段表示类别外,其他字段都是数值类型。对于产地地段,1 表示美国,2 表示欧洲,3 表示日本。

(2)加载数据集
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
column_names = ['MPG', 'Cylinders', 'Displacement', 'Horsepower', 'Weight',
               'Acceleration', 'Model Year', 'Origin']
raw_dataset = pd.read_csv('./data/auto-mpg.data', names=column_names,
                        na_values="?", comment='\t',
                        sep=" ", skipinitialspace=True)
(3)数据清洗
# 数据清洗
# 统计每列的空值数量
null_counts = raw_dataset.isnull().sum()
# 打印每列的空值数量
print(null_counts)
# 删除包含空值的行
dataset = raw_dataset.dropna()

(4)将Origin列转换为one-hot(独热)编码。
dataset = pd.get_dummies(dataset, columns=['Origin'])
(5)数据探索
  • 使用describe方法查看数据的统计指标
# 使用describe方法查看数据的统计指标
dataset.describe()
  • 使用seaborn库中pairplot方法绘制"MPG", "Cylinders", "Displacement", "Weight"四列的联合分布图
# 使用seaborn库中pairplot方法绘制"MPG", "Cylinders", "Displacement", "Weight"四列的联合分布图
sns.pairplot(dataset[['MPG', 'Cylinders', 'Displacement', 'Weight']])
(6)数据可视化
labels = dataset.pop('MPG')  #从数据集中取出目标值MPG
#数据标准化
from sklearn.preprocessing import StandardScaler
def norm(x):
    return (x - train_stats['mean']) / train_stats['std'] #标准化公式
scaler = StandardScaler()
normed_dataset = scaler.fit_transform(dataset)
(7)划分数据集
X_train, X_test, Y_train, Y_test = train_test_split(normed_dataset, labels, test_size=0.2, random_state=0)

模型构建

(8)模型定义
import tensorflow as tf
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation='relu', input_shape=[X_train.shape[1]]),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(1)
  ])
(9)模型编译
model.compile(loss='mse', optimizer='adam', metrics=['mae', 'mse'])
plt.show()
(10)输出模型参数
# 输出模型参数
print(model.summary())

模型训练

(11)训练
history = model.fit(X_train, Y_train, epochs=100, validation_split=0.2, verbose=1)
(12)获取训练历史数据中的各指标值
mae = history.history['mae']
val_mae = history.history['val_mae']
mse = history.history['mse']
val_mse = history.history['val_mse']
(13)绘制指标在训练过程中的变化图
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(mae, label='Training MAE')
plt.plot(val_mae, label='Validation MAE')
plt.title('Training and Validation MAE')
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(mse, label='Training MSE')
plt.plot(val_mse, label='Validation MSE')
plt.title('Training and Validation MSE')
plt.legend()
plt.show()

(14)模型评估

使用测试集对模型进行评估

model.evaluate(X_test, Y_test, verbose=1)

4. 多层神经网络回归

(1)数据获取与预处理

IMDB数据集,有5万条来自网络电影数据库的评论,其中25000千条用来训练,25000用来测试,每个部分正负评论各占50%。和MNIST数据集类似,IMDB数据集也集成在Keras中,同时经过了预处理:电影评论转换成了一系列数字,每个数字代表字典中的一个单词(表示该单词出现频率的排名)

(2)读取数据
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
from tensorflow.keras.callbacks import EarlyStopping
import tensorflow as tf
# 加载数据,评论文本已转换为整数,其中每个整数表示字典中的特定单词
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=10000)
(2)预处理
# 循环神经网络输入长度固定
# 这里应该注意,循环神经网络的输入是固定长度的,否则运行后会出错。
# 由于电影评论的长度必须相同,pad_sequences 函数来标准化评论长度
x_train = tf.keras.preprocessing.sequence.pad_sequences(x_train, maxlen=100)
x_test = tf.keras.preprocessing.sequence.pad_sequences(x_test, maxlen=100)

模型搭建

(3)模型定义
model = Sequential([
    #定义嵌入层
    Embedding(10000,  # 词汇表大小中收录单词数量,也就是嵌入层矩阵的行数
                    128,           # 每个单词的维度,也就是嵌入层矩阵的列数
                    input_length=100),
    # 定义LSTM隐藏层
    LSTM(128, dropout=0.2, recurrent_dropout=0.2),
    # 模型输出层
    Dense(1, activation='sigmoid')
])
(4)编译模型
model.compile(loss='binary_crossentropy',optimizer='adam',metrics=['accuracy'])

模型训练

(5)训练
history = model.fit(x_train, y_train, epochs=5, validation_split=0.2, verbose=1)
(6)获取训练历史数据中的各指标值
accuracy = history.history['accuracy']
val_accuracy = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
(7)绘制指标在训练过程中的变化图
# 绘制指标在训练过程中的变化图
import matplotlib.pyplot as plt

# plt.figure(1)
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(accuracy, label='Training Accuracy')
plt.plot(val_accuracy, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

# plt.figure(2)
plt.subplot(1, 2, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()

(8)模型评估

使用测试集对模型进行评估

test_loss, test_acc = model.evaluate(x_test, y_test, verbose=1)
print(f"Test Accuracy: {test_acc}, Test Loss: {test_loss}")

三、数据挖掘综合应用

1.微博评论情感分析

(1)数据读取

新浪微博数据集(网上搜集、作者不详)来源于网上的GitHub社区,有微博10 万多条,都带有情感标注,正负向评论约各 5 万条,用来做情感分析的数据集。

import jieba
import pandas as pd
import re
from wordcloud import WordCloud
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Embedding, LSTM, Dense
#from keras.preprocessing.text import Tokenizer
from keras.utils import to_categorical
from sklearn.model_selection import train_test_split
from keras.callbacks import EarlyStopping


data = pd.read_csv("E:/课程内容文件/大三下学期/数据挖掘与分析/课程实验/实验六/weibo_senti_100.csv")

数据预处理

(2)分词
data['data_cut'] = data['review'].apply(lambda x: jieba.lcut(x))
(3)去停用词
with open("E:/课程内容文件/大三下学期/数据挖掘与分析-王思霖/课程实验/实验六/stopword.txt", 'r', encoding='utf-8') as f:
    stop = f.readlines()
stop = [re.sub('\n', '', r) for r in stop]
data['data_after'] = data['data_cut'].apply(lambda x: [i for i in x if i not in stop and i != '\ufeff'])
(4)词云分析
num_words = [''.join(i) for i in data['data_after']]
num_words = ''.join(num_words)
num = pd.Series(jieba.lcut(num_words)).value_counts()
wc_pic = WordCloud(background_color='white', font_path=r'C:\Windows\Fonts\simhei.ttf').fit_words(num)
plt.figure(figsize=(10, 10))
plt.imshow(wc_pic)
plt.axis('off')
plt.show()

(5)词向量
# 构建词向量矩阵
w = []
for i in data['data_after']:
    w.extend(i)
# 计算词频
word_counts = pd.Series(w).value_counts()
# 创建DataFrame
num_data = pd.DataFrame(word_counts).reset_index()
# 重命名列
num_data.columns = ['word', 'count']
# 添加id列
num_data['id'] = num_data.index + 1

# 创建单词到ID的映射字典
word_to_id_dict = num_data.set_index('word')['id'].to_dict()

# 优化的转化成数字函数
def optimized_word2num(x):
    return [word_to_id_dict[i] for i in x if i in word_to_id_dict]

# 应用优化后的函数
data['vec'] = data['data_after'].apply(optimized_word2num)
(6)划分数据集
import tensorflow as tf
# from keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

maxlen = 128
vec_data = pad_sequences(data['vec'], maxlen=maxlen)
x_train, x_test, y_train, y_test = train_test_split(vec_data, data['label'], test_size=0.2, random_state=0)

模型搭建

(7)模型定义
model = Sequential([
    Embedding(len(num_data) + 1,  # 词汇表大小中收录单词数量,加1是因为要包括未知词
              64,  # 每个单词的维度
              input_length=maxlen),
    LSTM(64, dropout=0.2, recurrent_dropout=0.2),
    Dense(1, activation='sigmoid')
])
(8)编译模型
model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

模型训练

(9)训练
history = model.fit(x_train, y_train,
                    epochs=5,
                    validation_split=0.2,
                    verbose=1)
(10)获取训练历史数据中的各指标值
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
(11)绘制指标在训练过程中的变化图
# 绘制训练 & 验证的准确率
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()

plt.subplot(1, 2, 2)
# 绘制训练 & 验证的损失值
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()
(12)模型评估

使用测试集对模型进行评估

score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1940784.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

Stable Diffusion 使用详解(3)---- ControlNet

背景 炼丹师在AI绘画的过程中,由于Stable Diffusion的原理是水滴式的扩散作图原理,其实在前面也有提到,他的发挥是‘不稳定’的,因为你没有办法做到精确控制,只能说是大致符合你的预期。你不能总依赖抽卡固定随机数种…

SpringCloud--负载均衡

目录 前言 一.负载均衡的引入 1.1问题引入 1.2代码修改实现 二.负载均衡介绍 2.1实现负载均衡 2.2负载均衡策略 2.3LoadBalancer 原理 学习专栏:http://t.csdnimg.cn/tntwg 前言 在前面的Eureka当中,我们虽然实现了从注册中心中获取url&#xf…

spark 广播变量broadcast

broadcast使用如下图,可以看到创建broadcast是val barr1 sc.broadcast(arr1),使用broadcast是barr1.value 创建broadcast是使用的broadcastManager。 BroadcastManager cachedValues变量是map结构,key是broadcastId,强引用&a…

初识C++|模板初阶

🍬 mooridy-CSDN博客 🧁C专栏(更新中!) 目录 🍉1. 泛型编程 🍉2. 函数模板 🥝2.1 函数模板概念 🥝2.2 函数模板格式 🥝2.3 函数模板的原理 &#x1f95…

java题目之数字加密以及如何解密

public class Main6 {public static void main(String[] args) {// 某系统的数字密码&#xff08;大于0&#xff09;&#xff0c;比如1983&#xff0c;采用加密方式进行传输//定义了一个静态数组int []arr{1,9,8,3};//1.加密//先给每位数加上5for (int i 0; i <arr.length …

1997. 孤独的素数(结果有一点问题,希望能一起求解)

问题描述 在一个 &#x1d45b; 行 &#x1d45a;列的矩阵王国中&#xff0c;生活着一些整数&#xff0c;其中一些是素数&#xff0c;一些不是素数。如果一个素数的上下左右、左上、右上、左下、右下相邻的数中都没有素数&#xff0c;我们就认为这是一个孤独的素数。 比如&am…

Spring Boot + Spring Cloud 入门

运行配置 java -jar spring-boot-config-0.0.1-SNAPSHOT.jar --spring.profiles.activetest --my1.age32 --debugtrue "D:\Program Files\Redis\redis-server.exe" D:\Program Files\Redis\redis.windows.conf "D:\Program Files\Redis\redis-cli.exe" &q…

【零基础必看的前端教程】——JavaScript(四)类型转换

欢迎大家打开前端的新篇章——JavaScript&#xff0c;JavaScript与HTML、CSS合称为前端三大件&#xff0c;JavaScript是前端的重中之重&#xff0c;小洪将继续以零基础视角&#xff0c;带你循序渐进学习前端知识&#xff0c;一看就懂&#xff0c;小白也能转行做前端&#xff01…

基于WebGoat平台的SQL注入攻击

目录 引言 一、安装好JAVA 二、下载并运行WebGoat 三、注册并登录WebGoat 四、模拟攻击 1. 第九题 2. 第十题 3. 第十一题 4. 第十二题 5. 第十三题 五、思考体会 1. 举例说明SQL 注入攻击发生的原因。 2. 从信息的CIA 三要素&#xff08;机密性、完整性、可用性&…

推荐一款基于Spring Boot 框架开发的分布式文件管理系统,功能齐全,非常便捷(带私活源码)

前言 在数字化时代&#xff0c;文件管理是企业和个人用户的基本需求。然而&#xff0c;现有的文件管理系统往往存在一些痛点&#xff0c;如存储空间有限、文件共享困难、缺乏在线编辑功能、移动端适配性差等。这些问题限制了用户在不同设备和场景下的文件处理能力。 为了解决…

spring-retry详解

spring-retry详解 1.引入依赖2.Retryable基础使用3.Recover使用4.Retryable参数详解5.需要注意 重试机制对于大部分场景来说都是必要的&#xff0c;比如同步调用三方接口&#xff0c;三方接口、信息拉取等网络原因突然不通&#xff0c;有了重试就可以多一些容错机制&#xff0c…

压缩包方式windows安装mysql

压缩包方式windows安装mysql 本文介绍通过压缩包方式在Windows本地安装mysql。 一、 具体步驟 步骤1&#xff0c;下载mysql压缩程序 这里好像上传不了压缩文件&#xff0c;先这样吧&#xff0c;后期补充。 步骤2&#xff0c;解压并手写添加 my.ini 文件 my.ini 文件内容如下…

Air780EP-AT开发-HTTP应用指南

简介 关联文档和使用工具&#xff1a; AT固件获取AT指令手册 概述 4G模块支持HTTP和HTTPS协议&#xff0c; HTTP应用的基本流程如下&#xff1a; 1、激活PDP&#xff08;参考&#xff1a;http://oldask.openluat.com/article/937&#xff09;2、初始化HTTP服务3、设置HTTP会话…

17_高级进程间通信 UNIX域套接字1

非命名的UNIX域套接字 第1个参数domain&#xff0c;表示协议族&#xff0c;只能为AF_LOCAL或者AF_UNIX&#xff1b; 第2个参数type&#xff0c;表示类型&#xff0c;只能为0。 第3个参数protocol&#xff0c;表示协议&#xff0c;可以是SOCK_STREAM或者SOCK_DGRAM。用SOCK_STR…

ontap simulator配置过程

一、下载模拟器 参考《Simulate_ONTAP_9-14-1_Installation_and_Setup_Guide.pdf》P4的指导&#xff0c;登录网站进行下载。 二、传入pve&#xff0c;并解压转换 # 解压 tar -xvf vsim-netapp-DOT9.14.1-cm_nodar.ova# 解压后的文件列表&#xff0c;其中ovf文件里定义了虚拟机…

Docker部署Elasticsearch8.6.0 Kibana8.6.0

为了匹配springboot3.0.x&#xff0c;安装Elasticsearch:8.5.3 拉取镜像&#xff0c;遇到问题&#xff01; [rootserver01 ~]# docker pull elasticsearch:8.5.3 8.5.3: Pulling from library/elasticsearch eaead16dc43b: Retrying in 1 second a405acf5b7d4: Retrying in 1…

结构体[C语言]

文章目录 结构体的概念结构体的用法定义结构体创建结构体变量访问结构体成员 结构体的应用 结构体的概念 结构体是一种用户自定义的数据类型&#xff0c;它允许我们将逻辑上相关的不同数据类型组合在一起。例如&#xff0c;如果我们想要表示一个学生的信息&#xff0c;我们可以…

texify - 识别数学/图像 PDF

文章目录 一、关于 texify例子训练 二、安装手动安装 三、使用1、使用技巧2、用于交互转换的应用程序3、转换图像4、Python 中导入并运行 四、限制五、基准测试运行自己的基准测试 六、其它商业用途感谢 一、关于 texify Texify是一种OCR模型&#xff0c;它将包含数学的图像或…

数据结构(Java):优先级队列(堆)堆的模拟实现PriorityQueue集合

目录 1、优先级队列 1.1 概念 1.2 PriorityQueue底层结构 2、 堆 2.1 堆的概念 2.2 堆的存储结构 3、优先级队列&#xff08;堆&#xff09;的模拟实现 3.1 堆的创建 3.1.1 向下调整算法建完整堆 3.2 堆的插入 3.2.1 向上调整算法 3.3 堆的删除 3.4 堆排序 4、Pri…

Java实现随机题库-全站最呆瓜思想,保证你能学会

目录 Blue留言 &#xff1a; 学本篇文章之前所需掌握技能 推荐视频&#xff1a; 代码逻辑思想 步骤&#xff1a; 1、引入依赖 2、做一个excel表格 3、java实现从excel表中取数据 第一步&#xff1a;根据excel上面的字段名&#xff08;如下图&#xff09;&#xff0…