【数据挖掘】实验8：分类与预测建模

于 2024-04-17 19:28:11 发布
阅读量1.7k 收藏 11
点赞数 26
分类专栏： 专业选修课系列 文章标签： 数据挖掘 分类 人工智能 R 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65787507/article/details/137885445
版权

实验8：分类与预测建模

一：实验目的与要求

1：学习和掌握回归分析、决策树、人工神经网络、KNN算法、朴素贝叶斯分类等机器学习算法在R语言中的应用。

2：了解其他分类与预测算法函数。

3：学习和掌握分类与预测算法的评价。

二：实验内容

【回归分析】

Eg.1：

attach(women)

fit<-lm(weight ~ height)

plot(height,weight)

abline(fit,col="red")

detach(women)

【线性回归模型】

Eg.1：利用数据集women建立简单线性回归模型

data(women)

lm.model <- lm( weight ~ height - 1, data = women)  # 建立线性回归模型

summary(lm.model)  # 输出模型的统计信息

coefficients(lm.model)  # 输出参数估计值

confint(lm.model, parm = "speed", level = 0.95)  # parm缺省则计算所有参数的置信区间

fitted(lm.model)  # 列出拟合模型的预测值

anova(lm.model)  # 生成一个拟合模型的方差分析表

vcov(lm.model)  # 列出模型参数的协方差矩阵

residuals(lm.model)  # 列出模型的残差

AIC(lm.model)  # 输出AIC值

par(mfrow = c(2, 2))

plot(lm.model)  # 生成评价拟合模型的诊断图

【逻辑回归模型】

Eg.1：结婚时间、教育、宗教等其它变量对出轨次数的影响

install.packages("AER")

library(AER)

data(Affairs, package = "AER")

# 由于变量affairs为正整数，为了进行Logistic回归先要将其转化为二元变量。

Affairs$ynaffair[Affairs$affairs > 0] <- 1

Affairs$ynaffair[Affairs$affairs == 0] <- 0

Affairs$ynaffair <- factor(Affairs$ynaffair, levels = c(0, 1),

                           labels = c("No", "Yes"))

# 建立Logistic回归模型

model.L <- glm(ynaffair ~ age + yearsmarried + religiousness + rating,

               data = Affairs, family = binomial (link = logit))

summary(model.L)  # 展示拟合模型的详细结果

predictdata <- data.frame(Affairs[, c("age", "yearsmarried", "religiousness", "rating")])

# 由于拟合结果是给每个观测值一个概率值，下面以0.4作为分类界限

predictdata$y <- (predict(model.L, predictdata, type = "response") > 0.4)

predictdata$y[which(predictdata$y == FALSE)] = "No"  # 把预测结果转换成原先的值(Yes或No)

predictdata$y[which(predictdata$y == TRUE)] = "Yes"

confusion <- table(actual = Affairs$ynaffair, predictedclass = predictdata$y)  # 混淆矩阵

confusion

(sum(confusion) - sum(diag(confusion))) / sum(confusion)  # 计算错判率

【Bonferroni离群点检验】

Eg.1：对美国妇女的平均身高和体重数据进行Bonferroni离群点检验

install.packages("car")

library(car)

fit <- lm(weight ~ height, data = women)  # 建立线性模型

outlierTest(fit)   # Bonferroni离群点检验

women[10, ] <- c(70, 200)  # 将第10个观测的数据该成height = 70，weight = 200

fit <- lm(weight ~ height, data = women)

outlierTest(fit)  # Bonferroni离群点检验

【检验误差项的自相关性】

Eg.1：对模型lm.model的误差做自相关性检验

durbinWatsonTest(lm.model)

【自变量选择】

Eg.1：使用数据集freeny建立逻辑回归模型，并进行自变量选择

Data <-  freeny

lm <- lm(y ~ ., data = Data)  # logistic回归模型

summary(lm)

lm.step <- step(lm, direction = "both")  # 一切子集回归

summary(lm.step)

lm.step <- step(lm, direction = "forward")  # 前进法

summary(lm.step)

lm.step <- step(lm, direction = "backward")  # 后退法

summary(lm.step)

【C4.5决策树】

Eg.1：C4.5决策树预测客户是否流失

Data <- read.csv("Telephone.csv",fileEncoding = "GB2312")  # 读入数据

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立决策树模型预测客户是否流失

install.packages("matrixStats")

install.packages("party")

library(party)  # 加载决策树的包

ctree.model <- ctree(流失 ~ ., data = traindata)  # 建立C4.5决策树模型

plot(ctree.model, type = "simple")  # 输出决策树图

# 预测结果

train_predict <- predict(ctree.model)  # 训练数据集

test_predict <- predict(ctree.model, newdata = testdata)  # 测试数据集

# 输出训练数据的分类结果

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

#输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict) )

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【CART决策树】

Eg.1：CART决策树预测客户是否流失

Data <- read.csv("telephone.csv",fileEncoding = "GB2312")  # 读入数据

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立决策树模型预测客户是否流失

install.packages("tree")

library(tree)  # 加载决策树的包

tree.model <- tree(流失 ~ ., data = traindata)  # 建立CART决策树模型

plot(tree.model, type = "uniform")  # 输出决策树图

text(tree.model)

# 预测结果

train_predict <- predict(tree.model, type = "class")  # 训练数据集

test_predict <- predict(tree.model, newdata = testdata, type = "class")  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【C5.0决策树】

Eg.1：C5.0决策树预测客户是否流失

Data <- read.csv("telephone.csv",fileEncoding = "GB2312")  # 读入数据

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立决策树模型预测客户是否流失

install.packages("C50")

library(C50)  # 加载决策树的包

c50.model <- C5.0(流失 ~ ., data = traindata)  # 建立C5.0决策树模型

plot(c50.model)  # 输出决策树图

# 预测结果

train_predict <- predict(c50.model, newdata = traindata, type = "class")  # 训练数据集

test_predict <- predict(c50.model, newdata = testdata, type = "class")  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【BP神经网络】

Eg.1：BP神经网络算法预测客户是否流失

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# BP神经网络建模

library(nnet) #加载nnet包

# 设置参数

size <- 10  # 隐层节点数为10

decay <- 0.05  # 权值的衰减参数为0.05

nnet.model <- nnet(流失 ~ ., traindata, size = size, decay = decay)  # 建立BP神经网络模型

summary(nnet.model)  # 输出模型概要

# 预测结果

train_predict <- predict(nnet.model, newdata = traindata, type = "class")  # 训练数据集

test_predict <- predict(nnet.model, newdata = testdata, type = "class")  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【KNN算法】

Eg.1：KNN算法预测客户是否流失

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 使用kknn函数建立knn分类模型

install.packages("kknn")

library(kknn)  # 加载kknn包

# knn分类模型

kknn.model <- kknn(流失 ~ ., train = traindata, test = traindata, k = 5)  # 训练数据

kknn.model2 <- kknn(流失 ~ ., train = traindata, test = testdata, k = 5)  # 测试数据

summary(kknn.model)  # 输出模型概要

# 预测结果

train_predict <- predict(kknn.model)  # 训练数据

test_predict <- predict(kknn.model2)  # 测试数据

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

# 使用knn函数建立knn分类模型

library(class)  # 加载class包

# 建立knn分类模型

knn.model <- knn(traindata, testdata, cl = traindata[, "流失"])

# 输出测试数据的混淆矩阵

(test_confusion = table(actual = testdata$流失, predictedclass = knn.model))

# 使用train函数建立knn分类模型

install.packages("caret")

library(caret)  # 加载caret包

# 建立knn分类模型

train.model <- train(traindata, traindata[, "流失"], method = "knn")

# 预测结果

train_predict <- predict(train.model, newdata = traindata)      #训练数据集

test_predict <- predict(train.model, newdata = testdata)       #测试数据集

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

运行结果：

模型概要输出

Call:

kknn(formula = 流失 ~ ., train = traindata, test = traindata,     k = 5)

Response: "nominal"

    fit     prob.0     prob.1

1     1 0.33609798 0.66390202

2     1 0.25597771 0.74402229

3     0 0.97569952 0.02430048

4     0 0.51243637 0.48756363

5     0 1.00000000 0.00000000

6     1 0.17633839 0.82366161

7     0 0.59198438 0.40801562

8     0 1.00000000 0.00000000

9     0 1.00000000 0.00000000

10    1 0.36039846 0.63960154

11    0 0.74402229 0.25597771

12    0 0.84796209 0.15203791

13    0 0.89557925 0.10442075

14    0 1.00000000 0.00000000

15    0 1.00000000 0.00000000

16    0 0.74402229 0.25597771

17    1 0.02430048 0.97569952

18    1 0.15203791 0.84796209

19    0 1.00000000 0.00000000

20    0 0.97569952 0.02430048

21    0 0.97569952 0.02430048

22    0 1.00000000 0.00000000

23    0 0.76784183 0.23215817

24    0 0.74354135 0.25645865

25    0 0.74402229 0.25597771

26    0 1.00000000 0.00000000

27    0 1.00000000 0.00000000

28    0 0.51186411 0.48813589

29    0 1.00000000 0.00000000

30    0 0.97569952 0.02430048

31    0 1.00000000 0.00000000

32    0 0.56768390 0.43231610

33    0 0.84796209 0.15203791

34    0 0.66390202 0.33609798

35    1 0.00000000 1.00000000

36    0 1.00000000 0.00000000

37    0 1.00000000 0.00000000

38    0 0.84796209 0.15203791

39    1 0.25597771 0.74402229

40    1 0.48813589 0.51186411

41    1 0.36039846 0.63960154

42    0 0.97569952 0.02430048

43    0 0.89557925 0.10442075

44    0 1.00000000 0.00000000

45    0 0.51243637 0.48756363

46    0 0.66390202 0.33609798

47    0 0.74402229 0.25597771

48    0 1.00000000 0.00000000

49    0 1.00000000 0.00000000

50    0 1.00000000 0.00000000

51    1 0.36039846 0.63960154

52    0 0.91987973 0.08012027

53    0 1.00000000 0.00000000

54    0 0.91987973 0.08012027

55    1 0.25597771 0.74402229

56    0 0.89557925 0.10442075

57    0 0.91987973 0.08012027

58    0 1.00000000 0.00000000

59    0 0.56768390 0.43231610

60    1 0.48813589 0.51186411

61    0 1.00000000 0.00000000

62    0 1.00000000 0.00000000

63    1 0.48756363 0.51243637

64    0 0.51243637 0.48756363

65    0 0.51243637 0.48756363

66    0 0.84796209 0.15203791

67    0 0.84796209 0.15203791

68    0 0.76784183 0.23215817

69    1 0.02430048 0.97569952

70    1 0.00000000 1.00000000

71    0 0.84796209 0.15203791

72    0 0.76784183 0.23215817

73    0 0.76784183 0.23215817

74    1 0.15203791 0.84796209

75    1 0.02430048 0.97569952

76    0 1.00000000 0.00000000

77    0 0.51243637 0.48756363

78    1 0.36039846 0.63960154

79    0 0.71972181 0.28027819

80    0 0.82366161 0.17633839

81    1 0.36039846 0.63960154

82    1 0.23215817 0.76784183

83    0 0.76784183 0.23215817

84    1 0.00000000 1.00000000

85    0 1.00000000 0.00000000

86    0 0.66390202 0.33609798

87    0 1.00000000 0.00000000

88    0 0.91987973 0.08012027

89    1 0.23215817 0.76784183

90    0 1.00000000 0.00000000

91    0 0.91987973 0.08012027

92    0 1.00000000 0.00000000

93    0 1.00000000 0.00000000

94    1 0.10442075 0.89557925

95    0 0.91987973 0.08012027

96    0 0.74354135 0.25645865

97    1 0.25645865 0.74354135

98    1 0.33609798 0.66390202

99    0 0.91987973 0.08012027

100   1 0.25645865 0.74354135

101   0 1.00000000 0.00000000

102   1 0.28027819 0.71972181

103   0 0.66390202 0.33609798

104   0 0.51186411 0.48813589

105   0 0.56768390 0.43231610

106   0 0.84796209 0.15203791

107   0 0.76784183 0.23215817

108   0 1.00000000 0.00000000

109   0 0.76784183 0.23215817

110   0 0.91987973 0.08012027

111   1 0.43231610 0.56768390

112   0 1.00000000 0.00000000

113   0 0.97569952 0.02430048

114   0 1.00000000 0.00000000

115   0 0.76784183 0.23215817

116   0 0.63960154 0.36039846

117   0 0.97569952 0.02430048

118   1 0.15203791 0.84796209

119   0 0.74402229 0.25597771

120   0 1.00000000 0.00000000

121   0 1.00000000 0.00000000

122   0 0.91987973 0.08012027

123   0 1.00000000 0.00000000

124   0 0.74354135 0.25645865

125   0 1.00000000 0.00000000

126   1 0.43231610 0.56768390

127   0 0.71972181 0.28027819

128   1 0.08012027 0.91987973

129   0 0.91987973 0.08012027

130   1 0.10442075 0.89557925

131   0 1.00000000 0.00000000

132   0 0.91987973 0.08012027

133   0 0.51243637 0.48756363

134   0 0.66390202 0.33609798

135   1 0.02430048 0.97569952

136   0 1.00000000 0.00000000

137   0 0.74354135 0.25645865

138   0 0.97569952 0.02430048

139   0 1.00000000 0.00000000

140   0 1.00000000 0.00000000

141   1 0.25597771 0.74402229

142   0 1.00000000 0.00000000

143   0 1.00000000 0.00000000

144   1 0.36039846 0.63960154

145   0 1.00000000 0.00000000

146   0 0.74402229 0.25597771

147   0 0.84796209 0.15203791

148   0 0.91987973 0.08012027

149   0 0.51243637 0.48756363

150   0 1.00000000 0.00000000

151   1 0.28027819 0.71972181

152   0 1.00000000 0.00000000

153   0 0.59198438 0.40801562

154   0 0.51243637 0.48756363

155   1 0.33609798 0.66390202

156   0 0.97569952 0.02430048

157   0 1.00000000 0.00000000

158   0 1.00000000 0.00000000

159   0 0.59198438 0.40801562

160   1 0.48756363 0.51243637

161   0 1.00000000 0.00000000

162   0 0.97569952 0.02430048

163   1 0.25645865 0.74354135

164   1 0.33609798 0.66390202

165   0 0.51186411 0.48813589

166   1 0.43231610 0.56768390

167   0 1.00000000 0.00000000

168   0 1.00000000 0.00000000

169   0 1.00000000 0.00000000

170   0 1.00000000 0.00000000

171   0 1.00000000 0.00000000

172   0 0.76784183 0.23215817

173   0 0.56768390 0.43231610

174   0 0.76784183 0.23215817

175   0 0.84796209 0.15203791

176   0 1.00000000 0.00000000

177   0 0.51243637 0.48756363

178   0 0.51243637 0.48756363

179   0 0.63960154 0.36039846

180   0 0.74402229 0.25597771

181   0 1.00000000 0.00000000

182   1 0.15203791 0.84796209

183   0 0.66390202 0.33609798

184   1 0.02430048 0.97569952

185   0 0.97569952 0.02430048

186   1 0.23215817 0.76784183

187   0 0.97569952 0.02430048

188   0 0.51186411 0.48813589

189   1 0.25597771 0.74402229

190   0 1.00000000 0.00000000

191   0 1.00000000 0.00000000

192   0 1.00000000 0.00000000

193   0 1.00000000 0.00000000

194   0 1.00000000 0.00000000

195   0 0.91987973 0.08012027

196   0 1.00000000 0.00000000

197   0 0.91987973 0.08012027

198   0 0.74402229 0.25597771

199   0 1.00000000 0.00000000

200   0 1.00000000 0.00000000

201   0 1.00000000 0.00000000

202   0 1.00000000 0.00000000

203   0 0.97569952 0.02430048

204   0 0.84796209 0.15203791

205   1 0.00000000 1.00000000

206   0 0.89557925 0.10442075

207   0 1.00000000 0.00000000

208   0 1.00000000 0.00000000

209   0 0.91987973 0.08012027

210   0 0.84796209 0.15203791

211   0 1.00000000 0.00000000

212   0 0.74402229 0.25597771

213   0 0.74402229 0.25597771

214   0 0.66390202 0.33609798

215   0 1.00000000 0.00000000

216   0 0.91987973 0.08012027

217   0 1.00000000 0.00000000

218   0 1.00000000 0.00000000

219   0 0.51186411 0.48813589

220   0 1.00000000 0.00000000

221   1 0.00000000 1.00000000

222   1 0.15203791 0.84796209

223   0 0.51243637 0.48756363

224   1 0.28027819 0.71972181

225   1 0.08012027 0.91987973

226   0 1.00000000 0.00000000

227   0 1.00000000 0.00000000

228   1 0.25597771 0.74402229

229   1 0.15203791 0.84796209

230   1 0.15203791 0.84796209

231   0 0.51243637 0.48756363

232   1 0.08012027 0.91987973

233   1 0.28027819 0.71972181

234   1 0.40801562 0.59198438

235   0 0.51186411 0.48813589

236   0 1.00000000 0.00000000

237   1 0.43231610 0.56768390

238   0 0.89557925 0.10442075

239   1 0.33609798 0.66390202

240   0 0.74354135 0.25645865

241   0 0.97569952 0.02430048

242   0 1.00000000 0.00000000

243   0 0.97569952 0.02430048

244   0 0.89557925 0.10442075

245   0 0.74402229 0.25597771

246   0 1.00000000 0.00000000

247   0 1.00000000 0.00000000

248   0 0.84796209 0.15203791

249   1 0.36039846 0.63960154

250   0 0.84796209 0.15203791

251   1 0.48813589 0.51186411

252   0 1.00000000 0.00000000

253   0 1.00000000 0.00000000

254   0 0.91987973 0.08012027

255   0 0.56768390 0.43231610

256   0 1.00000000 0.00000000

257   0 0.84796209 0.15203791

258   1 0.33609798 0.66390202

259   0 0.76784183 0.23215817

260   0 1.00000000 0.00000000

261   1 0.36039846 0.63960154

262   0 1.00000000 0.00000000

263   0 1.00000000 0.00000000

264   1 0.48756363 0.51243637

265   1 0.48756363 0.51243637

266   0 0.89557925 0.10442075

267   0 1.00000000 0.00000000

268   0 0.66390202 0.33609798

269   0 0.56768390 0.43231610

270   0 0.74402229 0.25597771

271   1 0.25597771 0.74402229

272   0 1.00000000 0.00000000

273   0 0.66390202 0.33609798

274   0 1.00000000 0.00000000

275   0 1.00000000 0.00000000

276   0 0.89557925 0.10442075

277   0 1.00000000 0.00000000

278   0 0.51243637 0.48756363

279   0 0.84796209 0.15203791

280   0 1.00000000 0.00000000

281   0 0.84796209 0.15203791

282   0 0.91987973 0.08012027

283   0 1.00000000 0.00000000

284   0 1.00000000 0.00000000

285   0 0.97569952 0.02430048

286   0 1.00000000 0.00000000

287   0 1.00000000 0.00000000

288   0 1.00000000 0.00000000

289   0 1.00000000 0.00000000

290   0 0.91987973 0.08012027

291   0 1.00000000 0.00000000

292   0 1.00000000 0.00000000

293   0 0.91987973 0.08012027

294   0 0.76784183 0.23215817

295   1 0.17633839 0.82366161

296   1 0.10442075 0.89557925

297   0 0.84796209 0.15203791

298   0 0.97569952 0.02430048

299   1 0.36039846 0.63960154

300   0 1.00000000 0.00000000

301   0 0.84796209 0.15203791

302   0 0.91987973 0.08012027

303   0 0.89557925 0.10442075

304   0 0.97569952 0.02430048

305   0 1.00000000 0.00000000

306   1 0.02430048 0.97569952

307   1 0.15203791 0.84796209

308   1 0.40801562 0.59198438

309   0 0.84796209 0.15203791

310   1 0.00000000 1.00000000

311   0 0.89557925 0.10442075

312   0 1.00000000 0.00000000

313   0 1.00000000 0.00000000

314   1 0.48756363 0.51243637

315   0 0.51243637 0.48756363

316   0 0.97569952 0.02430048

317   0 1.00000000 0.00000000

318   0 0.97569952 0.02430048

319   1 0.25645865 0.74354135

320   0 1.00000000 0.00000000

321   1 0.08012027 0.91987973

322   1 0.33609798 0.66390202

323   0 0.91987973 0.08012027

324   0 0.89557925 0.10442075

325   0 0.91987973 0.08012027

326   0 1.00000000 0.00000000

327   1 0.25597771 0.74402229

328   0 1.00000000 0.00000000

329   0 1.00000000 0.00000000

330   1 0.43231610 0.56768390

331   0 0.84796209 0.15203791

332   0 0.51243637 0.48756363

333   1 0.33609798 0.66390202

 [ reached 'max' / getOption("max.print") -- omitted 365 rows ]

【朴素贝叶斯分类算法】

Eg.1：朴素贝叶斯算法预测客户是否流失

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 使用naiveBayes函数建立朴素贝叶斯分类模型

library(e1071)  # 加载e1071包

naiveBayes.model <- naiveBayes(流失 ~ ., data = traindata)  # 建立朴素贝叶斯分类模型

# 预测结果

train_predict <- predict(naiveBayes.model, newdata = traindata)  # 训练数据集

test_predict <- predict(naiveBayes.model, newdata = testdata)  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

# 使用NaiveBayes函数建立朴素贝叶斯分类模型

install.packages("klaR")

library(klaR)  # 加载klaR包

NaiveBayes.model <- NaiveBayes(流失 ~ ., data = traindata)  # 建立朴素贝叶斯分类模型

# 预测结果

train_predict <- predict(NaiveBayes.model)  # 训练数据集

test_predict <- predict(NaiveBayes.model, newdata = testdata)  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict$class)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict$class))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict$class)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict$class))

【lda模型】

Eg.1：建立lda模型并进行分类预测

Data[, "流失"] <- as.factor(Data[, "流失"]) #将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立lda分类模型

install.packages("MASS")

library(MASS)

lda.model <- lda(流失 ~ ., data = traindata)

# 预测结果

train_predict <- predict(lda.model, newdata = traindata)  # 训练数据集

test_predict <- predict(lda.model, newdata = testdata)  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict$class)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict$class))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict$class)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict$class))

【rpart模型】

Eg.1：构建rpart模型并进行分类预测

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立rpart分类模型

library(rpart)

install.packages("rpart.plot")

library(rpart.plot)

rpart.model <- rpart(流失 ~ ., data = traindata, method = "class", cp = 0.03)  # cp为复杂的参数

# 输出决策树图

rpart.plot(rpart.model, branch = 1, branch.type = 2, type = 1, extra = 102, 

           border.col = "blue", split.col = "red", 

           split.cex = 1, main = "客户流失决策树")

# 预测结果

train_predict <- predict(rpart.model, newdata = traindata, type = "class")  # 训练数据集

test_predict <- predict(rpart.model, newdata = testdata, type = "class")  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【bagging模型】

Eg.1：构建bagging模型并进行分类预测

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立bagging分类模型

install.packages("adabag")

library(adabag)

bagging.model <- bagging(流失 ~ ., data = traindata)

# 预测结果

train_predict <- predict(bagging.model, newdata = traindata)  # 训练数据集

test_predict <- predict(bagging.model, newdata = testdata)  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict$class)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict$class))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict$class)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict$class))

【randomForest模型】

Eg.1：构建randomForest模型并进行分类预测

Data[, "流失"] <- as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立randomForest模型

install.packages("randomForest")

library(randomForest)

randomForest.model <- randomForest(流失 ~ ., data = traindata)

# 预测结果

test_predict <- predict(randomForest.model, newdata = testdata)  # 测试数据集

# 输出训练数据的混淆矩阵

(train_confusion <- randomForest.model$confusion)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【svm模型】

Eg.1：构建svm模型并进行分类预测

Data[, "流失"] = as.factor(Data[, "流失"])  # 将目标变量转换成因子型

set.seed(1234)  # 设置随机种子

# 数据集随机抽70%定义为训练数据集，30%为测试数据集

ind <- sample(2, nrow(Data), replace = TRUE, prob = c(0.7, 0.3))

traindata <- Data[ind == 1, ]

testdata <- Data[ind == 2, ]

# 建立svm模型

install.packages("e1071")

library(e1071)

svm.model <- svm(流失 ~ ., data = traindata)

# 预测结果

train_predict <- predict(svm.model, newdata = traindata)  # 训练数据集

test_predict <- predict(svm.model, newdata = testdata)  # 测试数据集

# 输出训练数据的分类结果

train_predictdata <- cbind(traindata, predictedclass = train_predict)

# 输出训练数据的混淆矩阵

(train_confusion <- table(actual = traindata$流失, predictedclass = train_predict))

# 输出测试数据的分类结果

test_predictdata <- cbind(testdata, predictedclass = test_predict)

# 输出测试数据的混淆矩阵

(test_confusion <- table(actual = testdata$流失, predictedclass = test_predict))

【ROC曲线和PR曲线】

Eg.1：ROC曲线和PR曲线图代码

install.packages("ROCR")

library(ROCR)

library(gplots)

# 预测结果

train_predict <- predict(lda.model, newdata = traindata)  # 训练数据集

test_predict <- predict(lda.model, newdata = testdata)  # 测试数据集

par(mfrow = c(1, 2))

# ROC曲线

# 训练集

predi <- prediction(train_predict$posterior[, 2], traindata$流失)

perfor <- performance(predi, "tpr", "fpr")

plot(perfor, col = "red", type = "l", main = "ROC曲线", lty = 1)  # 训练集的ROC曲线

# 测试集

predi2 <- prediction(test_predict$posterior[, 2], testdata$流失)

perfor2 <- performance(predi2, "tpr", "fpr")

par(new = T)

plot(perfor2, col = "blue", type = "l", pch = 2, lty = 2)  # 测试集的ROC曲线

abline(0, 1)

legend("bottomright", legend = c("训练集", "测试集"), bty = "n",

       lty = c(1, 2), col = c("red", "blue"))  # 图例

# PR曲线

# 训练集

perfor <- performance(predi, "prec", "rec")

plot(perfor, col = "red", type = "l", main = "PR曲线", xlim = c(0, 1),

     ylim = c(0, 1), lty = 1)  # 训练集的PR曲线

# 测试集

perfor2 <- performance(predi2, "prec", "rec")

par(new = T)

plot(perfor2, col = "blue", type = "l", pch = 2, xlim = c(0, 1),

     ylim = c(0, 1), lty = 2)  # 测试集的PR曲线

abline(1, -1)

legend("bottomleft", legend = c("训练集", "测试集"), bty = "n",

       lty = c(1, 2), col = c("red", "blue"))  # 图例

【BIC图和一阶差分】

Eg.1：

install.packages("TSA")

library(TSA)

Data <- read.csv("arima_data.csv", header = T,fileEncoding = "GB2312")[, 2]

sales <- ts(Data)

plot.ts(sales, xlab = "时间", ylab = "销量 / 元")

# 一阶差分

difsales <- diff(sales)

# BIC图

res <- armasubsets(y = difsales, nar = 5, nma = 5, y.name = 'test',

                   ar.method = 'ols')

plot(res)

【逻辑回归】

Eg.1：

Data <- read.csv("bankloan.csv",fileEncoding = "GB2312")[2:701, ]

# 数据命名

colnames(Data) <- c("x1", "x2", "x3", "x4", "x5", "x6", "x7", "x8", "y")

# logistic回归模型

glm <- glm(y ~ x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8,

           family = binomial(link = logit), data = Data)

summary(glm)

# 逐步寻优法

logit.step <- step(glm, direction = "both")

summary(logit.step)

# 前向选择法

logit.step <- step(glm, direction = "forward")

summary(logit.step)

# 后向选择法

logit.step <- step(glm, direction = "backward")

summary(logit.step)

【ID3_decision_tree】

Eg.1：

data <- read.csv("sales_data.csv",fileEncoding = "GB2312")[, 2:5]

# 数据命名

colnames(data) <- c("x1", "x2", "x3", "result")

# 计算一列数据的信息熵

calculateEntropy <- function(data) {

  t <- table(data)   

  sum <- sum(t)      

  t <- t[t != 0]       

  entropy <- -sum(log2(t / sum) * (t / sum))

  return(entropy)

}

# 计算两列数据的信息熵

calculateEntropy2 <- function(data) {

  var <- table(data[1])

  p <- var/sum(var)

  varnames <- names(var)

  array <- c()

  for (name in varnames) {

    array <- append(array, calculateEntropy(subset(data, data[1] == name,

                                                   select = 2)))

  }

  return(sum(array * p))

}

buildTree <- function(data) {

  if (length(unique(data$result)) == 1) {

    cat(data$result[1])

    return()

  }

  if (length(names(data)) == 1) {

    cat("...")

    return()

  }

  entropy <- calculateEntropy(data$result) 

  labels <- names(data)

  label <- ""

  temp <- Inf

  subentropy <- c()

  for (i in 1:(length(data) - 1)) {

    temp2 <- calculateEntropy2(data[c(i, length(labels))])

    if (temp2 < temp) {        

      temp <- temp2         

      label <- labels[i]     

    }

    subentropy <- append(subentropy,temp2) 

  }

  cat(label)

  cat("[")

  nextLabels <- labels[labels != label]

  for (value in unlist(unique(data[label]))) {

    cat(value,":")

    buildTree(subset(data,data[label] == value, select = nextLabels))

    cat(";")

  }

  cat("]")

}

# 构建分类树

buildTree(data)

【bp_neural_network】

Eg.1：

Data <- read.csv("sales_data.csv",fileEncoding = "GB2312")[, 2:5]

# 数据命名

library(nnet)

colnames(Data) <- c("x1", "x2", "x3", "y")

print(names(Data))

print(class(Data$y))

Data$y <- as.factor(Data$y)

print(class(Data$y))

# 最终模型

model1 <- nnet(y ~ ., data = Data, size = 6, decay = 5e-4, maxit = 1000) 

pred <- predict(model1, Data[, 1:3], type = "class")

(P <- sum(as.numeric(pred == Data$y)) / nrow(Data))

table(Data$y, pred)

prop.table(table(Data$y, pred), 1)

MorleyOlsen
关注
  • 26
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
鸢尾花分类预测实验（机器学习）
weixin_47116024的博客
09-12 6858
鸢尾花数据集的分类预测实验是机器学习最经典的案例之一，通过模型的训练，对于大量的鸢尾花数据集的学习，可以识别出新的鸢尾花是什么类型，继而完成预测和分类 鸢尾花的分类和预测大概分为如下几个步骤 （1）准备训练数据 （2）切分数据集 （3）数据归一化/标准化（对其正态分布转化）（4）对数据集的训练和预测（多轮交叉验证） （5） 1 准备训练数据 #鸢尾花数据集加载 iris=datasets.load_iris() X=iris.data[:,2:]#数据采用花瓣长和宽 ...
数据挖掘与机器学习 实验：分类算法
m0_74394367的博客
10-26 541
数据挖掘与机器学习 实验：分类算法 实现对未知收入群体的收入情况的预测
python数据挖掘实验
04-11
python数据挖掘实验，内附有八个实验文档说明。实验一 探索性数据分析演示、实验二 常用概率分布演示、实验三 置信区间和假设检验演示、实验四 线性回归模型演示.................
数据挖掘实践
潘家皓的博客
05-26 6387
数据挖掘课程实验 一、背景描述 《数据挖掘》课程实践要求 从Kaggle上进行实践 网址：https://www.kaggle.com/datasets 要求： 在竞赛、数据集这2个栏目中，找到一个项目进行实践。 独立完成。 实践报告要求： a) 描述背景，目标、问题，方案，算法及比较，数据集（预处理等全流程），结果及调试，展示及结果分析。 b) 算法分析。流程图。 c) 源码和数据集（打包）、软件执行的录屏。 评分依据：选题难度、完成情况、工作量 越来越多的客户退出信用卡业务，这让银行经理感到不安。如
南理工数据挖掘大作业（网站评级SyskillWebert），包含代码和实验报告
05-28
南京理工大学数据挖掘大作业（网站评级SyskillWebert），徐建老师的课程，包含代码和实验报告。部分代码地址：https://blog.csdn.net/qq_33614902/article/details/80479695
数据挖掘实战-基于LSTM算法的HCV检测者分类模型研究
最新发布
m0_64336780的博客
04-06 9476
项目数据来自UCI机器学习知识库。收录日期是2020-06-10，由德国汉诺威医科大学临床化学研究所捐赠。该数据集包含献血者和丙型肝炎患者的实验室数据和年龄等人口学数据。数据集特征: 多元实例数量:377领域：生活属性特征：实整型属性数量：14相关的任务:分类 (含有缺失的值,对缺失值采取填充的方式解决）。数据集分类的目标属性是类别：0=献血者（即未发现丙肝病毒的人）、0s=疑似者、与三类丙型肝炎者，包括：1=仅为丙型肝炎、2=纤维化、3=肝硬化。
数据挖掘实验报告-综合实验2-分类与预测的综合实验.docx
07-04
总之，本实验是一个典型的数据挖掘案例，涵盖了数据预处理、特征工程、模型构建与评估等多个关键环节，对于学习和理解数据挖掘技术在分类与预测问题中的应用具有重要意义。同时，它也展示了如何利用机器学习解决实际...
《商务智能与数据挖掘实验》课程教学大纲.docx
12-14
《商务智能与数据挖掘实验》课程是一门针对信息管理与信息系统专业的必修课程，旨在让学生在掌握了商务智能和数据挖掘的基础知识后，进一步深化对这些概念和技术的理解。课程总学时为64学时，其中实验部分占据了36...
奥运会数据分析与可视化预测-数据挖掘机器学习与数据分析项目jupyter
06-08
参考kaggle上的历史数据进行建模预测，不管是多少年份的奥运会都可以作为参考 包含完整的数据集，可以方便快捷运行。 本次预测程序采用了近`120`年的奥运奖牌榜作为训练数据，以对应参赛国家/地区的GDP、人口等作为...
实验四 分类与预测实验手册1
08-03
在本实验中，我们将探索数据挖掘中的分类与预测任务，特别是如何处理数据缺失值以及构建分类模型。实验主要围绕电力窃漏电用户自动识别，采用的技术包括拉格朗日插值法、神经网络（LM 神经网络）和决策树（CART）。...
数据挖掘常用算法代码实现
11-15
数据挖掘常用算法代码实现
数据挖掘实验报告+代码+截图
03-03
数据挖掘的实验报告，共含五个实验，有具体的实验代码以及截图，自带实验感想。五个实验分别为数据预处理、数据立方体与联机分析处理构建、应用 Apriori 算法挖掘频繁项集、贝叶斯决策分类算法、k-均值聚类算法。原下载资源需要的积分太多啦（43分），为了方便大家下载重传了一下，大家愉快的下载吧！
《商业数据挖掘课程实验》教学大纲.docx
12-19
实验3的关联规则学习，实验4的决策树构建，实验5的贝叶斯网络构建，实验6的回归分析，实验7的聚类算法，实验8的时间序列预测，实验9的自动化建模，以及实验10的实际应用——超市管理数据挖掘。这些实验旨在帮助学生...
数据挖掘--（实验三）分类方法
m0_67522539的博客
11-17 1694
python数据挖掘--朴素贝叶斯算法
数据挖掘算法--分类与预测笔记
酱油家的老陈醋
08-15 1806
分类和预测是两种数据分析形式，可以用于提取描述重要数据量的模型或预测未来的数据趋势。然而，分类是预测分类标号，而预测建立连续值函数模型。 数据分类两过程： 1.建立模型，描述预定的数据类或概念集。学习模型用分类规则、判定树或数学公式的形式提出。 2.使用模型进行分类。利用测试集评估模型的预测准确率，如果准确率可以接受，可以用来对未知数据元组分类。 预测是构造和使用模型评估无
数据挖掘实验(一)
淡淡
11-02 6525
实验内容 产生-1···1间隔为0.05的向量 x⃗  \vec x 计算方程y=x2+3 y=x^2+3 绘制函数y=x2+3 y=x^2+3 的函数图像 随机产生大小为30*30的随机矩阵A A 绘制箱形图 在矩阵A A 中随机选择100个数据 用100个2-8之间的随机数替换矩阵A中的数据 重新绘制箱形图 取出异常值的点 矩阵归一化(标准化) 产生-1···1间隔为0.05的向量 x⃗
数据挖掘入门实验二
m0_37954431的博客
04-07 2999
实验2：基于Weka的数据挖掘程序设计学号： 姓名： XXXXXXX 专业： 计算机 班级： 实验目标在掌握基于Weka工具的数据挖掘（分类、回归、聚类、关联规则分析）应用的基础上，实现基于Weka API的数据挖掘程序设计。实验内容下载并安装JDK 7.0 64位版，Weka 3.7版，Eclipse IDE for Java Devel...
数据挖掘实验（八）综合实验【自选项目】
nefu_ljw的博客
11-25 3159
本文代码均已在 MATLAB R2019b 测试通过，如有错误，欢迎指正。 （一）前言 我选择的内容是关联规则挖掘，这个之前在实验六是做过的，但是当时我并没有写数据预处理的部分，而是直接用的已经整理好的整型数据，同时有一个缺点是数据量不够大。 所以在这次综合实验部分，我继续改进Apriori算法的代码，并且找到了一个数据量大一些的数据集，在MATLAB R2019b版本上通过测试。总共写了200多行代码，全部都是我自己写的，不保证代码没有bug。 本文所有代码和原数据集可以在此下载：https://down
数据挖掘之关联分析（实验展示以及源代码）
热门推荐
WarrenLee的博客
06-04 1万+
数据挖掘之关联分析 简单描述下，关联分析概念 关联分析概念主要参考下面的博文 原文：https://blog.csdn.net/qq_40587575/article/details/81022350 关联分析是从大量数据中发现项集之间有趣的关联和相关联系。 而关联分析的最终目标就是要找出强关联规则。 •定义： 1、事务：每一条交易称为一个事务，如上图包含5个事务。 2、项：交易的每一个物品称为一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MorleyOlsen

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

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

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

打赏作者

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

抵扣说明：

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

余额充值