数据挖掘——机器学习算法应用

于 2024-06-22 12:38:00 发布
阅读量1.1k 收藏 23
点赞数 28
分类专栏： 大数据人工智能 文章标签： 机器学习 数据挖掘 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66547608/article/details/139880359
版权

1. 朴素贝叶斯分类器

  1. 数据

Universal Bank 是一家业绩快速增长的银行。为了增加贷款业务，该银行探索将储蓄客户转变成个人贷款客户的方式。银行收集了5000条客户数据，包括客户特征（age、experience、income、family、 CCAvg、education、Zip Code）、客户对上一次贷款营销活动的响应（ Personal Loan ）、客户和银行的关系（ mortgage，securities account.online.CD account、credit card）共13个特征，目标值是 Personal Loan，即客户是否接受了个人贷款。

ID

Age

Experience

Income

ZIP Code

账户

年龄

经验

收入

邮政编码

Family

CCAvg

Education

Mortgage

Securities Account

家庭成员人数

信用卡月平均消费

教育水平

按揭贷款数目

证券账户

CD Account

Online

CreditCard

Personal Loan

定期存款

在线

信用卡

个人贷款

（目标值）

在5000个客户中，仅480个客户接受了提供给他们的个人贷款。

ID,Age,Experience,Income,ZIP Code,Family,CCAvg,Education,Mortgage,Personal Loan,Securities Account,CD Account,Online,CreditCard
1,25,1,49,91107,4,1.6,1,0,0,1,0,0,0
2,45,19,34,90089,3,1.5,1,0,0,1,0,0,0
3,39,15,11,94720,1,1,1,0,0,0,0,0,0
4,35,9,100,94112,1,2.7,2,0,0,0,0,0,0
5,35,8,45,91330,4,1,2,0,0,0,0,0,1
6,37,13,29,92121,4,0.4,2,155,0,0,0,1,0
7,53,27,72,91711,2,1.5,2,0,0,0,0,1,0
8,50,24,22,93943,1,0.3,3,0,0,0,0,0,1
9,35,10,81,90089,3,0.6,2,104,0,0,0,1,0
10,34,9,180,93023,1,8.9,3,0,1,0,0,0,0
11,65,39,105,94710,4,2.4,3,0,0,0,0,0,0
12,29,5,45,90277,3,0.1,2,0,0,0,0,1,0
13,48,23,114,93106,2,3.8,3,0,0,1,0,0,0
14,59,32,40,94920,4,2.5,2,0,0,0,0,1,0
15,67,41,112,91741,1,2,1,0,0,1,0,0,0
16,60,30,22,95054,1,1.5,3,0,0,0,0,1,1
17,38,14,130,95010,4,4.7,3,134,1,0,0,0,0
18,42,18,81,94305,4,2.4,1,0,0,0,0,0,0
19,46,21,193,91604,2,8.1,3,0,1,0,0,0,0
20,55,28,21,94720,1,0.5,2,0,0,1,0,0,1
21,56,31,25,94015,4,0.9,2,111,0,0,0,1,0
22,57,27,63,90095,3,2,3,0,0,0,0,1,0
23,29,5,62,90277,1,1.2,1,260,0,0,0,1,0
24,44,18,43,91320,2,0.7,1,163,0,1,0,0,0
25,36,11,152,95521,2,3.9,1,159,0,0,0,0,1
26,43,19,29,94305,3,0.5,1,97,0,0,0,1,0
27,40,16,83,95064,4,0.2,3,0,0,0,0,0,0
28,46,20,158,90064,1,2.4,1,0,0,0,0,1,1
29,56,30,48,94539,1,2.2,3,0,0,0,0,1,1
30,38,13,119,94104,1,3.3,2,0,1,0,1,1,1
31,59,35,35,93106,1,1.2,3,122,0,0,0,1,0
32,40,16,29,94117,1,2,2,0,0,0,0,1,0
33,53,28,41,94801,2,0.6,3,193,0,0,0,0,0
34,30,6,18,91330,3,0.9,3,0,0,0,0,0,0
35,31,5,50,94035,4,1.8,3,0,0,0,0,1,0
36,48,24,81,92647,3,0.7,1,0,0,0,0,0,0
37,59,35,121,94720,1,2.9,1,0,0,0,0,0,1
38,51,25,71,95814,1,1.4,3,198,0,0,0,0,0
39,42,18,141,94114,3,5,3,0,1,1,1,1,0
40,38,13,80,94115,4,0.7,3,285,0,0,0,1,0
41,57,32,84,92672,3,1.6,3,0,0,1,0,0,0
42,34,9,60,94122,3,2.3,1,0,0,0,0,0,0
43,32,7,132,90019,4,1.1,2,412,1,0,0,1,0
44,39,15,45,95616,1,0.7,1,0,0,0,0,1,0
45,46,20,104,94065,1,5.7,1,0,0,0,0,1,1
46,57,31,52,94720,4,2.5,1,0,0,0,0,0,1
47,39,14,43,95014,3,0.7,2,153,0,0,0,1,0
48,37,12,194,91380,4,0.2,3,211,1,1,1,1,1
49,56,26,81,95747,2,4.5,3,0,0,0,0,0,1
50,40,16,49,92373,1,1.8,1,0,0,0,0,0,1
51,32,8,8,92093,4,0.7,2,0,0,1,0,1,0
52,61,37,131,94720,1,2.9,1,0,0,0,0,1,0
53,30,6,72,94005,1,0.1,1,207,0,0,0,0,0
54,50,26,190,90245,3,2.1,3,240,1,0,0,1,0
55,29,5,44,95819,1,0.2,3,0,0,0,0,1,0
56,41,17,139,94022,2,8,1,0,0,0,0,1,0
57,55,30,29,94005,3,0.1,2,0,0,1,1,1,0
58,56,31,131,95616,2,1.2,3,0,1,0,0,0,0
59,28,2,93,94065,2,0.2,1,0,0,0,0,0,0
60,31,5,188,91320,2,4.5,1,455,0,0,0,0,0
61,49,24,39,90404,3,1.7,2,0,0,1,0,1,0
62,47,21,125,93407,1,5.7,1,112,0,1,0,0,0
63,42,18,22,90089,1,1,1,0,0,0,0,0,0
64,42,17,32,94523,4,0,2,0,0,0,0,1,0
65,47,23,105,90024,2,3.3,1,0,0,0,0,0,0
66,59,35,131,91360,1,3.8,1,0,0,0,0,1,1
67,62,36,105,95670,2,2.8,1,336,0,0,0,0,0
68,53,23,45,95123,4,2,3,132,0,1,0,0,0
69,47,21,60,93407,3,2.1,1,0,0,0,0,1,1
70,53,29,20,90045,4,0.2,1,0,0,0,0,1,0
71,42,18,115,91335,1,3.5,1,0,0,0,0,0,1
72,53,29,69,93907,4,1,2,0,0,0,0,1,0
73,44,20,130,92007,1,5,1,0,0,0,0,0,1
74,41,16,85,94606,1,4,3,0,0,0,0,1,1
75,28,3,135,94611,2,3.3,1,0,0,0,0,0,1
76,31,7,135,94901,4,3.8,2,0,1,0,1,1,1
77,58,32,12,91320,3,0.3,3,0,0,0,0,0,0
78,46,20,29,92220,3,0.5,2,0,0,0,0,0,0
79,54,30,133,93305,2,2.6,3,0,1,0,0,0,0
80,50,26,19,94720,2,0.4,1,118,0,0,0,1,0
81,60,36,41,95134,4,1.3,1,174,0,0,0,1,1
82,47,22,40,94612,3,2.7,2,0,0,0,0,1,0
83,41,16,82,92507,1,4,3,0,0,0,0,1,0
84,33,9,50,94305,1,2.4,2,0,0,0,0,0,0
85,46,22,18,91730,1,0.9,3,0,0,0,0,1,0
86,27,2,109,94005,4,1.8,3,0,0,0,0,0,0
87,40,16,42,94501,4,2.2,2,126,0,0,0,0,0
88,48,22,78,94305,3,1.1,1,0,0,0,0,1,0
89,65,41,51,94117,2,1.1,1,0,0,0,0,1,0

注意：数据集中的编号（ID）和邮政编码（ZIP CODE）特征因为在分类模型中无意义，所以在数据预处理阶段将它们删除。

  1. 使用高斯朴素贝叶斯分类器（特征为连续型变量）对数据进行分类
  • 使用留出法划分数据集，训练集:测试集为7:3。
  • 使用高斯朴素贝叶斯分类器对训练集进行训练
  • 使用训练好的模型对测试数据集进行预测并输出预测结果和模型准确度
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.naive_bayes import MultinomialNB

#1. 读入数据
df = pd.read_csv('universalbank.csv')
y = df['Personal Loan']
X = df.drop(['ID', 'ZIP Code', 'Personal Loan'], axis = 1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state = 0)

#2. 训练高斯朴素贝叶斯模型
gnb = GaussianNB()
gnb.fit(X_train, y_train)

# 3. 评估模型
y_pred = gnb.predict(X_test)
print('测试数据的预测结果:', y_pred)

acc = gnb.score(X_test, y_test)
print('GaussianNB模型的准确度:',acc)

        

  1. 使用多项式朴素贝叶斯（特征为离散型变量）对数据进行分类
  • 筛选出数据中的离散型特征
  • 使用留出法划分数据集，训练集:测试集为7:3。
  • 使用多项式朴素贝叶斯分类器对训练集进行训练
  • 使用训练好的模型对测试数据集进行预测并输出预测结果和模型准确度
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.naive_bayes import MultinomialNB
import matplotlib.pyplot as plt
#1. 读入数据
df = pd.read_csv('universalbank.csv')
# 1. 读入数据
y = df['Personal Loan']
X = df[['Family', 'Education', 'Securities Account', 
'CD Account', 'Online', 'CreditCard']]              #只选用6个特征
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state = 0)

#2. 训练多项式朴素贝叶斯模型
mnb = MultinomialNB()
mnb.fit(X_train, y_train)

y_pred = mnb.predict(X_test)
print('测试数据的预测结果:', y_pred)

acc = mnb.score(X_test, y_test)
print('MultinomialNB模型的准确度:',acc)

         

2. K近邻分类器（KNN）（4-2）

  1. 数据

使用第1题中的Universal Bank数据集。

注意：数据集中的编号（ID）和邮政编码（ZIP CODE）特征因为在分类模型中无意义，所以在数据预处理阶段将它们删除。

  1. 使用KNN对数据进行分类
  1. 使用留出法划分数据集，训练集:测试集为7:3。
  1. 使用KNN对训练集进行训练

最近邻的数量K设置为5。

  1. 使用训练好的模型对测试集进行预测并输出预测结果和模型准确度
# 导入所需的库
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
import pprint

# 禁用输出省略
pd.set_option('display.max_rows', None)
pd.set_option('display.max_columns', None)
pd.set_option('display.width', None)
pd.set_option('display.max_colwidth', None)

# 读取数据集
data = pd.read_csv("universalbank.csv")

# 数据预处理：删除无意义特征
data = data.drop(columns=['ID', 'ZIP Code'])

# 划分特征和标签
X = data.drop(columns=['Personal Loan'])
y = data['Personal Loan']

# 使用留出法划分数据集，训练集:测试集为7:3
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 使用KNN算法对训练集进行训练，最近邻的数量K设置为5
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

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

# 输出预测结果
for item in y_pred:
    print(item, end='\n')  # 每项后面都换行，这样就不会合并在一起
print("预测结果:")
print(y_pred)

# 输出模型准确度
accuracy = accuracy_score(y_test, y_pred)
print("模型准确度:", accuracy)

         

2. CART决策树（4-2）

  1. 数据

使用第1题中的Universal Bank数据集。

注意：数据集中的编号（ID）和邮政编码（ZIP CODE）特征因为在分类模型中无意义，所以在数据预处理阶段将它们删除。

  1. 使用CART决策树对数据进行分类
  1. 使用留出法划分数据集，训练集:测试集为7:3。
  1. 使用CART决策树对训练集进行训练

决策树的深度限制为10层，max_depth=10。

  1. 使用训练好的模型对测试集进行预测并输出预测结果和模型准确度
  2. 可视化训练好的CART决策树模型
  1. 安装graphviz模块

首先在windows系统中安装graphviz模块

32位系统使用windows_10_cmake_Release_graphviz-install-10.0.1-win32.exe

64位系统使用windows_10_cmake_Release_graphviz-install-10.0.1-win64.exe

注意：安装时使用下图中圈出的选项

安装完成后使用pip install graphviz指令在python环境中安装graphviz库。

  1. 使用graphviz模块可视化模型
# 导入所需的库
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

# 读取数据集
data = pd.read_csv("universalbank.csv")

# 数据预处理：删除无意义特征
data = data.drop(columns=['ID', 'ZIP Code'])

# 划分特征和标签
X = data.drop(columns=['Personal Loan'])
y = data['Personal Loan']

# 使用留出法划分数据集，训练集:测试集为7:3
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 使用CART决策树对训练集进行训练，深度限制为10层
model = DecisionTreeClassifier(max_depth=10)
model.fit(X_train, y_train)

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

# 输出预测结果和模型准确度
accuracy = accuracy_score(y_test, y_pred)
print("模型准确度:", accuracy)

# 可视化训练好的CART决策树模型
dot_data = export_graphviz(model, 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("Universal_Bank_CART6")  # 保存为PDF文件

 

 

4.神经网络回归任务（4-3）

  1. 数据
  1. 使用留出法划分数据集，训练集:测试集为7:3。
  1. 使用多层感知机回归模型对训练集进行训练
  1. 使用训练好的模型对测试集进行预测并输出预测结果和模型的MSE和MAE。
  1. 使用训练好的模型对如下数据的房价进行预测并输出结果

数据：[3.0,2.5,1490,8102,2.0,0,0,4,1490,0,1990,0]

 

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error

# 读取数据
df = pd.read_csv('house-price.csv')
df = df.drop(columns=['date', 'street', 'city', 'statezip', 'country'])

# 设置特征名称
feature_names = ['bedrooms', 'bathrooms', 'sqft_living', 'sqft_lot', 'floors', 'waterfront', 'view', 'condition', 'sqft_above', 'sqft_basement', 'yr_built', 'yr_renovated']
X = df[feature_names]
y = df['price']

# 使用留出法划分数据集，训练集:测试集为7:3
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 初始化多层感知机回归模型，并设置参数
model = MLPRegressor(max_iter=1000, random_state=42, hidden_layer_sizes=(100,))

# 对训练集进行训练
model.fit(X_train, y_train)

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

# 计算模型的均方误差（MSE）和平均绝对误差（MAE）
mse = mean_squared_error(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)

# 输出预测结果和模型的MSE和MAE
print("预测结果：", y_pred)
print("模型的均方误差（MSE）：", mse)
print("模型的平均绝对误差（MAE）：", mae)

# 创建新数据
new_data = pd.DataFrame([[3.0, 2.5, 1490, 8102, 2.0, 0, 0, 4, 1490, 0, 1990, 0]], columns=feature_names)

# 使用训练好的模型对提供的数据进行预测
predicted_price = model.predict(new_data)
print("提供的数据的房价预测结果：", predicted_price)

 

 

5.神经网络分类任务（4-3）

  1. 数据
  1. 用1-10行数据作为训练集，用11-20行数据作为测试集。
  2. 使用多层感知机分类模型对训练集进行训练
  1. 使用训练好的模型对测试集进行预测并输出预测结果和模型准确度。
  2. 使用模型对21-25行数据的贷款申请进行评估，输出评估结果（1为同意，0为拒绝）。

 

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt

# 加载数据
df = pd.read_excel('企业贷款审批数据表.xlsx')  # 请替换成你的数据文件路径

# 划分训练集和测试集
train_data = df.iloc[0:17]  # 使用1-17行数据作为训练集
test_data = df.iloc[17:20]  # 使用18-20行数据作为测试集

# 特征和标签
X_train = train_data.drop(columns=['Y'])  # 特征
y_train = train_data['Y']  # 标签
X_test = test_data.drop(columns=['Y'])  # 特征
y_test = test_data['Y']  # 标签

# 初始化多层感知机分类模型
model = MLPClassifier(max_iter=1000, random_state=42)

# 训练模型并记录损失值
history = model.fit(X_train, y_train)

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

# 计算模型准确度
accuracy = accuracy_score(y_test, y_pred)
print("模型准确度：", accuracy)

# 准备新数据
new_data = df.iloc[20:25].drop(columns=['Y'])

# 使用训练好的模型进行评估
evaluation_result = model.predict(new_data)
print("评估结果：", evaluation_result)

# 创建一个图形对象
fig, ax = plt.subplots(2, 1, figsize=(10, 10))

# 绘制训练过程中的损失值变化
ax[0].plot(model.loss_curve_, label='训练损失')
ax[0].set_title('训练过程中的损失值变化')
ax[0].set_xlabel('迭代次数')
ax[0].set_ylabel('损失值')
ax[0].legend()

# 绘制预测结果与实际值的对比折线图
ax[1].plot(y_test.values, label='实际值', marker='o')
ax[1].plot(y_pred, label='预测值', marker='x')
ax[1].set_title('预测结果与实际值的对比')
ax[1].set_xlabel('样本索引')
ax[1].set_ylabel('值')
ax[1].legend()

# 显示图形
plt.tight_layout()
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.show()

 

6.关联规则分析（4-4）

  1. 安装mlxtend库

        pip install mlxtend

  1. 数据读取与预处理
  1. 使用pd.read_excel()读取并转换为下图中所示Python List
  1. 使用TransactionEncoder将上图中列表转换为下图中所示DataFrame
  1. 使用apriori算法挖掘频繁项集（最小支持度为0.3），并输出结果

（4）使用FP-growth算法挖掘频繁项集（最小支持度为0.3），并输出结果，与上一问结果进行对比

（5）生成强规则(最小置信度为0.5, 提升度>1)，并输出结果

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

# 步骤2：数据读取与预处理
data = {
    'I1': ['西红柿', '排骨', '鸡蛋', '毛巾', '水果刀', '苹果'],
    'I2': ['西红柿', '茄子', '水果刀', '香蕉'],
    'I3': ['鸡蛋', '袜子', '毛巾', '肥皂', '苹果', '水果刀'],
    'I4': ['西红柿', '排骨', '茄子', '毛巾', '水果刀'],
    'I5': ['西红柿', '排骨', '酸奶', '苹果'],
    'I6': ['鸡蛋', '茄子', '酸奶', '肥皂', '苹果', '香蕉'],
    'I7': ['排骨', '鸡蛋', '茄子', '水果刀', '苹果'],
    'I8': ['土豆', '鸡蛋', '袜子', '香蕉', '苹果', '水果刀'],
    'I9': ['西红柿', '排骨', '鞋子', '土豆', '香蕉', '苹果']
}

transactions = list(data.values())

# 步骤3：使用TransactionEncoder将列表转换为DataFrame
te = TransactionEncoder()
te_ary = te.fit(transactions).transform(transactions)
print(te_ary)
df = pd.DataFrame(te_ary, columns=te.columns_)

# 步骤4：使用apriori算法挖掘频繁项集（最小支持度为0.3），并输出结果
frequent_itemsets_apriori = apriori(df, min_support=0.3, use_colnames=True)
print("使用Apriori算法挖掘频繁项集:")
print(frequent_itemsets_apriori.to_string(index=False))

# 步骤5：使用FP-growth算法挖掘频繁项集（最小支持度为0.3），并输出结果，与上一问结果进行对比
frequent_itemsets_fpgrowth = fpgrowth(df, min_support=0.3, use_colnames=True)
print("\n使用FP-growth算法挖掘频繁项集:")
print(frequent_itemsets_fpgrowth.to_string(index=False))

# 步骤6：生成强规则(最小置信度为0.5, 提升度>1)，并输出结果
rules = association_rules(frequent_itemsets_apriori, metric="confidence", min_threshold=0.5)
rules = rules[rules['lift'] > 1]
print("\n强规则:")
print(rules.to_string(index=False))

 

7.时间序列分析（4-5）

  1. 安装statsmodels库

pip install statsmodels

  1. 数据读取与预处理 

使用pd.read_csv()读取并对日期数据进行转换

  1. 检测序列的平稳性
    1. 时序图判断法

                

 

    1. 制自相关图判断法

                

 

  1. 使用ADF单位根检测法

 

注意：p>0.05即为非平稳序列 

  1. 差分处理

 

# 差分处理
diff_data = data.diff().dropna()

 

 

 

 

注意：根据上一步结果判断数据序列为非平稳序列，如想使用模型对数据进行建模，则需将数据转换为平稳序列。所以在这一步使用差分处理对序列进行处理。

对处理后的序列进行平稳性检测（自相关图法、偏相关图法、ADF检测法）

  1. 使用ARIMA模型对差分处理后的序列进行建模
  1. 使用模型预测未来5个月的销售额

 

 

 

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.stattools import adfuller
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
from statsmodels.tsa.arima.model import ARIMA
import io
# 读取数据并进行预处理
data = """
"Month","Sales"
"1-01",266.0
"1-02",145.9
"1-03",183.1
"1-04",119.3
"1-05",180.3
"1-06",168.5
"1-07",231.8
"1-08",224.5
"1-09",192.8
"1-10",122.9
"1-11",336.5
"1-12",185.9
"2-01",194.3
"2-02",149.5
"2-03",210.1
"2-04",273.3
"2-05",191.4
"2-06",287.0
"2-07",226.0
"2-08",303.6
"2-09",289.9
"2-10",421.6
"2-11",264.5
"2-12",342.3
"3-01",339.7
"3-02",440.4
"3-03",315.9
"3-04",439.3
"3-05",401.3
"3-06",437.4
"3-07",575.5
"3-08",407.6
"3-09",682.0
"3-10",475.3
"3-11",581.3
"3-12",646.9
"""

# 将字符串转换为DataFrame
data = pd.read_csv(io.StringIO(data))

# 将'Month'列转换为日期类型
data['Month'] = pd.to_datetime(data['Month'], format='%m-%d')
# 将'Month'列转换为日期类型，并设置年份为2024年
data['Month'] = pd.to_datetime(data['Month'], format='%y-%m', yearfirst=True).dt.strftime('2024-%m')
print(data)
# 将日期列设置为索引
data.set_index('Month', inplace=True)

# 绘制时序图
data.plot(figsize=(10, 6))
plt.xlabel('Month')
plt.ylabel('Sales')
plt.title('Time Series of Sales')
plt.show()

# 检测序列的平稳性
# 自相关图
plot_acf(data, lags=9)
plt.title('Autocorrelation Plot')
plt.show()

# 偏相关图
plot_pacf(data, lags=9)
plt.title('Partial Autocorrelation Plot')
plt.show()

# ADF检验
adf_result = adfuller(data['Sales'])
print('ADF Statistic:', adf_result[0])
print('p-value:', adf_result[1])
print('Critical Values:', adf_result[4])

# 差分处理
diff_data = data.diff().dropna()

# 绘制差分后的时序图
diff_data.plot(figsize=(10, 6))
plt.xlabel('Month')
plt.ylabel('Sales (Differenced)')
plt.title('Differenced Time Series of Sales')
plt.show()

# 差分后的序列平稳性检测
# 自相关图
plot_acf(diff_data, lags=9)
plt.title('Autocorrelation Plot (Differenced)')
plt.show()

# 偏相关图
plot_pacf(diff_data, lags=9)
plt.title('Partial Autocorrelation Plot (Differenced)')
plt.show()

# ADF检验
adf_result_diff = adfuller(diff_data['Sales'])
print('ADF Statistic (Differenced):', adf_result_diff[0])
print('p-value (Differenced):', adf_result_diff[1])
print('Critical Values (Differenced):', adf_result_diff[4])

# 使用ARIMA模型建模
model = ARIMA(data, order=(1, 1, 1))
model_fit = model.fit()

# 打印模型的概要信息
print(model_fit.summary())

# 预测未来5个月的销售额
forecast_steps = 5
forecast = model_fit.forecast(steps=5)
# 生成未来几个月的日期
last_month = data.index[-1]
future_months = pd.date_range(start=last_month, periods=forecast_steps + 1, freq='M')[1:]

# 创建包含日期和预测销售额的DataFrame
forecast_df = pd.DataFrame({'Month': future_months, 'Forecasted Sales': forecast})

# 输出预测结果
print('Forecasted Sales for the next 5 months:')
print(forecast_df)

 

张謹礧
关注
  • 28
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
机器学习之朴素贝叶斯分类器原理详解、公式推导（手推）、面试问题、简单实例（python实现，sklearn调包）
如果没有躺赢的命，那就站起来奔跑，你的努力一定会对得起这一路的颠沛流离。
02-07 1万+
主要内容分为理论推导和代码实现以及面试宝典三个部分。 理论推导主要是贝叶斯的推导以及朴素贝叶斯计算实例。 代码实现包括手动实现朴素贝叶斯和sklearn调用，实例有3个，分别对应离散型诗句和连续型数据两种情况。 面试宝典是一部分《机器学习》中的课后习题和一些面试题。
机器学习笔记07---朴素贝叶斯分类器
m0_64007201的博客
10-29 3552
朴素贝叶斯分类器
机器学习笔记之线性分类——朴素贝叶斯分类器(Naive Bayes Classifier)
静静的学习就好
09-02 1943
本节将介绍一个经典的基于线性分类的概率生成模型——朴素贝叶斯分类器(Naive Bayes Classifier)。
【机器学习】朴素贝叶斯分类器原理（理论+图解）
CSDN 精品推荐
07-14 3124
  简 介：下面是我在学习时候的记录并加上自己的理解。本文意在记录自己近期学习过程中的所学所得，如有错误，欢迎大家指正。   关键词：Python、机器学习、贝叶斯分类器 一、贝叶斯网络 我们都学过贝叶斯公式，就是 p(b∣a)=p(a∣b)p(b)p(a)p(b|a)=\frac{p(a|b)p(b)}{p(a)}p(b∣a)=p(a)p(a∣b)p(b)​，它表明了两个随机变量之间的概率关系，意思是在a条件发生的前提下，b发生的概率为多大。所以我们可以将这个性质利用到我们的建模..
【机器学习】十大算法之一 “朴素贝叶斯”
Code_and516的博客
06-13 3859
朴素贝叶斯算法是一种监督学习的算法，通过计算条件概率来预测或分类数据。它的核心思想是贝叶斯定理，即后验概率等于先验概率与似然函数的乘积除以证据因子。在文本分类的应用中，假设我们有一个文档和一个文档分类，我们想要判断这个文档属于哪个分类。我们可以将文档中的每个词都看作一个特征，每个特征的值为 0 或 1，0 表示该词不在文档中，1 表示该词在文档中。这样，我们就可以将每个文档表示为一个特征向量。然后，我们可以使用朴素贝叶斯算法来计算每个分类的条件概率，并选择条件概率最大的分类作为文档所属的分类。
机器学习算法与应用.pdf
09-24
机器学习算法与应用.pdf 机器学习是人工智能的核心和基础，研究机器学习是实现人工智能的重要步骤。机器学习算法是机器学习的核心部分，它决定了机器学习的性能和效果。本文将从三个方面介绍机器学习算法：典型机器...
数据挖掘与机器学习——经典图书介绍.pdf
09-24
本书主要从机器学习的角度，也有称从数据挖掘的应用实现角度来讲解数据挖掘，描述了各种算法、模型及其Java实现，重点是以应用的观点利用案例来说明数据挖掘的算法模型，对于具体算法的原理介绍不是非常详细。...
机器学习——逻辑回归数据集
03-22
train.csv中存储了原始数据，每人拥有年龄，工作类型等14个维度，共32561个样本。最后一个维度为label，即收入是否大于50k。
2022中山大学机器学习与数据挖掘
最新发布
04-29
机器学习是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。它专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的...
机器学习与数据挖掘实验三.doc
01-12
在本实验中，学生将通过探索IRIS鸢尾花数据集进行聚类分析，这是机器学习与数据挖掘领域的一个经典实例。实验旨在让学生熟悉并掌握关键的机器学习概念、模型和算法，特别是聚类分析。 首先，实验目标是让学生理解和...
机器学习-朴素贝叶斯分类
qq_52233007的博客
11-29 1835
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考优点：1、朴素贝叶斯模型发源于古典数学理论，有着坚实的数学基础，以及稳定的分类效率。2、NBC模型所需估计的参数很少，对缺失数据不太敏感，算法也比较简单。缺点：1、理论上，NBC模型与其他分类方法相比具有最小的误差率。
朴素贝叶斯分类器（Naive Bayes Classifier）
Yizhibi_CEO的博客
07-06 806
尽管它对特征条件独立性的假设在现实世界中很少成立，但朴素贝叶斯仍然在文本分类和情感分析等领域取得了良好的效果。2. 特征提取：将文本样本转换为特征向量表示。4. 计算条件概率：对于每个特征和每个情感类别，计算在该情感类别下该特征出现的条件概率。3. 计算先验概率：根据训练数据集中的标签，计算每个情感类别的先验概率。先验概率指的是在未观察到任何特征的情况下，某个样本属于某个情感类别的概率。5. 预测分类：对于新的文本样本，根据特征向量计算每个情感类别的后验概率，并选择具有最高后验概率的类别作为预测结果。
【海量数据挖掘/数据分析】 之 贝叶斯分类算法（朴素贝叶斯分类、贝叶斯分类计算流程、拉普拉斯修正、贝叶斯分类实例计算）
仙魁XAN
07-03 7373
【海量数据挖掘/数据分析】 之 贝叶斯分类算法（朴素贝叶斯分类、贝叶斯分类计算流程、拉普拉斯修正、贝叶斯分类实例计算） 一、 贝叶斯分类器 1 . 贝叶斯分类器 : 2 . 贝叶斯分类器的类型 : 3 . 正向概率 与 逆向概率 : 4 . 贝叶斯公式 : 有两个事件 , 事件 A , 和事件 B ; 二、 贝叶斯分类器处理多属性数据集方案 三、 贝叶斯分类器分类的流程 四、拉普拉斯修正 五、贝叶斯分类器示例 六、 朴素贝叶斯分类器使用 七、 朴素贝叶斯分类的优缺点
【NLP入门教程】十七、朴素贝叶斯分类器
m0_68629936的博客
06-28 442
朴素贝叶斯分类器基于贝叶斯定理，利用特征的条件概率来进行分类。假设有一个样本x=(x₁, x₂, …, xn)，其中x₁, x₂, …, xn是特征。朴素贝叶斯分类器的核心思想是假设给定类别C的条件下，特征之间是相互独立的。根据贝叶斯定理，我们可以计算后验概率P(C|x)如下：其中，P©是类别C的先验概率，P(x|C)是在给定类别C的情况下特征x的条件概率，P(x)是特征x的概率。
机器学习 --- 朴素贝叶斯分类器
学习日常分享
06-23 2万+
第1关：条件概率 任务描述 本关任务：根据本节课所学知识完成本关所设置的选择题。 相关知识 为了完成本关任务，你需要掌握条件概率。 条件概率 朴素贝叶斯分类算法是基于贝叶斯定理与特征条件独立假设的分类方法，因此想要了解朴素贝叶斯分类算法背后的算法原理，就不得不用到概率论的一些知识，首当其冲就是条件概率。接下来就开启我们的条件概率之旅吧。 什么是条件概率 概率指的是某一事件A发生的可能性，表示为P(A)。而条件概率指的是某一事件A已经发生了条件下，另一事件B发生的可能性，表示为P(B|A)，举个例子： 今天有
朴素贝叶斯分类器（Naive Bayes Classifiers）
热门推荐
K.Sun
03-03 5万+
原文地址：Naive Bayes Classifiers 本文讨论的是朴素贝叶斯分类器（ Naive Bayes classifiers）背后的理论以及其的实现。朴素贝叶斯分类器是分类算法集合中基于贝叶斯理论的一种算法。它不是单一存在的，而是一个算法家族，在这个算法家族中它们都有共同的规则。例如每个被分类的特征对与其他的特征对都是相互独立的。开始之前，先看一下数据集。这是一个虚构的数据集，这个
朴素贝叶斯分类【原理推导+实例】
v20000727的博客
12-22 1688
贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素贝叶斯(Naive Bayes)分类假设特征之间相互独立，是贝叶斯分类中最简单一种分类方法。
机器学习算法——贝叶斯分类器3（朴素贝叶斯分类器）
Vicky_xiduoduo的博客
04-28 6803
基于贝叶斯公式来估计后验概率P(c|x)的主要困难在于：类条件概率P(x|c)是所有属性上的联合概率，难以从有限的训练样本直接估计而得。 为避开这个障碍，朴素贝叶斯分类器（Naive Bayes classfier）采用了“属性条件独立性假设”：对已知类别，假设所有属性相互独立。换句话说，每个属性独立地对分类结果产生影响。 基于属性条件独立性假设，可重写P(c|x) 其中，d为属性数目，为x在第i个属性上的取值。由于对所有类别来说P(x)相同，则贝叶斯判定准则为(即朴素贝叶斯分类器的表达式)：
数据挖掘实践：机器学习与技术指南
"数据挖掘（非扫描版）——一本实用的机器学习类工具书，由Ian H. Witten和Eibe Frank合著，属于Morgan Kaufmann Series in Data Management Systems系列，涵盖了数据挖掘和机器学习的实用技术和工具。" 在数据挖掘...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

张謹礧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值