北邮——R语言数据分析

温故而知新

6.函数

6.5 自定义函数

  1. 基本使用
> ce2fa <- function(ce){
+   fa <- 1.8 * ce + 32
+   return(fa)
+ }
> ce2fa(0)
[1] 32
> ce2fa(0:10)
 [1] 32.0 33.8 35.6 37.4 39.2 41.0 42.8 44.6 46.4 48.2 50.0
> ce2fa
function(ce){
  fa <- 1.8 * ce + 32
  return(fa)
}
<bytecode: 0x00000233228bbb90>
  1. R中的参数
    2.1 位置参数
> frm <- function(name,frm="BUPT"){
 1.   cat(name,"is from", frm)
 2. }
> frm(name = "AXB",frm = "BJTU")
AXB is from BJTU
> frm("AXB","BJTU")
AXB is from BJTU
#因为有位置参数,所以上面二者是等价的。

2.2 名义参数

> frm <- function(name,frm="BUPT"){
+   cat(name,"is from", frm)
+ }
> frm(name = "AXB",frm = "BJTU")
AXB is from BJTU
> frm(frm = "BJTU",name = "AXB")
AXB is from BJTU
#因为为名义参数,当指定对应参数名时,位置不影响赋值。

2.3 特殊参数——[…] (任意参数)

> my_func <- function(...){
 1.   cat("The second arg is ", ..2)#第二个参数
 2.   dot_args <- list(...)#通过list来捕捉任意参数
 3.   message("\nThe sum is ",sum(dot_args[[1]],dot_args[[5]]))
 4. }
> my_func(1,"arg2",3,4,5,6,7,8)
The second arg is  arg2
The sum is 6
  1. 函数的二元操作符——既为函数
    1)+、-、*、/、^、>、<-、:、[、"% %"、
# +
> 1+2
[1] 3
> "+"(1,2)#可以看作一个函数调用的过程
[1] 3
> 10^2
[1] 100
> "^"(10,2)
[1] 100
> 2>1
[1] TRUE
> ">"(2,1)
[1] TRUE
> new_var <- 3
> "<-"(n,3)
> n
[1] 3
> new_var
[1] 3
> 1:10
 [1]  1  2  3  4  5  6  7  8  9 10
> ":"(1,10)
 [1]  1  2  3  4  5  6  7  8  9 10
> "["(1:10,2)
[1] 2
> c(1,3,9) %in% 1:3
[1]  TRUE  TRUE FALSE
> "%ab2c%" <- function(a,b){
+   sqrt(sum(a^2,b^2))
+ }
> 3 %ab2c% 4
[1] 5
2) 管道操作符
> library(purrr)
> x <- c(17,28,17,12,15,12,49)
> x %>%
+   unique() %>%
+   sort()
[1] 12 15 17 28 49

6.6 泛型函数

  单一接口,根据接口接收对象的类(这里的类并不是指数据类型,而是指不同的标签)不同而分发到不同的方法中去。——接口函数+不同具体的分发函数
> interface <- function(x,y){
+   message("Single interface")
+   UseMethod("particular",y)
+ }
> particular.classA <- function(x,y){
+   message("Different behavior: classA")
+ }
> particular.classB <- function(x,y){
+   message("Different behavior: classB")
+ }
> particular.default <- function(x,y){
+   message("Different behavior: default")
+ }
> x <- 1:10
> y <- 2:4
> class(y) <- "classB"
> interface(x,y)
Single interface
Different behavior: classB
> class(y) <- NULL
> interface(x,y)
Single interface
Different behavior: default
  1. 查看一个函数有多少种泛型函数
> methods("+")
[1] +.Date        +.gg*         +.glue*      
[4] +.POSIXt      +.vctrs_vctr*
see '?methods' for accessing help and source code
  1. 定义自己的泛型函数
> "+.onlyFirst" <- function(a,b){
+   return(a[1]+b[1])
+ }
> a <- 1:5
> a + 6:10
[1]  7  9 11 13 15
> class(a) <- "onlyFirst"
> a + 6:10
[1] 7
  1. 数据矩阵绘图
> x <- seq(1,100,by=10)
> y <- 2*x + 10
> xy <- cbind(x,y)
> class(xy)
[1] "matrix" "array"
> plot(xy,
+   xlim = c(1,100),
+   ylim = c(0,230),
+   type = "o", col = "red")

北邮——R语言数据分析_第1张图片

6.7 递归——层层递进,逐层回归

> old_monk_story <- function(depth = 1){
+   message(rep(" ", depth),
+           "400 years ago(", 2018 - 400 * depth,
+           "), monk[", depth, "] is telling the story:")
+   if(2018 - 400 * (depth +1) >= 66){
+     old_monk_story(depth + 1)
+ }
+   message(rep(" ",depth),
+           "monk [",depth,"] finished his story")
+ }
> old_monk_story()
 400 years ago(1618), monk[1] is telling the story:
  400 years ago(1218), monk[2] is telling the story:
   400 years ago(818), monk[3] is telling the story:
    400 years ago(418), monk[4] is telling the story:
    monk [4] finished his story
   monk [3] finished his story
  monk [2] finished his story
 monk [1] finished his story

斐波那契数列——递归
1 2 3 5 8 13 21 34 55 …

> fib <- function(n){
+   if(n == 1){
+     return(1)
+   }
+     else {
+     return(c(fib(n-1),sum(tail(fib(n-1),n =2))))
+   }
+ }
> fib(10)
 [1]  1  1  2  3  5  8 13 21 34 55

7.数据对象(3组6类)

7.1 向量/因子

1. 向量

1.1向量类型

1.1 字符型向量
1.2 数值型向量
1.3 逻辑型向量

1.2 创建向量

2.1 创建向量时不能有类型混合,会进行强制类型转换
1)数值型—字符型
2)逻辑型—数值型(TRUE-1, FALSE-2)
2.2 不存在包含向量的向量,会对向量内部向量进行拆包
2.3 除了用c()可以创建向量,vector(), numeric(), logical()也可以创建指定类型的向量
2.4 创建有规则向量
1)等差序列

seq(from = , to = , by = )
seq(from = , to = , len = )

2)随机序列
1. 正态分布——rnorm()
2. 随机抽样——sample()
set.seed()——在这个条件下,随机生成的结果一样

1.3 访问向量子集

3.1 下标 [] —— 下标可重复,顺序可变
1)数值型下标
2)逻辑型下标——取出结果为TRUE的值
3)给向量中的元素起名,通过元素名访问子集

> xm
[1] "A" "B" "C" "D" "E" "F"
> yw
[1] 94 87 92 91 85 92
> names(yw) <- xm
> yw
 A  B  C  D  E  F 
94 87 92 91 85 92 
> yw[c("A","F")]
 A  F 
94 92

1.4 基本向量操作

4.1 排序
sort()——对向量直接排序
order()——返回排序下标
rev()——向量倒序

1.5 向量运算

在进行向量化运算时,若长度不等,则采取循环补齐的方式进行,1:10 - 1:3 相当于1:10 - c(1:3, 1:3, 1:3, 1)

2. 因子类型

北邮——R语言数据分析_第2张图片

向量——存储数值变量(定距定比)
因子——存储类别变量(定类定序)

2.1 因子的应用

(1)分组统计中,因子常用作分组变量
(2)分类问题,均要求因变量为因子
(3)在其它一些算法建模过程中,要求变量为因子(如apriori算法)

2.2 因子的创建与操作

2.1 基于向量

#分类但无序
> xb <- c("F","M","F","F")
> typeof(xb)
[1] "character"
> xb <- factor(xb)
> typeof(xb)
[1] "integer"#factor表面看是一个字符向量,其实是一个整型的数值向量
> mean(as.numeric(number_factors))
[1] 1.6
> as.numeric(number_factors)
[1] 1 2 2 2 1
> as.numeric(xb)
[1] 1 2 1 1
> as.character(xb)
[1] "F" "M" "F" "F"
> xb
[1] F M F F
Levels: F M
> nlevels(xb)
[1] 2
> levels(xb)
[1] "F" "M"

#分类但有序
> score <- factor(c("优","良","优","优","良","优"),**ordered**=TRUE)
> score[1] > score[2]
[1] TRUE#可以自动识别出优比良好
> days <- factor(c("MON","TUE","WED","THUR","FRI"),ordered = TRUE)
> days[3]<days[2]
[1] FALSE
> days[3] > days[2]
[1] TRUE
> days
[1] MON  TUE  WED  THUR FRI 
Levels: FRI < MON < THUR < TUE < WED #因子的识别是按照首字母的26个字母排序来的

2.2 数据分箱

#数据分箱+闭区间+左开右闭
> yw <- c(94,87,92,91,85,92)
> yw5 <- cut(yw,
+            breaks = c(0,(6:10)*10))
> yw5
[1] (90,100] (80,90]  (90,100] (90,100] (80,90]  (90,100]
Levels: (0,60] (60,70] (70,80] (80,90] (90,100]
#数据分箱+有序数据+左闭右开
> yw5 <- cut(yw,
+            breaks = c(0,(6:10)*10),
+            include.lowest = TRUE,
+            right = FALSE,
+            ordered_result = TRUE)
> yw5
[1] [90,100] [80,90)  [90,100] [90,100] [80,90)  [90,100]
Levels: [0,60) < [60,70) < [70,80) < [80,90) < [90,100]
#数据分箱+有序数据+左闭右开+标签
> yw5 <- cut(yw,
+            breaks = c(0,(6:10)*10),
+            include.lowest = TRUE,
+            right = FALSE,
+            ordered_result = TRUE,
+            labels = c("不及格","及格","中","良","优"))#标签需要和前面的levels一一对应
> yw5
[1] 优 良 优 优 良 优
Levels: 不及格 < 及格 <<<

7.2 矩阵/数组

1. 矩阵

1.1 矩阵的创建

> ysw <- matrix(c(94, 87, 92, 91, 85, 92,
+                 82, 94, 79, 84, 92, 82,
+                 96, 89, 86, 96, 82, 85),
+               ncol = 3)
> ysw#默认按照列的顺序来填充矩阵
     [,1] [,2] [,3]
[1,]   94   82   96
[2,]   87   94   89
[3,]   92   79   86
[4,]   91   84   96
[5,]   85   92   82
[6,]   92   82   85
> colnames(ysw) <- c("yw","sx","wy")
> row.names(ysw) <- xm
Error in dimnames(x) <- dn : 'dimnames'的长度[1]必需与陈列范围相等
> xm <- c("A","B","C","D","E","F")
> row.names(ysw) <- xm
> ysw
  yw sx wy
A 94 82 96
B 87 94 89
C 92 79 86
D 91 84 96
E 85 92 82
F 92 82 85
#设置按照行的顺序来填充矩阵
> ysw <- matrix(c(94, 87, 92, 91, 85, 92,
+                 82, 94, 79, 84, 92, 82,
+                 96, 89, 86, 96, 82, 85),
+               byrow = TRUE,
+               ncol = 3)
> colnames(ysw) <- c("yw","sx","wy")
> row.names(ysw) <- xm
> ysw
  yw sx wy
A 94 87 92
B 91 85 92
C 82 94 79
D 84 92 82
E 96 89 86
F 96 82 85

1.2 矩阵的基本性质

###矩阵基本属性
> colnames(ysw)#列名
[1] "yw" "sx" "wy"
> rownames(ysw)#行名
[1] "A" "B" "C" "D" "E" "F"
> dimnames(ysw)#行名+列名
[[1]]
[1] "A" "B" "C" "D" "E" "F"

[[2]]
[1] "yw" "sx" "wy"
> nrow(ysw)#行数
[1] 6
> ncol(ysw)#列数
[1] 3
> dim(ysw)#矩阵维度
[1] 6 3

###子集访问
##访问第一行
> ysw[1,]
yw sx wy 
94 87 92 
> ysw["A",]
yw sx wy 
94 87 92
##访问列
> ysw[,"sx"]
 A  B  C  D  E  F 
87 85 94 92 89 82 
> ysw[,2]
 A  B  C  D  E  F 
87 85 94 92 89 82
##去除第二列
> ysw
  yw sx wy
A 94 87 92
B 91 85 92
C 82 94 79
D 84 92 82
E 96 89 86
F 96 82 85
> ysw[,-2]
  yw wy
A 94 92
B 91 92
C 82 79
D 84 82
E 96 86
F 96 85

###行列重排
##列重排
> ysw[,c("sx","yw","wy")]
  sx yw wy
A 87 94 92
B 85 91 92
C 94 82 79
D 92 84 82
E 89 96 86
F 82 96 85
> ysw[,c(2,1,3)]
  sx yw wy
A 87 94 92
B 85 91 92
C 94 82 79
D 92 84 82
E 89 96 86
F 82 96 85
##行重排
#order()函数,排序并返回下标
> order_sx <- order(ysw[,"sx"],
+   decreasing = TRUE)
> ysw[order_sx,]
  yw sx wy
C 82 94 79
D 84 92 82
E 96 89 86
A 94 87 92
B 91 85 92
F 96 82 85

###矩阵合并
##行合并
rbind()
##列合并
cbind()
##当两个矩阵顺序不统一时,进行合并
tidyverse::merge
tidyverse::join

###矩阵运算
##求和
#行求和
rowSums()
#列求平均值
colMeans()
##对每一行/列循环操作
apply(matrix, 1/2, function)#1_row,2_column
apply家族的处理思路:split-apply-combine模式

1.3 矩阵运算

北邮——R语言数据分析_第3张图片

#利用矩阵解方程
> A <- matrix(
+     c(1, 2, 3,
+       2, 2, 5,
+       3, 5, 1),
+     ncol = 3,
+     byrow = TRUE)
> b <- 1:3
> solve(A,b)#求矩阵的逆
[1] 1 0 0
> solve(A) %*% A#A的逆矩阵 * A 得到的是单位矩阵
              [,1]          [,2]          [,3]
[1,]  1.000000e+00  8.881784e-16  1.054712e-15
[2,] -4.440892e-16  1.000000e+00 -7.077672e-16
[3,] -5.551115e-17 -1.110223e-16  1.000000e+00
> solve(A) %*% A %>% dplyr::near(.,diag(3))#dplyr::near()求近似值
     [,1] [,2] [,3]
[1,] TRUE TRUE TRUE
[2,] TRUE TRUE TRUE
[3,] TRUE TRUE TRUE
> all(near(solve(A) %*% A, diag(3)))
[1] TRUE
R中矩阵的基本操作

北邮——R语言数据分析_第4张图片

2.数组——高维矩阵(这里主要讲三维)

例1:导入图片——图片的操作本质上都是数组的操作

#载入需要的包
> library(magrittr)
> install.packages("imager")
> library(imager)
#创建对象,并加载图片
> presidents <- load.image("D:/R/R-4.0.5/R_Files/presidents.jpg")
#查看图片参数的数据类型
> str(presidents) %>% print
 'cimg' num [1:482, 1:345, 1, 1:3] 0.984 0.961 0.918 0.902 0.902 ...
##这是一个彩色图片,RGB(红、绿、蓝),可以看作一个三维数组
> presidents[, , 2] <- 0
> presidents[, , 3] <- 0
> plot(presidents)
##去除第三个图层,则只留下红色的图层

#给图片特定区域加马赛克
> area_coor_x <- 350:449#图片中需要马赛克的x坐标
> area_coor_y <- 110:259#图片中需要马赛克的y坐标
> array_dim <- c(length(area_coor_x),
+                length(area_coor_y),
+                3)
> array_data <- runif(prod(array_dim))#将各维度数据相称,并均质化
> random_noise <- array(dim = array_dim,
+                       data = array_data)#设置一个数组形式的随机噪音
> presidents[area_coor_x,area_coor_y,] <- 
+   (1 - 0.6) * presidents[area_coor_x,area_coor_y,] +
+   0.6 * random_noise#将这个随机噪音添加到原来的图片上,并给自己随机噪音设置系数,两个系数相加等于1即可
> plot(presidents)

7.3 数据框/列表

1.列表

1.1 list性质

(1)列表是对象的有序集合
(2)列表的对象可以是不同类型、不同长度
(3)列表最为灵活,最具包容性

1.2 list创建

list()

1.3 list访问

#1.LIST$NAME——得到的是一个向量
#2.LIST[]——得到的是一个列表(通用法则:子集X[]的类型与X相同)
   LIST[[]]——得到的是向量([[]]#3.LIST$NAME、LIST[[]]、LIST[["NAME"]]——得到的效果一样

1.4 更改列表元素——总体为赋值

#1.直接重新赋值
#2.删除某个部分——将其赋值给NULL(tips:注意NA、NULL、”“之间的区别)

1.5 对列表的某一部分,执行相同的操作

lapply(LIST,FUNCTION)#返回的结果为list形式
sapply(LIST,FUNCTION)#返回的结果形式为向量

2.数据框

2.1数据框性质

(1)形式是矩阵,本质是列表
(2)列:变量、属性、特征、维度
行:记录、观测值、N维数据空间的一个点

2.2 数据框的创建

A <- data.frame()

2.3 数据框的访问

A$colName
A[row,col]
  #4种下标访问方式:
   1.正整数——选出
   2.负整数——排除 ##正整数和负整数做下标时,不能混用
   3.逻辑值——TRUE(选出)、FALSE(排除)
   4.名称字符串

2.4 更改数据框

#将数据框和新的一列组合起来
cbind()

2.5 读取数据框

A_url <- "地址"
read.csv()#如果读取时乱码,则在参数中加入encoding = "UTF-8"

2.6 查看数据框

#1.查看数据框
view()
head()
tail()
#2.查看数据框结构
str()
#3.对数据框进行统计描述
summary()#按照列进行统计
#4.查看数据框的基本属性
names()
colnames()
nrow()
ncol()
length()

2.7 更改数据框类型转换——本质为赋值

dataframe$NAME <- factor(dataframe$NAME)
#做完数据转换之后,再次进行summary

2.8 数据框记录排序

order()

2.9 训练集和测试集

#将一个数据框分为训练集和测试集(训练集和测试集一般7:3)
> set.seed(2021)
> n_record <- nrow(cjb)
> train_idx <- sample(1:n_record,floor(n_record * 0.7))#在数据框中随机选出70%的数据,并向下取整
> length(train_idx)
[1] 542
> test_idx <- setdiff(1:n_record,train_idx)#选出数据框中非训练集的部分,setdiff(A,B)存在于A中,但不在B中的数据
> length(test_idx)
[1] 233
#得到训练集和测试集
> train_set <- cjb[train_idx,]
> test_set <- cjb[test_idx,]

2.10 数据框与机器学习

(1)分类——数据框与函数
数据框本质就是函数中的列表法
北邮——R语言数据分析_第5张图片
(2)聚类
数据框具有N维属性/特性,组成一个N维的数据空间
距离关系的远近,在无监督学习的情况下,在数据空间中,自然形成了结构:簇
(3)关联规则
支持度
置信度
北邮——R语言数据分析_第6张图片

2.11 数据框的本质及其衍射

数据框—关系表

  1. data.frame
  2. tidyerse::tibble
  3. data.table(当数据量大于1GB时,data.table处理效率高)
    数据框是R算法建模过程中,最常用的数据对象,其中蕴含各类关系结构,包括映射关系、距离关系、伴随关系、相关关系、拓扑关系等

7.4 数据材质

名称 类型 示例
逻辑型 logical F,T
整型 integer 1L,300L
双精度型 numeric 1,3.14
复数型 complex 1+2i
字符型 character “Hello,world”
原始字节数据 raw b0

8.算法模型

8.1近邻法——kNN(k-最近邻分类),空间划分的角度

1.基本组成

#输入:最近邻数目—— k,训练集S,测试集T
#输出:对测试集T中所有的样本贴上相应的标签,预测其类编号值
(1)for每个测试样本 z = (X',y') ∈ T # X'_特征向量;y'_类标签
(2)   计算z和每个训练样本(X',y') ∈ S之间的距离d(X,X')
(3)	  选择离z最近的k最近邻集合Sz包含于S
(4)	  多数表决y' = argmax∑(xi,yi) ∈ Dz I(v = yi)
(5)end for
##距离d的计算
1.欧几里得距离
2.曼哈顿距离

北邮——R语言数据分析_第7张图片

1.2 weighted kNN_加权近邻法

(1)意义:近邻法会由于k的取值不同而产生不同的结果,这个时候使用加权法,给每个点加上一定比重,距离越近,比重越高。
北邮——R语言数据分析_第8张图片
wi即为这个权重,可以取不同的核函数,如高斯核,求距离的倒数

1.3 k值和核的确立

通过实验的方法,一步步尝试,看哪个值性能表现最好

1.4 近邻法R语言实现

北邮——R语言数据分析_第9张图片

>library(kknn)
#################################
##构建预测模型
> imodel <- kknn(wlfk ~ .,#构建因变量和自变量函数
+                 train = cjb[train_set_idx, ],#载入训练集
+                 test = cjb[train_set_idx, ])#将训练集当作测试集,来查看其拟合情况
> predicted_test <- imodel$fit#挑选出模型中查看拟合情况的部分
> Metrics::ce(cjb$wlfk[train_set_idx, ], predicted_test)#查看模型的分类错误率,分析其拟合效果
#> [1] 0.1107011
##再用测试集,来查看拟合情况(这时训练和测试同时进行)
> imodel <- kknn(wlfk ~ .,#构建因变量和自变量函数
+                 train = cjb[train_set_idx, ],#载入训练集
+                 test = cjb[-train_set_idx, ])#测试集,来查看其拟合情况
> predicted_test <- imodel$fit#挑选出imodel列表中fit模型中查看拟合情况的部分
> Metrics::ce(cjb$wlfk[-train_set_idx, ], predicted_test)#查看测试集的分类错误率,查看其泛化误差,分析其拟合效果
#> [1] 0.2586207
#################################
##选取合适的k值和核函数
> train_kk <- train.kknn(
+   wlfk ~ .,
+   data = cjb,
+   kmax = 100,#最大k值
+   kernel = c(#在这么多核函数中进行选择
+     "rectangular","epanechnikov",
+     "cos","inv",
+     "gaussion","optimal"))
#得到了train_kk
#其中
best_k <- train_kk$best.parameters$k#最好的k值
best_kernel <- train_kk$best.parameters$kernel
####################################
#k折交叉检验
#1.目的:继续测试,使模型参数稳定在一定性能上
#2.方法:每一次1折为测试集,其余k-1折为训练集
> sp <-  Sys.time()
> cat("\n[Start at:", as.character(sp))

[Start at: 2021-12-26 16:12:30
> for (i in 1:lenth(kfolds)){
+   curr_fold <- kfolds[[i]]#取出当前这一折
+   train_set <- cjb[-curr_fold,]#k-1折为训练集
+   test_set <- cjb[curr_fold,]#当前这一折为测试集
+   predicted_train <- kknn(
+     wlfk ~ ., train = train_set, test = train_set,
+     k = best_k,kernal = best_kernel)$fit#查看训练集拟合效能表现
+   imerics("kknn","Train",predicted_train,train_set$wlfk)
    predicted_test <- kknn(
      wlkf ~ ., train = train_set,test = test_set,
      k = best_k, kernel = best_kernel)$fit
    imetrics("kknn","Test",predicted_test,test_set$wlfk)
    }
    ep <- Sys.time()
    cat(["\tFinished at:", as.character(ep),"]\n")
    cat("[Time Ellapsed:\t",
        difftime(ep,sp,units = "secs")," seconds]\n")

北邮——R语言数据分析_第10张图片

最好的k值:25
最好的核函数:gaussian
最小分类错误率:0.2144703

8.2 决策树

1.定义

  不断细分数据空间,纯化数据空间,从而实现分类

北邮——R语言数据分析_第11张图片

1.2 决策树中的一种——cart分类决策树[基尼系数](决策树不同的算法是基于不同的纯度来划分的)

(1)工作原理
1.各种条件属性的组合,根据特征进行决策
2.局部最优,不断细化——当前特征属性的选择+取值范围的选择
(2)决策树归纳算法TreeGrowth(D,F)——递归
北邮——R语言数据分析_第12张图片
(3)代价—复杂度剪枝

		α:取值区间不同,对应的最优树不同

北邮——R语言数据分析_第13张图片
(4)寻找决策树
1.决策树的生成
2.根据代价-复杂度进行剪枝——设置不同的α取值区间,从而生成不同的决策树
2.将所有决策树序列进行交叉验证,查看泛化性能最佳的决策树

8.3 随机森林——属于分类器组合学习

1.1 定义

(1)集成学习
将多个弱分类器组合成一个强分类器
(2)流程
1.将数据集分成多个子集
1.1 利用重采样/有放回抽样的方法,各个子集之和会大于原始数据集
(随机森林过程中通过有放回的重采样方法,样本大小与原数据集大小一致,但有36%左右的数据不被抽到)
2.每个子集选取不同的特征属性,生成相应的弱分类器
3.利用弱分类器对测试集进行验证
4.采用不同的法则(如少数服从多数)来决定最终分类结果——生成强分类器

北邮——R语言数据分析_第14张图片

1.2 R语言实现(大致流程同前)

8.4朴素贝叶斯

1.定义

(1)抽象理解:通过条件概率来减少不确定性
(2)贝叶斯:
北邮——R语言数据分析_第15张图片
(3)朴素贝叶斯的本质:学到了先验概率和条件概率对结果的影响

8.5 logistic(逻辑斯蒂回归)

北邮——R语言数据分析_第16张图片

8.6 人工神经网络

1.1 基本结构

输入层—隐藏层—输出层

8.7 支持向量机

9.聚类——无监督学习

9.1 聚类形成的自然空间结构——簇(cluster)

1.1簇的类型

(1)明显分离的簇
(2)基于中心的簇
(3)基于邻近的簇
(4)基于密度的簇

9.2 聚类方法

北邮——R语言数据分析_第17张图片

1.1 基于划分的聚类方法——kMeans

(1)对象属性:簇内高相似性,簇间低相似性

1.2 层次聚类

(1)基本凝聚层次聚类算法
(2)

你可能感兴趣的:(R语言学习,r语言,数据分析,bash)