初学者 r 公式教程
想一想，R 中的很多函数都利用了公式:像ggplot2、stats、lattice、dplyr等包都在用！使用这些 R 对象的常见函数示例有glm()、lm()、facet_wrap()等。但是这些公式到底是什么，为什么要用呢？
这些只是本教程希望回答的一些问题:
提示:您有兴趣在统计建模的背景下学习更多的公式吗？看看 DataCamp 的多元与 Logistic 回归课程。
R 中的数据结构
因为公式是 R 编程语言中的一个特殊类，所以简单地修改一下这种编程语言中可用的数据类型和数据结构是一个好主意。
记住 R 是一种面向对象的编程语言:这种语言是围绕对象来组织的。R 中的一切都是对象。
让我们从头开始:在编程中，你使用数据结构存储数据，函数处理数据。数据结构是组织在计算机内存中的数据的接口。正如 R 语言定义所说，R 并不提供对计算机内存的直接访问，而是提供一些你可以称为“对象”的特殊数据结构。每个数据结构都是为优化存储、访问或处理的某个方面而设计的。
R 中的五种主要数据结构是:
- 原子向量，
- 列表，
- 矩阵，
- 数据帧，以及
- 排列
# Create variables
a <- c(1,2,3,4,5,6,7,8,9)
b <- list(x = LifeCycleSavings[,1], y = LifeCycleSavings[,2])
提示:你可以使用typeof()函数返回一个 R 对象的类型。对象的类型告诉您关于任何对象的(R 内部)类型或存储模式的更多信息:
# Retrieve the types of `a` and `b`
typeof(a)
typeof(b)
双份
‘列表’
在上面定义变量a和b的例子中，您可以看到数据结构包含数据元素序列。这些元素可以是相同或不同的数据类型。您可以在 R 中找到以下 6 种原子数据类型:
- 数字，如
100、5、4，包含整数。 - 字符，如
"Hello"、"True"或"23.4"，由键盘字符串组成。； - 逻辑的，如
TRUE或FALSE，由“真值”组成； - raw，如
48 65 6c 6c 6f，由比特组成； - 复数，如
2+5i，包含复数；最后一点， - double，如
3.14，包含十进制数。
在 r 中，几乎所有的对象都有属性。例如，您可能已经知道矩阵和数组只是简单的向量，属性dim和可选的dimnames被附加到向量上。属性用于实现 r 中使用的类结构。作为一种面向对象的编程语言，类的概念以及方法是它的核心。类是对象的定义。它定义了对象包含的信息以及如何使用该对象。
看看下面的例子:
# Retrieve the classes of `a` and `b`
class(a)
class(b)
‘数字’
‘列表’
注意如果一个对象没有class属性，它有一个隐式类，“矩阵”、“数组”或mode()函数的结果。
您可能遇到的一些特殊类是日期和公式；而这最后一个就是今天教程的题目！
R 中的公式是什么？
当你阅读本教程的介绍时，你可能已经看到了在使用像ggplot2这样的包或者像lm()这样的函数时出现的公式。因为您通常在这些函数调用中使用公式来表达统计模型的思想，所以在建模函数和一些图形函数中经常使用这些 R 对象是合乎逻辑的。
对吗？
然而，公式并不局限于模型。它们是一个强大的通用工具，允许您捕获两件事情:
- 未赋值的表达式，以及
- 创建表达式的上下文或环境。
这解释了为什么在函数调用中使用公式来生成“特殊行为”:它们允许您捕获变量的值，而无需对它们求值，以便它们可以被函数解释。
记住数据结构后，您就可以将这些 R 对象描述为“语言”对象或未赋值的表达式，它们具有一个“公式”类和一个存储环境的属性。
在上一节中，您看到了对象具有某些(R internal)类型，这些类型指示对象是如何存储的。在这种情况下，公式是“语言”类型的对象。
但是这到底意味着什么呢？
嗯，当你处理 R 语言本身时，你通常会遇到这种类型的对象。为了更好地理解这一点，请看下面的例子:
# Retrieve the object type
typeof(quote(x * 10)) # Retrieve the class
class(quote(x * 10))
“语言”
“呼叫”
在上面的例子中，你要求 R 返回quote(x*10)的类型和类。结果你看到quote(x*10)的类型是'language'，而class是'call'。
这绝对不是一个公式，因为你需要用class()来返回'formula'！
但那是什么呢？
R 中的公式的特征是波浪号操作符~。有了这个操作符，您实际上可以说:“捕捉这段代码的含义，而不用马上对它进行评估”。这也解释了为什么你可以把 R 中的公式看作一个“引用”操作符。
但是公式到底是什么样子的呢？仔细看看下面一行代码:
# A formula
c <- y ~ x
d <- y ~ x + b # Double check the class of `c`
class(c)
公式
波浪号(~)左侧的变量称为“因变量”，而右侧的变量称为“自变量”，由加号+连接。
很高兴知道这些变量的名称会根据上下文而变化。你可能已经看到自变量以“预测值(变量)”、“受控变量”、“特征”等形式出现。同样，你可能会遇到因变量，如“反应变量”、“结果变量”或“标签”。
注意尽管您在上面的代码块中定义的公式d包含几个变量，但公式的基本结构实际上只是波浪号~和至少一个独立或右侧变量。
记住公式实际上是具有存储环境属性的语言对象:
# Return the type of `d`
typeof(d) # Retrieve the attributes of `d`
attributes(d)
“语言”
$class [1] "formula"
$.Environment <environment: R_GlobalEnv>
正如你在上面的例子中看到的，公式中包含的变量可以是向量。但是，您经常会看到公式中包含的变量来自数据框，就像下面的示例一样:
Sepal.Width ~ Petal.Width + log(Petal.Length) + Species
注意当创建公式本身时，不会访问任何已分配给公式中符号的数据值。
现在你已经知道了 R 中的公式是什么样子，它们是什么，最好提一下底层的公式对象是不同的，这取决于你有一个单边还是双边的公式。你可以通过观察左边的变量来识别前者。如果没有，就像~ x中一样，你有一个片面的公式。
这也意味着单侧公式的长度为 2，而双侧公式的长度为 3。
不完全信服？看看下面的代码块。您可以借助方括号:[[和]]来访问公式的元素。
e <- ~ x + y + z
f <- y ~ x + b # Return the length of `g`
length(e)
length(f) # Retrieve the elements at index 1 and 2
e[[1]]
e[[2]]
f[[3]]
2
3
`~` x + y + z
x + b
为什么在 R 中使用公式？
如您所见，公式是功能强大的通用工具，允许您捕获变量的值，而无需对它们求值，以便它们可以被函数解释。这已经是为什么应该在 r 中使用公式的答案的一部分了。
此外，您使用这些 R 对象来表达变量之间的关系。
比如下面代码块中的第一行代码，你用第一行代码说“y 是 x，a，b 的函数”；当然，你也可以遇到更复杂的公式，比如在第二行代码中，你的意思是“萼片宽度是花瓣宽度的函数，取决于物种”。
y ~ x + a + b
Sepal.Width ~ Petal.Width | Species
在 R 中使用公式
现在，您已经了解了这些特殊 R 对象的“是什么”和“为什么”,是时候了解如何使用基本公式以及更复杂的公式了！在本节中，您不仅会看到如何创建和连接基本公式，还会发现如何在运算符的帮助下构建更复杂的公式。
如果您想了解更多关于如何在 R 中创建公式、连接公式、使用公式运算符以及如何在 R 中检查公式的信息，请访问 原始教程 。
何时使用公式
到目前为止，您已经了解到 R 公式是通用工具，并不局限于建模，并且您已经看到了一些可以使用公式的例子。在本节中，您将更深入地了解最后一个主题:您将看到一些可以利用这些工具的案例。当然，您将会涉及到诸如lattice和stats之类的软件包的建模和图形功能，但是您也将会涉及到dplyr中的非标准评估。
转到 原创教程 阅读全节。
r 配方奶粉包
之前，您已经看到您可以使用as.formula、update()、all.vars等函数来创建和检查您的公式。…这些都是简单的操作和处理，但是高级的公式处理呢？也许下面这些套餐会让你有些兴趣！
Formula套餐
最近，这个包发表在 CRAN 上。这款套装非常适合那些想让配方更上一层楼的人。这个包扩展了基类formula。
更具体地说，Formula对象扩展了基本的公式对象:使用这个包，您实际上可以定义公式，这些公式接受一个附加的公式操作符|来分隔多个部分，或者可以在左侧包含所有的公式操作符(包括管道字符)来支持多个响应。
您将能够创建的公式示例如下:
- 多部分公式，如
y ~ x1 + x2 | u1 + u2 + u3 | v1 + v2 - 多响应公式，如
y1 + y2 ~ x1 + x2 + x3 - 多部分响应，如
y1 | y2 + y3 ~ x，以及 - 以上三者的组合。
# Load package
library(Formula) # Create formulas
f1 <- y ~ x1 + x2 | z1 + z2 + z3
F1 <- Formula(f1) # Retrieve the class of `F1`
class(F1)
注意功能as.formula()和is.formula()在这个包中也被更新:你将使用is.Formula()和as.Formula()来代替！
在这里阅读更多。
这个包是最近发布的，它为你提供了“操作公式、表达式、调用、赋值和其他 R 对象的编程工具”。这是一大堆，但本质上，这一切都归结为:您可以使用这个包来访问和修改公式结构，以及提取和替换那些 R 对象的名称和符号。这个包裹是克里斯托弗·布朗写的。
在使用这个包时，您可能会发现以下一些有用的东西:
get.vars():代替all.vars()，这个函数会从各种 R 对象中提取变量名，但是所有符号等。将被插入到变量的名称中。invert():您可以使用此功能反转对象中的运算符，如公式。is.one.sided():这个函数可以很方便的判断一个函数是单边的还是双边的。
记住一个公式如果长这样就是片面的:~x；当表述为x~y时，它将是双面的。
有兴趣了解更多套餐？查看 原教程 。
还有更多的发现！
万岁！你已经完成了 R 公式的教程。如果你想了解更多，一定要看看 Hadley Wickham 的数据科学 书籍 R，其中有一章专门介绍 R 中的公式和模型族
您能想出更多可以找到公式或更多可以用来操作公式的包的例子吗？随时在推特上告诉我: @willems_karlijn 。
原载于www.datacamp.com。
朗:从零到英雄
统计计算和图形指南。
R 语言简介。
r 是一个计算环境，它结合了一种叫做 S 的编程语言，实现了用数据编程的思想。它对线性代数、微分方程和随机有强大的数值分析工具。r 编程通过提供一组内置的函数和库让你了解数据可视化。r 的图形前端有很多，目前最好的似乎是 RStudio。然而，在了解这些之前，您应该先了解一下 R 本身。
为什么是 R？
- r 是灵活的。
- r 是强大的。
- r 不仅仅是一个统计计算包；这是一种编程语言。
- r 被设计成以问题设计的方式运行。
- r 在处理数据和存储设备方面效率很高。
用 R 语言编写的代码片段对用户来说总是可用的，所以对任务的小改动通常只需要对代码进行小改动——这种差别可以在更短的时间内完成。
在你的机器上安装 R
R 工作室
RStudio 让 R 更容易上手。它包括一个代码编辑器，调试和可视化工具。它是一个(IDE ),包括一个控制台、支持直接代码执行的语法高亮编辑器，以及用于绘图、历史、调试和工作空间管理的工具。
从以下链接下载 R-Studio。
控制你的 R 代码 RStudio 是一个 R 的集成开发环境(IDE)。
www.rstudio.com](https://www.rstudio.com/products/rstudio/) 
A Snapshot of RStudio
交互使用 R
在机器上安装 R 之后，在终端或 shell 中点击 R 启动 R 交互式 Shell。默认提示是’ > '，在 UNIX 上可能与 shell 提示相同，因此可能看起来什么也没发生，它将等待用户的指令。
您可以将 R Shell 用作计算器，您可以从做简单的数学运算到高级机器学习算法。
要退出 R 程序，命令是
> q()
这将从 R Shell 中退出。您也可以通过在退出后按“y”来保存工作区会话。如果希望继续而不保存，只需按“n”，这将使您返回到终端/shell。
让我们开始打印“Hello World！”在 R 互动壳里。
在 R 中，我们使用 print()函数返回参数中给定的字符串。
$R
> print("Hello World!")
[1] "Hello World!"
>
R 中的注释
正如我们所知，每种编程语言都需要注释，R 支持注释，而注释会被解释器忽略。
这就是我们在 r 中使用注释的方式。
# This is a comment in R
# print("This doesn't work")
变量
在编程中，变量只不过是某种东西的名称。R 中的变量可以存储一个原子向量、一组原子向量或许多 R 对象的组合。r 名称区分大小写。要为数据结构创建名称，我们必须遵循以下规则:
注意:名称以。被认为是系统名，使用ls()-函数时并不总是可见的。
现在让我们看看如何在 R 中声明变量
a <- 3
这行代码声明了一个变量“a ”,并将其赋值为 3。
typeof()函数返回变量的数据类型。
type(a)
[1] "double"
R 中的数据类型
Numeric (real 或 decimal): Decimal 值在 r 中称为 Numeric，它是默认的计算数据类型。
Integer: 为了在 R 中创建一个 Integer 变量，我们调用 as integer 函数。
Character: 一个 Character 对象用来表示 r 中的字符串值，我们用 as character()函数把对象转换成字符值。
逻辑:逻辑值通常是通过变量之间的比较产生的。
**复:**R 中的复数值通过纯虚数值 I 来定义。
解释数据类型的代码片段。
为了从 shell 中执行 R 文件，我们使用命令“Rscript filename”。r "
[1] 3
[1] "double"
[1] "Stark"
[1] "character"
[1] TRUE
[1] "logical"
[1] 1+4i
[1] "complex"
注意:R 语言中的字符串是字符。
算术运算
所有的基本运算，如加、减、除、乘。Etc 可以在 r 中执行
[1] 6
[1] 1
[1] 315
[1] 8.333333
[1] 3
[1] 1
[1] 125
R 中的数据结构
原子向量
向量是 R 中最常用的数据结构。它是相同基本类型的数据元素序列。向量中的成员正式称为分量。向量可以是最常见的character、logical、integer或numeric.元素的向量
我们使用 vector()函数创建一个空向量，下面的代码片段展示了我们如何声明一个向量。
x <- vector()
> character(5)
[1] "" "" "" "" ""
列表
R lang 中的列表充当容器。它们是包含其他对象通用向量。与原子向量不同，列表的变量不限于单一模式，可以包括任何数据类型的混合。一个列表可以包含其他列表。这使得它们不同于原子向量。
R 中的列表是使用 list()函数创建的。
my_list <- list("Red", TRUE, 51.23)
[1] "Red"
[[2]]
[1] TRUE
[[3]]
[1] 51.23[[1]]
[1] 1
[[2]]
[1] 2
[[3]]
[1] 3
[[4]][1] "Sun"
[[5]]
[1] "Mon"
[[6]]
[1] "Tue"
[数]矩阵
矩阵是 r 中特殊类型的向量。矩阵是以二维矩形布局排列的数据元素的集合。矩阵有行和列。
现在，让我们创建一个 2x2 矩阵，我们使用矩阵函数，并将行和列作为参数发送。行数为 nrow ，列数为 ncol 。
my_matrix <- matrix(nrow = 2, ncol = 2)
[,1] [,2] [,3] [,4]
[1,] 59.0 22.3 31.2 9.5
[2,] 55.0 19.7 30.4 13.8
[3,] 53.5 20.8 30.6 14.8
[4,] 55.0 20.3 30.3 15.2
[5,] 52.5 20.8 30.3 15.5
[6,] 57.5 21.5 30.8 15.6
[7,] 53.0 20.6 32.5 15.6
[8,] 55.0 21.5 34.0 15.7
数据帧
数据帧是 R 语言中最常用的数据结构之一。数据以表格的形式表示，表格中有许多行和列。
我们通常将 csv 文件读入数据帧，为此我们使用 read.csv()函数或 read.table()函数，并将 csv 文件名作为参数发送。
我们还可以使用 data.frame()函数创建一个数据框。
> df <- data.frame(id = letters[1:5], x = 1:10, y = rnorm(10))
> df
> ## id x y
> ## 1 a 1 -1.37593
> ## 2 b 2 0.47094
> ## 3 c 3 -0.16046
> ## 4 d 4 -1.36914
> ## 5 e 5 0.39763
这些是我们应用于数据框以得出最小结论的几个重要函数。
head() —查看前 6 行
tail() —查看最后 6 行
dim()-请参见尺寸
nrow() —行数
ncol() —列数
str() —每列的结构
因素
因子几乎都是有标签的整数。虽然因子看起来(并且经常表现)像字符向量，但它们实际上是整数，当把它们当作字符串时需要小心。有些字符串方法会将因子强制转换为字符串，而有些则会抛出错误。
可以用factor()创建因子。输入通常是一个字符向量。
> x <- factor(c("yes", "no", "no", "yes", "yes"))
> x
[1] yes no no yes yes
Levels: no yes
# table(x) will return a frequency table.
控制结构
这些允许您控制脚本的执行流程，通常是在函数内部。常见的包括:
- 如果，否则
- 为
- 在…期间
- 重复
- 破裂
如果-否则
我们总是需要检查条件并相应地改变程序行为的能力。条件语句给了我们能力。最简单的形式是“if”语句。
if (condition) {
# do something
} else {
# do something else
}
例子，
x is less than 10
For 循环
R 中的 for 循环能够迭代任何序列的项，比如列表或向量。
for (i in 1:5) {
print(i)
}
这就是我们在 R 中声明 for 循环的方式，它接受 iterable 变量(I)并迭代直到给定的范围(这里是 10)
1
2
3
4
5
实现 for 循环的几种方法。
[1] NA
[1] NA
[1] NA
[1] NA[1] "apples"
[1] "oranges"
[1] "bananas"
[1] "strawberries"[1] "apples"
[1] "oranges"
[1] "bananas"
[1] "strawberries"[1] "apples"
[1] "oranges"
[1] "bananas"
[1] "strawberries"
在…期间
只要给定的条件为真，R lang 中的 while 循环语句就会重复执行目标语句。与 for 循环不同，while 循环不会运行 n 次，而是直到满足定义的条件。
While 循环的语法
while(condition){
statements
iteration
}
这是一个我们如何实现一个简单的 while 循环的例子，
1
2
3
4
5
重复和中断
重复循环用于多次迭代代码块。重复循环中没有退出循环的条件检查。
重复和中断的语法
repeat{
condition
statements
break
}
现在让我们使用 repeat 和 break 打印前五个数字。
[1] 1
[1] 2
[1] 3
[1] 4
[1] 5
功能
在任何编程语言中，函数的主要用途是可重用性。它们是组织在一起执行特定任务的一组语句。R 中有各种内置函数，R 中的一些内置函数有 sum()、min()、max()、mean()等。
在 R 中声明函数的语法
function_name <- function(arg_1, arg_2, ...) {
function body
}
现在让我们创建一个函数来按顺序打印数字的立方。
216
R 中的可视化
可视化数据是决策的重要解决方案之一。r 编程语言为创建数据故事和可视化提供了一套最好的内置函数和库(如 ggplot2、leaflet、lattice)。
现在，让我们在 RStudio 中使用 ggplot2 创建一个简单的线图，为此我们需要安装 ggplot2 包，您会在左上角找到控制台。运行命令 install.packages("package_name ")。
> install.packages("ggplot2")
我们现在将导入一个内置的数据集(mpg ),并绘制一个简单的图表。
关于 mpg 数据集:这是 1999 年和 2008 年 38 种流行车型的燃油经济性数据。
- 具有 234 行和 11 个变量的数据框
- displ —发动机排量，单位为升
- 公路——公路英里/加仑
感谢阅读！
这篇文章的代码可以在 AaqilShaik 的这里找到。
感谢阅读。如果你觉得这个故事有帮助，请点击下面的👏去传播爱。
r:等级与顺序
如果你正在学习 R，你可能已经遇到过 排序 ， 等级 和 顺序 函数。因为在语义上有相似性，甚至重叠，问题出现了:每一个具体做什么，每一个的用例是什么？
这三个函数都要求它们运算的值是可比较的。 R 中的比较适用于字符串、数字、复杂和逻辑日期类型。
等级与顺序混淆
排序、等级和顺序是 r 中的函数。它们可以应用于向量或因子。如果你习惯用行和列来考虑数据，那么向量代表一列数据。因子是从向量中创建的，代表离散的带标签的值。在下面的 R 代码中，X 加载了数据，然后进行排序、排名和排序。 R 将结果报告为向量。
X = c(3,2,1)
X
3 2 1
sort(X)
[1] 1 2 3
rank(X)
[1] 1 2 3
order(X)
[1] 1 2 3
这似乎够清楚了:
- 使用“c”ombine 函数将数据加载到向量中
- 当您查看 X 时，它会按照加载时的方式排列
- 当你对 X 进行排序时，你会看到一个向量，它包含 X 中的值，这些值按升序排列
- 当您对 X 进行排序时，您会看到一个向量，其中包含 X 中按升序排列的值(类似于排序)
- 当您对 X 排序时，您会看到一个包含 X 中按升序排列的值的向量(类似于 sort)
现在，让我们在创建 X 向量和运行这些函数时应用一个简单的排列。
X = c(2,3,1)
X
2 3 1
sort(X)
[1] 1 2 3
rank(X)
[1] 2 3 1
order(X)
[1] 3 1 2
在上面的输出中，排序函数肯定了我们上面所说的，但是等级和顺序更难解释。现在，看一个不同的向量，在不同的整数范围上有相似的排列。
X = c(5,6,4)
X
5 6 4
sort(X)
[1] 4 5 6
rank(X)
[1] 2 3 1
order(X)
[1] 3 1 2
在上面的代码中，我们看到“5，6，4”的等级和顺序与“2，3，1”相同。这两个序列具有相同的等级和顺序的原因是等级和顺序报告的是相对位置，而不是相对值。等级和顺序基于向量中数据升序排序的结果。具体来说，rank 和 order 返回的值的范围是原始序列中值的索引范围。
- Rank 引用值在排序向量中的位置，与原始序列的顺序相同
- 顺序返回原始值的位置，按照排序的顺序，即从最小值到最大值
下图有助于将按等级和顺序报告的值与它们来自的职位联系在一起。
对合循环
首先呈现的“1，2，3”序列返回秩和序的向量“1，2，3 ”,它实际上是一个特殊的序列，因为这些值和“1，2，3”的几个其他排列导致秩和序表现为对合函数。一个无意识函数是一个它自己的反函数。
**X = c(1,2,3)
RANK(X) == ORDER(X) == X
RANK(ORDER(X)) == X
ORDER(RANK(X)) == 1:length(X)**
在下面的代码中，您可以看到“1，2，3”的所有六种排列都经过了测试，以确定它们是否是对合的(一个应用两次就会给出初始值的函数)。没有导致对合功能的两种排列可以通过它们分解成的循环来识别。有关对合循环的更多信息，请参见下面的文章R 中的秩与序。
X = c(1,2,3)
all(order(rank(X)) == X)
[1] TRUEX = c(2,3,1)
all(order(rank(X)) == X)
[1] FALSEX = c(3,1,2)
all(order(rank(X)) == X)
[1] FALSEX = c(1,3,2)
all(order(rank(X)) == X)
[1] TRUEX = c(2,1,3)
all(order(rank(X)) == X)
[1] TRUEX = c(3,2,1)
all(order(rank(X)) == X)
[1] TRUEall(order(X)[rank(X)] == rank(x)[order(X)]) == 1:length(X)
TRUE
虽然学习查看简单的数据集来帮助理解函数的行为很有吸引力，但当数据的排列影响函数的输出时，它会导致混乱的结论。
排序序列
对于任何升序排列的向量序列，下面的代码演示了顺序和等级之间的关系，因为它们相互作用。级的级将始终等于级的级。
X = c(100,200,300)
all(order(X)[rank(X)] == rank(X)[order(X)])
TRUE
此外，下面的代码验证了对于任何升序序列，秩的顺序和顺序的秩将始终等于由有序元素的位置组成的向量。
x = c(100,200,300)
all(order(X)[rank(X)] == 1:length(X))
TRUE
all(rank(X)[order(X)] == 1:length(X))
TRUE
1:length(X)
[1] 1 2 3
订单函数的用例
您可以使用 order 函数对数据帧进行排序。
排序命令可用于创建一个新的向量，从任何可比较值的向量到按升序排列的向量。默认的排序顺序是升序，但是可以选择降序，也可以选择处理未定义的值和指定排序方法。
当您将数据从文件系统读入一个数据帧或者用代码构建该数据帧时，您拥有一个包含不同类型数据的行和列的结构。为了按列值对数据框的行进行“排序”，无论是单列还是多列，都必须使用命令，因为命令只对向量进行排序。
为了了解其工作原理，下面的示例从加载到矢量中的原始数据构建了一个数据框。这些数据也可以很容易地从 CSV 或其他格式的文本文件中读入。注:将最后一条指令括在括号中会导致数据帧被 test.data 变量引用，并显示 test.data 变量中的内容。显示的第一个整数是由 R 分配给数据帧中各行的计数器标识符。
size = 5
sex=sample(c("male","female"),size,replace=T)
age = sample(21:100, size, replace=T)
degree = sample(c("BA","BS","MS","MBA"), size, replace=T)
(test.data = data.frame(sex=sex, age=age, degree=degree))sex age degree
1 female 30 BA
2 male 49 BA
3 male 39 MBA
4 male 27 MS
5 male 61 MS
我们可以使用 order 命令按年龄对数据进行排序。向 order 函数传递要排序的列的名称，并且顺序为升序。order 命令的结果是一个向量，其中每个值引用原始数据框中项目的位置值，并且它本身位于排序数据的位置。例如，原始数据帧中的第一年龄是 30，而排序数据帧中的第一年龄 30 将在第二位置。因此，值 1 位于顺序向量的第 2 个位置。
一旦获得顺序向量，它将用于从原始测试数据中提取数据。您可以在结果中看到原始的计数器 id，以及它如何匹配用于排序的顺序向量。r 使用带有行、列名称的方括号从数据帧(或矩阵)中提取数据。
order(test.data$age)
[1] 4 1 3 2 5test.data[order(test.data$age),]
sex age degree
4 male 27 MS
1 female 30 BA
3 male 39 MBA
2 male 49 BA
5 male 61 MS
通过在 order 命令指定的列名前使用负号，可以按降序对数据框进行排序。
order(-test.data$age)
[1] 5 2 3 1 4test.data[order(-test.data$age),]5 male 61 MS
2 male 49 BA
3 male 39 MBA
1 female 30 BA
4 male 27 MS
我们还可以通过向 order 命令添加多列来提供多列排序。
order(test.data$degree,-test.data$age)
[1] 2 1 3 5 4
test.data[order(test.data$degree,-test.data$age),]sex age degree
2 male 49 BA
1 female 30 BA
3 male 39 MBA
5 male 61 MS
4 male 27 MS
等级函数的用例
您可以使用 rank 函数创建一个值，该值表示一个值在其序列中的相对位置。
IEEE 提供了一份 2017 年十大编程语言的清单。它们存储在一个文件中，在我的本地文件系统中，按照语言名称的字母顺序排序。下面的代码将它们读入一个变量，这个变量通过名称 language.ieee 引用它们并显示内容。
(language.ieee =read.csv(file="language-scores.csv"))
X language score
1 2 C 99.7
2 5 C# 87.7
3 4 C++ 97.1
4 9 Go 75.1
5 3 Java 99.5
6 7 JavaScript 85.6
7 8 PHP 81.2
8 1 Python 100.0
9 6 R 87.7
10 10 Swift 73.1
我们可以得到一个排序数据的向量。排名向量中的数据显示为 float，因为有平局: C# 与 R 并列第 5 和第 6 名。rank 函数中有处理平局的选项，但默认情况下是使用“平均”方法，并为每个平均分赋值。这些值本身通过值在原始数据集中的位置来表示相应值的降序。较高的等级值代表较大的数据值。
rank(language.ieee$score)
9.0 5.5 7.0 2.0 8.0 4.0 3.0 10.0 5.5 1.0
我可以使用 rank vector，通过向 order 命令提供负秩，按秩对数据进行排序，也就是分数的降序。
language.ieee[order(-rank(language.ieee$score)),]
X language score
8 1 Python 100.0
1 2 C 99.7
5 3 Java 99.5
3 4 C++ 97.1
2 5 C# 87.7
9 6 R 87.7
6 7 JavaScript 85.6
7 8 PHP 81.2
4 9 Go 75.1
10 10 Swift 73.1
计算秩不仅用于排序数据。排名的相关性可以用来检验两个变量之间关系的零假设。由于变量的类型和规模可能不同，秩提供了一种规范化。例如，参见关于使用斯皮尔曼等级相关性的研究:【https://geographyfieldwork.com/SpearmansRank.htm。
结论
R 是一种统计编程语言，具有许多帮助格式化和处理数据的功能。它的服务通过函数调用来提供。除了阅读文档之外，通过这些函数运行数据集也有助于弄清楚它们到底做了什么。Sort、Order 和 Rank 在语义上是相同的，但在实践中，它们有非常不同的用途，有时会相互配合以达到预期的结果。
R vs Python:基于 Keras 的图像分类
许多数据专家对用于人工神经网络模型的语言非常严格，这限制了他们的发展。Python 专用的环境。我决定根据训练一个基于卷积神经网络的图像识别模型所需的时间来测试 Python 与 R 的性能。作为起点，我从Shirin Elsinghorst博士的博客文章开始，讲述了使用 Keras 在 R 语言中构建 CNN 模型是多么容易。
几句关于 Keras 的话。它是一个用于人工神经网络 ML 模型的 Python 库，提供面向各种深度学习框架的高级前端，默认为 Tensorflow 。
Keras 有许多优点，其中包括:
- 只需几行代码即可轻松构建复杂的模型=> 非常适合开发人员。循环快速实验并检查你的想法
- 代码回收:人们可以很容易地交换后端框架(比如从 CNTK 到 Tensorflow 或者反之亦然)=>DRY principle
- 无缝使用 GPU => 非常适合快速模型调优和实验
由于 Keras 是用 Python 编写的，它可能是您的开发人员的自然选择。使用 Python 的环境。直到大约一年前，RStudio 创始人 J.J.Allaire 宣布于 2017 年 5 月发布 Keras 库。我认为这是数据科学家的一个转折点；现在，我们可以更加灵活地使用 dev。环境，能够更有效地交付结果，并有机会扩展我们用 r 编写现有解决方案
这让我想到了这篇文章的主题。
我的假设是，说到用 Keras 建立 ANN ML 模型，Python 不是必须的，根据你客户的要求，或者 tech stack， R 可以无限制使用，效率差不多。
基于 Keras 的图像分类
为了测试我的假设，我将使用 kaggle 的水果图像数据来执行图像分类，并训练一个具有四个隐藏层的 CNN 模型:两个 2D 卷积层，一个池层和一个密集层。 RMSProp 正被用作优化器功能。
技术堆栈
硬件 :
CPU :英特尔酷睿 i7–7700 HQ:4 核(8 线程)、2800–3800(Boost)MHz 核心时钟
GPU :英伟达 Geforce GTX 1050 Ti 移动:4Gb vRAM、1493–1620(Boost)MHz 核心时钟
RAM : 16 Gb
软件:
OS:Linux Ubuntu 16.04
R:ver。3.4.4
Python : ver。3.6.3
和版本。2.2
张量流:版本。1.7.0
CUDA :版本。9.0 ( 注意目前 tensorflow 版本支持 CUDA ver。9.0，而其最新版本是 9.2)
cud nn:ver。7.0.5 ( 注意当前 tensorflow 版本支持 ver。7.0，而 cuDNN 的最新版本是 7.1 )
密码
用于 CNN 模型构建的 R 和 Python 代码片段如下所示。由于 F. Chollet 和 J.J. Allaire 之间卓有成效的合作，R 中的逻辑和函数名与 Python 中的很相似。
R
计算机编程语言
实验
上面的模型用 R 和 Pythons 在 GPU 和 CPU 上训练了 10 次，测量了经过的时间和 10 个历元后的最终精度。
测量结果显示在下图中。
从上面的图表中，我们可以看出
- 您的模型的准确性不取决于您用来构建和训练它的语言(该图仅显示了训练准确性，但该模型没有很高的方差，偏差准确性也在 99%左右)。
- 尽管 10 次测量可能没有说服力，但 Python 可以减少(最多 15%)训练 CNN 模型所需的时间。这是意料之中的，因为 R 在执行 Keras 函数时使用了 Python。
假设我们所有的观察值都是正态分布的，让我们进行不成对 t 检验。
T-score 反映了与 Python 相比，在 R 中训练 CNN 模型所需时间的显著差异，正如我们在上面的图中看到的。
摘要
- 使用 Keras 在 R 中构建和训练 CNN 模型就像在 Python 中一样“简单”,具有相同的编码逻辑和函数命名约定
- 你的 Keras 模型的最终精度将取决于神经网络结构、超参数调整、训练持续时间、训练/测试数据量等。，但不是您将用于 DS 项目的编程语言
- 用 Python 训练 CNN Keras 模型可能比 R
附言
如果您想了解更多关于 Keras 的知识，并能够使用这个强大的库来构建模型，我向您推荐以下书籍:
- f . Chollet(Keras 创作者之一)用 Python 进行深度学习
- f . Chollet 和 J.J. Allaire 的深度学习与 R
- 以及这个 Udemy 课程开始你的 Keras 之旅
非常感谢您的关注！我希望这篇文章能够帮助有抱负的数据科学家理解不同技术的用例，并避免在选择 DS 项目完成工具时产生偏见。
径向基函数神经网络—我们需要知道的一切
单感知器 / 多层感知器(MLP) 中的⁃，我们只有线性可分性，因为它们是由输入层和输出层(MLP 中的一些隐藏层)组成的
比如⁃，与、或函数是线性可分的&异或函数是不线性可分的。
Linear-separability of AND, OR, XOR functions
⁃我们至少需要一个隐藏层来导出非线性分离。
⁃我们的 RBNN 它做的是，它将输入信号转换成另一种形式，然后可以馈送到网络中以获得线性可分性。
⁃ RBNN 在结构上与感知器(MLP)相同。
Distinction between MLP and RBF
⁃ RBNN 由输入、和输出层组成。RBNN 被严格限制为只有一个隐含层。我们称这个隐藏层为特征向量。
⁃ RBNN 增加特征向量的维数。
Simplest diagram shows the architecture of RBNN
Extended diagram shows the architecture of RBNN with hidden functions.
⁃:在我们进行分类问题之前，我们将非线性传递函数应用于特征向量。
⁃当我们增加特征向量的维数时，特征向量的线性可分性增加。
非线性可分离问题(模式分类问题)在高维空间中比在低维空间中高度可分离。
【 盖兹定理 】
⁃什么是径向基函数？
⁃我们定义一个受体= t
⁃:我们在受体周围画正面图。
⁃高斯函数通常用于弧度基函数(正射映射)。所以我们定义径向距离 r = ||x- t||。
Radial distance and Radial Basis function with confrontal map
高斯径向函数:=
ϕ® = exp (- r /2 σ )
其中σ > 0
Classification only happens on the second phase, where linear combination of hidden functions are driven to output layer.
⁃的例子。XOR 函数:-
⁃，我有 4 个输入，我不会在这里增加特征向量的维数。因此，我将在这里选择 2 个受体。对于每个变换函数ϕ(x)，我们将有每个受体 t
⁃现在考虑 RBNN 结构，
⁃ P := #个输入特征/值。
⁃ M = #变换的矢量维数(隐藏层宽度)。所以 M ≥ P 通常为。
⁃在隐藏层的每个节点上，执行一组非线性的弧度基函数。
⁃输出 c 将保持与分类问题相同(预先定义一定数量的类别标签)。
Architecture of XOR RBNN
Transformation function with receptors and variances.
Output → linear combination of transformation function is tabulated.
只有隐藏层中的⁃节点执行弧度基变换功能。
⁃输出层执行隐藏层输出的线性组合，以给出输出层的最终概率值。
⁃所以分类只做了@ (隐藏层→输出层)
训练 RBNN :-
⁃ 首先，我们要用反向传播训练隐层**。**
⁃神经网络训练(反向传播)是一种曲线拟合方法。在训练阶段拟合一条非线性曲线。它通过随机逼近，我们称之为反向传播。
⁃对于隐藏层中的每个节点，我们必须找到 t (受体)&方差( σ )【方差——径向基函数的扩散】
⁃在第二个训练阶段，我们要更新中隐藏层&输出层之间的加权向量。
在隐藏层中，的每个节点代表的每个变换基函数。函数的任意可以满足非线性可分性，甚至函数集合的组合也可以满足非线性可分性。
⁃:所以在我们的隐藏层变换中，所有的非线性项都包括在内。比如说 X+Y+5XY；它全部包含在超曲面方程中(X 和 Y 是输入)。
⁃因此，第一阶段的训练是由聚类算法完成的。我们定义我们需要的个聚类中心。通过聚类算法，我们计算聚类中心，然后将其指定为每个隐藏神经元的受体。
⁃:我必须将 n 个样本或观测值聚类成 m 个聚类(N > M)。
⁃所以输出“集群”就是“受体”。
对于每个受体，我可以找到的方差为"各个受体之间距离的平方和&每个聚类最近的样本 " := 1/N * ||X — t||
⁃对第一个训练阶段的解释是**“特征向量被投影到变换的空间上”。**
Complex diagram depicting the RBNN
使用径向基神经网络比 MLP 的优势:-
1.RBNN 中的训练比多层感知器(MLP)中的快→需要许多交互在 MLP。
2.我们可以很容易地解释 RBNN 隐含层中每个节点的意义/ 功能是什么。这是 MLP 的难**。**
3.(什么应该是隐藏层的节点数 & 隐藏层的节点数)这个参数化在 MLP 很难。但这在 RBNN 中是没有的。
4.分类在 RBNN 比在 MLP 要花更多的时间。
随机蓝调
统计物理学的范式转换理论被用来产生平庸的钢琴即兴创作
投
无论你是梦想成为著名音乐家的软件工程师，还是梦想成为软件工程师的真正摇滚明星:你可能会对算法音乐生成感兴趣。本文描述了一种可能的 AMG 方法——我们将一种简单的蓝调即兴演奏技术数学建模为多维图上决策的马尔可夫链。
Example result of stochastic composition.
由于大多数 AMG 项目的结果充其量听起来很一般，我们并不真正期望超过那个水平，我们希望通过将算法结构嵌入到一些重要和有趣的科学企业中来带来一些非美学价值(从而获得该领域的洞察力)。我们将把这个问题作为一个非古典(即*)扩散过程来处理，并尝试结合一种新颖的数学工具——MERW(见下文),来生成音符序列，希望这些音符序列听起来至少有点像真正音乐才能的早期阶段。*
物理
我们希望将音乐即兴创作视为一个随机过程，我们将把它建模为一组图表上的扩散(见下文)。为了在这些图上移动(从一个节点到另一个节点)，我们将使用一种叫做最大熵随机游走(MERW)的方法。如果你正在跟踪物理学中的“基本”趋势，你可能会遇到这个概念，因为作者的一个大胆的主张是，它提供了一个统计框架，其中贝尔不等式违反是一个确定性的(和局部的！)系统[ 4 ， 5 。
Top: schematic proof of simple Bell inequalities. Bottom: Example of its violation for MERW. See [1, fig. 2]
MERW 的另一个有趣的性质，也是本项目更感兴趣的，是它允许执行经典(即 而不是 量子)扩散，并获得量子系统特有的结果——我们可以观察到强局域化性质，而不是均匀分布。这可能(也可能不会)在理论物理中有很多迷人的含义(例如，“波函数不是真实的，只是统计的，不再有多重宇宙 bs ”)，并有望使一些有趣的 AMG 成分成为可能。
音乐
音调
在我们的钢琴独奏中，我们想要自动化的第一个决策过程，最先进的人工智能算法是这样的问题:接下来弹哪个音符？为了做到这一点，我们在五声音阶 c 小调布鲁斯音阶中定义了这个问题的可能答案的简单图表，并使用它来执行 MERW，在每次迭代中生成一个新的音符。
This graph is for one octave only. In reality we use a similar graph, but stretched over the same notes in each octave available on the usual piano (resulting in 42 vertices instead of 6).
这尽可能地简单明了——图表的定义方式是在每次迭代中强制一步变化，我们只能停留在 c 小调音阶的相邻音符上。
Two measures of semiquavers composed by the random walk.
持续时间(值)
在我们决定播放哪种声音后，我们需要决定它的时间长度(音符值 ) —我们设计的图表保存了播放声音将响起的三十秒音符(半半音)的数量。
Notice that this graph has different numbers of possible transitions for each vertex and some of them have loops (that is, arrows that connect nodes with themselves).
希望你可以看到最长的可能值是半音符( 16 * 1/32 )，还有几个奇数值，比如 14/32(四分音符+带点的八分音符)。这个图有点密集:我们不希望在生成的序列中有更多的可变性和动态性，所以我们为每个顶点定义了多个可能的转换。以 python 可接受的格式阅读可能更容易:
*# Measure duration in thirty-second notes
duration_graph = {
1: [2, 4, 6, 8, 16],
2: [1, 4, 8],
4: [1, 2, 6, 10],
6: [4, 6, 8],
8: [6, 8, 10, 12, 14, 16],
10: [6, 8, 10, 12],
12: [1, 2, 4, 14, 16],
14: [8, 12, 16, 1, 2],
16: [1, 2, 4, 8, 10]
}*
例如，当从八个音符(上图中的 4)开始时，算法将生成这种结果:
Three measures long rhythmic pattern arranged by the random walk.
关节
到目前为止，我们定义了一个生成 c 小调音符流的系统。有人怀疑这可能仍然不够令人印象深刻，所以我们将继续添加控制其他音乐事件的图表层。
Graph for the articulation of every n-th note.
假设我们想要在每个 n - 音符上提供某种重音，其中 n 将是一个动态参数，其值由其自己的图形控制。增加音符在序列中的重要性的许多方法之一是添加另一个高一个八度的音符。
它实现起来非常简单，并且很好地增加了最终作品的复杂性，同时保持了基本的 c 小调和声不受干扰。此外，对于左边显示的图表，这种技术不会导致任何会产生任何节奏感的东西，这偶尔会被认为是一种特征(被一些人)。
为了恰当地说明这种效果，我们可以生成一个一小节的例子，其中充满了中间 C 的半八度音(30 秒的音符),随机加重了一个高八度的 C。
Randomly accented demisemiquavers.
和弦进行
为了使生成的音乐的和声方面更加复杂，我们添加了另一个图表，该图表可以将 c 小调五声音阶切换到建立在该音阶的第四和第五阶上的音阶( F 和 G )。它应该会给我们带来著名的 I-IV-V 感觉。下图描述了可能的转换。
Graph defining the space of possible keys.
结果
当目前为止描述的所有图表都用于生成一个单独的作品时，结果乐谱可能如下所示:
This image was generated automatically form a MIDI file, so it is not optimized for readability.
在这一点上，活页乐谱似乎不是概念化和评估制作的作品的好方法，所以这是开始产生实际声音的好时机。这是一个 15 分钟的 10000 个音符长序列的表演，由目前描述的方法生成:
Share, like, comment and subscribe. Buy merch.
我们分享一些代码，你可以用它们来重现这些结果。
随机森林简介
异常值检测和聚类的说明、解释、偏差和使用
最近更新时间:2018–12–09
随机森林广泛应用于数据科学竞赛和实际问题。它们通常是准确的，不需要特征缩放、分类特征编码，并且需要很少的参数调整。它们也比神经网络等其他复杂模型更容易解释。
内容组织如下。
- 什么是随机森林
- 解读随机森林
- 偏向于具有更多类别的功能
- 处理冗余功能
- 离群点检测
- 使聚集
什么是随机森林
随机森林由多个随机决策树组成。树中内置了两种随机性。首先，每棵树都建立在原始数据的随机样本上。第二，在每个树节点，随机选择一个特征子集来生成最佳分割。
我们使用下面的数据集来说明如何建立一个随机的森林树。注 Class = XOR (X1，X2)。X3 被制作成与 X2 相同(在后面的部分中为了说明的目的)。
An illustrative dataset with two classes colored in red and blue.
下图演示了如何构建随机森林树。
The process of building a random forest tree.
相同的过程适用于构建多个树。下图说明了将带有三棵树的随机森林应用到测试数据实例的流程。
The flow (highlighted in green) of predicting a testing instance with a random forest with 3 trees.
解读随机森林
特征重要性
要素的重要性分数衡量要素的贡献。它基于由于该特征而导致的杂质减少。
让我们向说明性数据集添加一个不相关的特征 X4。重要性分数绘制如下。显然，X1 和 X4 分别具有最大和最小的分数。X2 和 X3 是相同的，重要性分数不同。
部分依赖图
要素的重要性分数并不能说明要素和类是如何关联的。部分依赖图可以可视化特征对类概率的边际效应。
当一个特征与类相关时，图看起来如下图所示，表明 X1 ≤ 0.5 和 X1>0.5 与不同的类相关。
然而，在我们的说明性数据集中，部分依赖关系图看起来像右图-它没有指示 X1 和类之间的任何关系，即使 X1 具有最大的重要性分数。
原因是 X1 必须与 X2 或 X3 交互才能预测类别。单独的 X1 不具有预测性。因此，在这种情况下，部分相关图可能会产生误导。
Left: when X1 alone is correlated to the class, partial dependence is informative. Right: when X1 alone is not correlated to the class, partial dependence can be misleading.
兴趣
重要性分数和部分依赖图都不能说明多个特征如何与类交互。inTrees 框架可以用来更清楚地了解随机森林内部发生了什么。
对于说明性数据集，高度预测的交互及其相关类可以用 inTrees 提取，如下所示。频率(0%-100%)衡量交互在随机森林中的受欢迎程度，准确度(0-1)衡量交互预测类别的准确度。
偏向于具有更多类别的功能
对于说明性数据集，让我们添加一个具有 30 个类别的随机特征 X5。即使特征与类别无关，X5 的重要性分数也大于真正有信息的特征 X2 和 X3，这表明对具有更多类别的特征的不正确的偏好。
X1, X2, and X3 are truly informative, X4 and X5 are irrelevant, and X5 has many categories.
一种解决方案是执行特征选择。例如，在 randomForest R 包中，可以使用特性对精度的影响(importance $ meandercise accuracy)来评估特性。下面的精度影响图显示，与真正提供信息的特征相比，X5 的精度影响非常小，这表明该特征混淆了模型，应该在拟合分类器之前删除。
处理冗余功能
当特征彼此相似时，这些特征的重要性分数可能会产生误导。在说明性数据集中，X2 和 X3 是相同的，它们“共享”重要性分数(如下左图所示)。当冗余特征越多，每个特征的重要性就越小。
这可能不会损害精度性能，但可能会在解释中产生误导。一个解决方案是规则化随机森林(RRF)。在树构建过程中，RRF 记忆在先前的树节点中使用的特征，并且在分裂未来的树节点时更喜欢这些特征，因此避免了树中的冗余特征。下图显示了 RRF 的重要性分数。
Left: feature importance from a random forest; Right: feature importance from a regularized random forest.
随机森林中的离群点检测
用随机森林进行聚类可以避免对特征变换(例如，分类特征)的需要。此外，这里还可以使用一些其他随机森林函数，例如概率和解释。在这里，我们用左图中绘制的二维数据集来演示该方法。
这个想法是生成一个与原始数据形成对比的随机数据集。这里我们随机排列每个特征。这两个数据集分别标有两个类别(比如“正常”和“随机”)。合并后的数据集如下右图所示。
Left: original data; Right: generate a two-class data set. class 1: original data; class 2: the same size as the original data but with X1 and X2 randomly permuted.
在数据集上构建随机森林。然后，可以将分类器应用于测试数据实例。如果预测的类是“随机的”，那么它被识别为异常值。发现的异常值如下图所示。
通过查看重要性分数，我们可以了解哪些特征有助于离群点检测。为了便于说明，我们添加了一个与类别无关的随机特征 X3。重要性分数如下图所示。X1 和 X2 被确定为重要特征，而 X3 不太重要。
Left: outlier detection. Right: feature importance score in outlier detection.
随机森林聚类
与离群点检测类似，使用随机森林进行聚类可以节省特征预处理的工作量。
该过程类似于异常值检测。首先，创建一个与原始数据大小相同的合成数据集。然后用两个不同的类标记原始数据和合成类。然后为分类问题建立一个随机森林。
从构建的随机森林中，提取每对数据实例之间的相似性得分。两个数据实例的相似性通过两个数据实例出现在同一叶节点的树的百分比来衡量。
有了相似性得分，诸如分层聚类之类的聚类算法就可以用于聚类。下图显示了预定义聚类数分别为 2 和 4 时的聚类结果。
Left: clustering with 2 clusters. Right: clustering with 4 clusters.
摘要
随机森林不仅在分类/回归方面非常强大，而且在异常值检测、聚类和解释数据集(例如，作为具有兴趣的规则引擎)等方面也非常强大。
但是，使用随机森林时很容易出错。首先，当数据集中存在多级分类特征时，可能会有偏差。第二，当特征是冗余的时，重要性分数可能是误导的。本文提供了这些问题的解决方案。
你可能有兴趣阅读一篇关于为什么随机森林优于决策树的相关文章。
在 dataanalyticsbook.info 可以找到我的书的更多内容。
随机森林编码器
随机森林是机器学习中最常用的技术之一。它们计算速度快，可以并行计算，可以处理数值和标称值，并且预测能力强。
随机森林中使用的技术是一种叫做装袋的综合方法。集成方法训练许多弱学习者，并将它们组合成一个强学习者；在 bagging 中，弱学习者是通过使用数据的增强捕获样本来训练一个“基础学习者”而产生的。然后将这些基础学习者的结果与(加权)平均值相结合以获得预测。
Example for a Random Forest. The color represents the pruity of the node. Each tree results in one score. The score of the forest is the average of the individual trees.
随机森林使用一个非常特殊的学习器作为基础学习器:随机树。随机树类似于决策树，但是每个节点只使用所有列的子集。
如何更好的组合树木？
这里出现的一个问题是——为什么我们只是平均所有的树？我们就不能做一些更“智能”的事情吗？答案当然是——是的，有一点。
一种方法是创建一个新表。新表有一个针对所有行的标签列(用作预测目标)，还有一个新的置信度/概率列。这使我们能够“学习另一个学习者”，将置信度作为输入并预测我们的标签。你可以认为这是另一种系综方法——叠加。
这种想法的危险在于，你给你的模型增加了额外的复杂性，这可能会导致过度拟合。我强烈建议小心验证这些树。
随机森林作为编码方法
看待这种方法的另一种方式是将随机树的所有置信度放入一个新列，类似于 PCA 或 t-SNE 所做的。我们输入数据，得到与目标变量更相关的数据的新表示。这就是我所说的“编码器”。这个编码器的美妙之处在于，你可以输入名义数据，然后输出数值。这使我们能够将这种编码的结果输入到神经网络和支持向量机等学习器中。
在编码的情况下，我建议小心控制深度树，不要在一个属性中编码太多的路径。另一方面，深度控制着你的柱子之间的“互动水平”。
在 RapidMiner 中实现
Implementation using RapidMiner. The table delivered at the most upper output of Random Forest Encoder has includes all the scores of the individual trees.
我最近添加了一个新的操作符，让它在 RapidMiner 中更容易使用。RapidMiner 是一个开源的数据科学平台，它支持无代码的数据科学。操作符是用 Java 写的，可以从市场下载。操作员获取一个数据集和一个随机森林模型并进行转换。
当然，也可以通过在系综的子树上迭代，在 Python 或 R 中快速实现这一点。
随机森林学习-基本理解
> >使用> > 决策树模型进行参数化
> >集成了> > 三种技法，
**1。**一种采样技术
2。子空间法，和
3。集合方法
优化模型构建
抽样方法 := 自举；采用随机抽样方法，用替换。
子空间法 := 也采用了随机的采样方式，
但是有助于提取更小的特征子集(子空间)。
有助于基于它们构建决策树。
为随机森林构造选择决策树。
集合方法:= 基于打包方法；帮助构建分类器。
1.1 随机森林(RF)
树木可以是
1。分类树
2。回归树
因此 RF 可以应用于两者。
- 决策树为测试阶段提供单个训练好的决策树分类器。
- 但是 RF 为测试阶段提供多个训练好的 DT 分类器。
- 这一特性使得 RF 比常规 DT 学习更受青睐。
The construction of a Decision Tree using 1-D data domain & bootstrap sampling.
平行结构
- 并行化是 RF 对 增强分类性能 的贡献属性之一。
- DT 可以在的同时建立，用于 RF 建模的分类。
- 这种射频并行结构有助于大数据分类。
The parallelization feature of the random forest technique
模型参数
- RF 的参数化包括 DT 型号的参数化，因为它内部采用了另一个。
- 因此，RF 模型由 DT 的参数组成，但也有更多的新参数。
例如，特征子集中的#个，选择用于构建 RF 的#个 DTs
增益/损失函数
- 参数的优化基于
1。自举采样
2。子空间整合
在模型建筑中
- 树构建使用与 DTs 中使用的相同的量化度量来选择最佳特征，例如。
1。熵
2。基尼杂质
3。信息增益
自举和装袋
- 为了优化分类目标，
1。统计措施，
2。自举，
3。装袋
在射频学习中起着重要的作用。
1.1.4.1 自举
- BS 是一种简单的随机化技术。
- 它在射频方面的效果非常出色。
- 它通过随机选择从一组数据中选择几个 子集，但与原始数据集中的观测值完全相同，只是用 替换**。**
- 所以有些观察值可以在数据集的一个子集里多次出现**。**
- 概念:-
在每个中间节点& DT 的叶子上最大化“类距离”。
- BS 应用于射频算法的训练阶段。
1.1.4.2 重叠细化
- BS 给数据域带来了一些影响。
- BS 生成多个域**，其中类可能比原始数据域更加孤立。**
- 这些隔离数据域中的类可以通过单个拆分轻松分离。****
- 有时候我们可能不需要分裂。
1.1.4.3 装袋
- 指 BS 样本给出的预测**(分类)响应的平均，得到最终预测结果。**
- 套袋来自 自举聚集。
- BS 用“ 简单类重叠细化 ”创建多个域，这些域帮助创建多个分类模型**，多个分类模型允许测试算法高效地评估分类器的**性能。****
- 在 RF 算法的测试阶段应用 Bagging。
1.2 随机森林学习模型
- 实现参数化目标&优化目标。****
1.2.1 参数化
- 参数，
1。使用自举生成的域数量— A.
2。每个节点(域)的子空间大小— B.
3。域分割的阈值— C.
- 参数化的目标:-
我们需要找到或建议参数的可能值。
- A 的通常值是 10 。
但是进行“交叉验证并确定一个合适的取值范围是合适的。****
- 对于 B 选择，有 2 个约束。
- 第一个建议是 n < < p &它必须在 DT 的整个构建过程中保持不变。
- 第二 constriant，n<= sqrt§；我们在原始数据域中有 p 个特性。其中有 n 个是好的。良率在 n/p. 其中特征之一为最佳**之一，其良率为 1/n.**
****
- 人们使用 sqrt§ 作为特征的 #进行随机选择。
优化
一旦选择了参数，模型就被参数化了。那么必须优化参数。
- 但是在 RF 参数化&优化中嵌套**，&它们是同时**执行的。****
- 已经在树的每个节点进行了优化。****
- RF 优化的主要参与者是基尼指数(熵)&信息增益。
1.3 随机森林学习算法
- 像其他机器学习算法一样，由 3 部分组成； 培训、验证和测试。
- 交叉验证已经包含在培训协议中。
- 所以射频技术不需要不需要单独的 验证算法。
简单地说:-
RF 学习为我们提供了几个空间(最佳特征组合)，在这些空间中可以执行最佳的领域划分&可以获得高的分类精度。
- 因此，射频分类目标只分为****训练&测试算法。****
1.3.1 训练算法
- 这提供了一种系统化的方法来开发多分类器 (DTs)，以便测试算法使用多分类器来选择对新数据进行分类的最佳方式。
第一步::—
— 为给定数据创建多个子空间。
r < = sqrt§
p = #特性；
r =子空间尺寸
第二步::—
****—我们有明显更小的 r ( 维度子空间 )，因此我们可以使用 DT 构建过程为根节点找到最佳特征 & 最佳分裂位置(域划分)。
[但是我们不对这个子空间执行这个过程，所以跳到下一步]
第三步::—
— 随机改变子空间使用引导样本&创建多个引导子空间，其中重叠细化发生在数据域中。****
第四步::——
—通过应用 DT 算法为每个引导子空间寻找最佳特征和最佳分裂位置来为 DTs 构建节点。
第五步::—
—现在，每个引导样本都有一个 DT(分类器)。
——这些树可以被测试算法用来分类新的数据。
射频相对于 DT 的优势，
1.在测试空间=>将增加和的分类精度。
2.bootstrap 样本用于多个 DTs，这将有助于通过重叠细化增加分类边界的锐化。****
3.为了在整个空间中找到最佳特征&最佳分割位置而进行的穷举搜索被通过子空间搜索 = > 消除在 bootstrap 采样中很小的附加计算成本。** ( 计算优势)**
测试算法
- 测试要求整个射频可以在早期使用几个自举样本(10)** 构建。然后贴标过程就可以开始了。**
- 步骤，
1.功能选择:
来自输入数据的正确的特征序列必须是“观察到的”。
2.树选择:
我们有 N 个射频分类器。所以我们推送新的数据根据的特性通过所有的&DTs 获取其类标签。
3.装袋:
上一步选择的树用于寻找获得的结果的集合(套袋技术****
F 最后，我们可以通过 表决机制 得出新的观察属于一个特定的标签。
****
随机森林可扩展性
- 在典型的数据科学应用中，****
#的特性是固定的。
RF 技术从中选择一个子空间，并基于 bootstrapping 构建“深度优先决策树”来构造 RF。
- 但是在大数据中，****
功能集可以动态“增长”。
- 这个问题可以通过构建“宽度优先决策树”来解决。这里的 DTs 是在并行中构建的。
然而，在深度优先** & 传统 RF 中，DT 是在一个 DT 被完全构建之后构建的。**
参考:-
大数据分类的机器学习模型与算法，Shan Suthaharan 第十一章——随机森林学习
随机森林——谜底揭晓
image by Jens Lelie on unsplash.com
为您的应用选择“正确的”机器学习算法是在现实世界中正确应用机器学习的众多挑战之一。正确的算法有时可能是最简单、最健壮、最容易被最终用户理解的算法。Random Forest 会定期勾选所有这些框，但正如其他人所写的那样，它经常被忽略。希望这篇文章能让你对算法的工作原理有一个坚实的了解，这样你在进行自己的研究或在 R 或 Python 这样的工具中应用时会更有信心。
随机森林是一种监督学习算法，通常应用于分类和回归情况。简单介绍一下，该算法是一个集合模型，创建一个由许多决策“树”组成的“森林”,树的数量由用户定义。每个决策树都是基于原始数据集中的属性(列)和观察值(行)的子集创建的。这些树是使用训练数据集生长的，并应用于测试数据集。模型返回的最终分类是与最大数量的单个决策树提供的分类相匹配的分类。
由于随机森林只是由最大数量的树返回的分类，所以本博客将关注决策树本身，它是算法的核心。
什么是决策树？
决策树是一种流型结构，其中数据中的每个属性都表示为一个“内部节点”，每个“分支”表示一个测试的结果，“叶子”表示所做的分类。算法中的每个决策树都是使用来自原始训练数据集的不同的“随机”属性和观察值子集创建的。
[1]
下一部分可能会令人困惑(至少对我来说是这样！)所以希望我的解释是清楚的。决策树以析取范式创建，其中决策是“和的一个“或”。或者，这可以被表述为一个或多个文字的一个或多个合取的分支。[2]上面的决策树示例将第一个析取项显示为“工资高于”或“低于 6 万美元”。就树的结构而言，这也是内部节点。代表“否”的分支是此薪金测试的结果，其中“拒绝”是分类。第二条分界线是两年以上的工作经验。我们同样有一个拒绝分类，但在本例中，我们还有一个批准分类。要达到批准的分类，工作经验必须在 2 年以上，并且(联合)薪金> $60k 测试的结果必须为真/是。下面嵌入了一个简短的视频，其中讨论了析取陈述。维基百科也有一篇关于逻辑析取的文章，其中包括维恩图来突出‘或’属性。
属性排序和拆分
如上所述，决策树中的每个级别或分支代表用于单个决策树的随机数据段中的一个属性。考虑到最终模型的准确性以及与树相关的计算工作量，这些属性的排序非常重要。换句话说，属性应该以这样一种方式排序，以便为将来的观察分类提供最有效和最丰富的结构。在决策树中，属性的优先级是根据属性分解后的“信息增益”来确定的。
来自子内部节点的信息增益等于父节点的熵(无序度)减去子节点的加权平均熵。加权基于通过每个分支进行的分类的数量。当分类中存在完美分离时，熵为零，即所有“真”的结果导致“好”的分类，所有“假”的结果导致“坏”的分类。当“真”和“假”结果返回相同数量的“好”和“坏”分类时，熵为“1”(最大可能熵)。第二个例子没有提供信息增益，因为在两个可能的结果之间存在有效的分类随机分裂，并且树没有获得信息。因此，作为树的“根”,这是一个很差的属性。
熵是一个与系统的有序或无序有关的术语。高熵与高度无序相关，反之亦然。下面是来自 Udacity 的两个短视频，涵盖了熵和信息增益的概念。它们构成了一个免费系列的一部分，该系列介绍了机器学习的主题。
为了保持这篇文章的简短，我将在讨论包括决策树的“修剪”和与修剪概念密切相关的过度拟合的概念之前结束这篇文章。我将在以后的文章中讨论这两个问题，但是希望到目前为止的总结已经揭开了强大的随机森林算法的帷幕。
[1]* https://data aspirant . com/2017/01/30/how-decision-tree-algorithm-works/
[2]门德尔松，e .数理逻辑导论，第 4 版。伦敦:查普曼&霍尔出版社，第 27 页，1997 年。
python 中的随机森林和决策树
介绍
随机森林是集成机器学习方法的主要例子。简而言之，集成方法是一种聚合预测性较低的基础模型以产生更好的预测模型的方法。正如人们可以直观猜测的那样，随机森林通过减少决策树臭名昭著的过度拟合倾向，集成各种决策树以产生更一般化的模型。决策树和随机森林都可以用于回归和分类问题。在这篇文章中，我们创建了一个随机森林回归器，尽管在下面的代码中只需稍加修改就可以创建一个分类器。
先决条件
我建议你具备以下方面的工作知识，以便更好地理解这篇文章:
- 决策树:我们也将为我们的随机森林从头开始创建这种树，但我不会解释它的理论和工作机制，为简洁起见， 推理因此，在一个帖子里把所有东西都搅在一起只会让它变得不合理。
- 集成学习(Ensemble learning):随机森林只是这个庞大的机器学习技术集的一个子集，如果你对这个有一个基本的了解，你会更好地理解这个帖子(不要为了这个帖子而谈论太多细节)
- 熊猫图书馆:一个好的木匠必须精通他的工具。这两个库是我们的工具。
理论
在开始编写我们的代码之前，我们需要了解一些基本理论:
- 特征装袋 : b 根带聚集再聚集或装袋是从替换的原始组中随机选择一定数量样本的方法。在特征打包中，原始特征集被随机采样并传递到不同的树上(没有替换，因为具有冗余特征没有意义)。这样做是为了降低树之间的相关性。具有无与伦比的重要性的特征将导致每个决策树选择它进行第一次和可能的后续分裂，这将使所有的树表现相似，并最终更加相关，这是不希望的。我们的目标是制作高度不相关的决策树。
为什么要让决策树高度不相关？
我们需要高度不相关的决策树，因为“一组完全随机误差的平均误差是零”，因此通过降低相关性并使每棵树尽可能随机地分裂(在特征选择的意义上是随机的，我们的目标仍然是在随机选择的一组列中找到最佳分裂)，我们可以获得更好的无误差预测。
Correlated trees | Both have same feature set and make similar splits
People travel lands, i travel timeuncorrelated trees | Both have randomly selected different feature set and make different splits
2.聚合:使随机森林优于决策树的核心概念是聚合不相关的树。这个想法是创建几个蹩脚的模型树(低深度)并平均它们来创建一个更好的随机森林。一些随机误差的平均值为零因此，我们可以从我们的森林中获得广义预测结果。在回归的情况下，我们可以平均每个树的预测(平均值)，而在分类问题的情况下，我们可以简单地取每个树投票的类别的大多数(模式)。
Python 代码
为了从头开始编码我们的随机森林，我们将遵循自顶向下的方法。我们将从一个单独的黑盒开始，进一步分解成几个黑盒，减少抽象层次，增加细节，直到我们最终达到不再抽象任何东西的程度。
随机森林类
我们正在创建一个随机的森林回归器，尽管同样的代码可以稍微修改一下来创建一个分类器。首先，我们需要知道我们的黑盒将什么作为输入来产生输出(预测)，因此我们需要知道定义我们的随机森林的参数:
- x :训练集的自变量。为了保持事情最小和简单，我没有创建一个单独的 fit 方法，因此基类构造函数将接受训练集。
- y :监督学习所需的相应因变量(随机森林是一种监督学习技术)
- n_trees :我们集合起来创建随机森林的不相关的树的数量。
- n_features :采样并传递到每棵树上的特征数量，这是特征打包发生的地方。它可以是 sqrt、log2 或整数。在 sqrt 的情况下，采样到每棵树的要素数是总要素数的平方根，在 log2 的情况下是总要素数的对数底 2。
- sample_size :随机选择并传递给每棵树的行数。这通常等于总行数，但可以减少以提高性能，在某些情况下减少树的相关性(树的打包是一种完全独立的机器学习技术)
- **深度:**每个决策树的深度。更高的深度意味着更多的分裂，这增加了每棵树的过度拟合趋势，但是因为我们聚集了几个不相关的树，所以单个树的过度拟合几乎不会干扰整个森林。
- min_leaf :一个节点中导致进一步拆分所需的最小行数。min_leaf 越低，树的深度越高。
让我们开始定义我们的随机森林类
- init :构造函数在我们参数的帮助下简单地定义随机森林，并创建所需数量的树。
- create_tree :通过调用类
DecisionTree的构造函数创建一个新的决策树，这个类现在被认为是一个黑盒。我们稍后将编写它的代码。每棵树都接收一个随机的特征子集(特征打包)和一组随机的行(打包树，虽然这是可选的，但我写它是为了展示它的可能性) - 预测:我们的随机森林的预测只是所有决策树预测的平均值。
如果我们能神奇地创造出树木，这就很容易想象出一个随机的森林。现在，我们降低抽象层次，编写代码来创建决策树。
如果你知道如何从头开始写一个决策树，你可以在这里停止阅读，但是如果你不知道，那么继续阅读。
决策树类
它将具有以下参数:-
- indxs :该参数的存在是为了跟踪原始集合的哪些索引去了右边，哪些去了左边的树。因此，每棵树都有这个参数“ indxs ”，它存储它所包含的行的索引。预测是通过对这些行进行平均来进行的。
- min_leaf :一个叶节点上能够引起拆分所需的最小行样本。每个叶节点将具有小于 min_leaf 的行样本，因为它们不能再分割(忽略深度约束)。
- 深度:每棵树内可能的最大深度或最大分裂数。
Why are decision trees only binary?
我们使用属性修饰器来使我们的代码更加简洁。
- init :决策树构造器。它有几个有趣的片段值得研究:
a.如果我们在这个特定树的计算中没有指定行的索引，只需取所有的行。
b.self.val = np.mean(y[idxs])每个决策树预测一个值，这个值是它保存的所有行的平均值。变量self.val保存对树的每个节点的预测。对于根节点，该值只是所有观察值的平均值，因为它包含所有的行，因为我们还没有进行分割。我在这里使用了“节点”这个术语，因为本质上决策树就是一个节点，它的右边有一个决策树，左边有一个决策树。
c.self.score = float(‘inf’)节点的得分是根据它划分原始数据集的“好”程度来计算的。我们稍后会定义这个“好”，现在让我们假设我们有一个方法来测量这样一个量。此外，我们的节点的分数被设置为无穷大，因为我们还没有进行任何分割，因此我们现有的分割是无限糟糕的，这表明任何分割都比没有分割好。
d.self.find_varsplit()我们第一次分开了！
-
find_varsplit: 我们使用蛮力方法来寻找最佳拆分。该函数按顺序遍历所有列，并在所有列中找到最佳拆分。这个函数仍然是不完整的，因为它只进行了一次分裂，后来我们扩展了这个函数，为每次分裂生成左右决策树，直到到达叶节点。
-
split_name :一个属性装饰器，返回我们要拆分的列的名称。
var_idx是该列的索引，我们将在find_better_split函数中计算该索引以及我们拆分的列的值 -
split_col: 一个属性装饰器，用于返回索引
var_idx处的列，该列包含由indxs变量给出的索引处的元素。基本上，用选定的行分隔一列。 -
find_better_split: 这个函数在某一列中寻找可能的最佳拆分，这很复杂，所以我们在上面的代码中把它看作一个黑盒。让我们稍后定义它。
-
is_leaf :叶节点是从未进行过分裂的节点，因此其得分为无穷大(如上所述)，因此该函数用于识别叶节点。同样，如果我们已经越过了最大深度，即
self.depth< = 0，那么它就是一个叶节点，因为我们不能再深入了。
如何找到最佳分割？
决策树通过基于特定条件递归地将数据分成两半来训练。如果一个测试集有 10 列，每列有 10 个数据点(值)，总共有 10×10 = 100 个拆分是可能的，我们手头的任务是找出这些拆分中哪一个最适合我们的数据。
我们根据将数据分成两半的效果来比较拆分。我们进行分割，使两半的每一半都具有最“相似”的数据类型。增加这种相似性的一种方法是减少两半的方差或标准差。因此，我们希望最小化两半标准偏差的加权平均值(分数)。我们使用贪婪方法，通过将列中的每个值的数据分成两半，并计算两半的标准偏差的加权平均值(得分),最终找到最小值，从而找到拆分。(贪婪的方法)
为了加快速度，我们可以复制该列，并对其进行排序，以通过使用由拆分nth索引创建的两个一半的值的总和和平方和在n+1th索引处拆分值来计算加权平均值。这是基于以下标准偏差公式:
下图形象地展示了分数计算的过程，每幅图的最后一列是一个数字，代表分裂分数，即左右标准差的加权平均值。
继续对每一列进行排序
Sort the column
现在我们按指数顺序进行分割
Start with index = 0
index = 1
index = 2 (best split)
index = 3
index = 4
index = 5
通过简单的贪婪方法，我们发现在 index = 2 上进行的分割是最好的可能分割，因为它具有最小的分数。我们稍后对所有列执行相同的步骤，并对它们进行比较，以贪婪地找到最佳(最小)分数。
以下是上述绘画作品的简单代码:
以下代码片段很有趣，需要一些解释:
- 函数
std_agg使用值的总和以及平方和计算标准偏差 curr_score = lhs_std*lhs_cnt + rhs_std*rhs_cnt每次迭代的拆分分数就是两半的标准偏差的加权平均值，每一半的行数作为它们的权重。较低的分数有利于较低的方差，较低的方差有利于相似数据的分组，这将导致更好的预测。if curr_score<self.score: self.var_idx,self.score,self.split = var_idx,curr_score,xi每当当前分数更好时(小于当前保存在self.score中的分数)，我们将更新当前分数，并将该列存储在变量self.var_idx中(记住这是帮助为我们的两个属性装饰者选择列的变量)，并将进行拆分的值保存在变量self.split中。
既然我们知道了如何为所选的列找到最佳的拆分，我们需要为每个进一步的决策树递归地定义拆分。对于每棵树，我们找到最佳列和它的值来分裂，然后我们递归地生成两个决策树，直到我们到达叶节点。为此，我们扩展我们的不完整函数find_varsplit如下:
for i in range(self.c): self.find_better_split(i)这个循环遍历每一列，并试图找到该列中的最佳拆分。到这个循环结束时，我们已经对所有列进行了所有可能的拆分，并找到了最佳可能的拆分。要拆分的列存储在self.var_idx变量中，我们拆分的列的值存储在self.split变量中。现在我们递归地形成两半，即右和左决策树，直到我们到达叶节点。- 如果我们已经到达了叶节点，我们不再需要寻找更好的分裂，简单地结束这棵树。
self.lhs持有左侧决策树。它接收的行保存在lhs中，这些行是所选列中小于或等于split.value中存储的拆分值的所有此类值的索引。变量lf_indxs保存左树接收到的特征(列)样本(特征打包)。self.rhs掌握正确的决策树。rhs存储传递到右侧决策树的行的索引。rhs的计算方式与lhs类似。同样，变量rf_indxs保存右侧树接收到的特征(列)样本(特征打包)。
结论
这是完整的代码
这篇文章的目的是让读者和我自己更熟悉随机森林的一般工作方式，以便将来更好地应用和调试。随机森林有更多的参数和相关的复杂性，我不可能在一篇文章中涵盖。为了研究一个更加健壮和有益的代码，我建议你阅读开源的 sklearn 模块的随机森林代码。
我要感谢杰瑞米·霍华德和瑞秋·托马斯的 fast.ai 机器学习课程，让我能够写这篇文章。事实上，我在这里的所有代码都是在对最初的 fast.ai 课程材料做了小小的改动后创建的。
如果我的解释有错误/不清楚，请在回复中告诉我。感谢您的阅读。
随机森林和偏差-方差权衡
Photo by Lukasz Szmigiel on Unsplash
随机森林是一种非常流行的机器学习算法。通常，在没有太多预处理的情况下，人们可以快速构建一个不需要超参数调整的脏模型，并获得不错的结果。例如，我最近在 Kaggle 上使用scikit-learn用 Python 编写了一个用于纽约市出租车费用预测游乐场竞赛的RandomForestRegressor，没有向模型构造器传递任何参数，使用 1/100 作为训练数据(554238 行，约 55M)，验证 R 约为 0.8。你自己试试！
注意:这个代码片段假设您将数据分成训练集和验证集，并将您的特征和目标变量分开。你可以在我的 GitHub 个人资料上看到完整的代码。
这种算法如此聪明的部分原因是它如何处理被称为的偏差-方差权衡。我在以下 5 个步骤中探索了随机森林的这一方面:
- 偏差和方差
- 决策树
- 装袋、引导和随机森林
- 超参数调谐
- 随机森林和偏差-方差权衡
偏差和方差
统计模型的均方误差(MSE)可以表示为其预测的平方偏差、这些预测的方差和某个误差项𝜖的方差的总和。由于偏差和方差的平方都是非负的，并且捕捉数据随机性的𝜖超出了我们的控制，我们通过最小化模型的方差和偏差来最小化 MSE。我发现图 1 中的图像特别能说明这两个术语的意思。
Fig. 1: A visual representation of the terms bias and variance.
如果我们的模型系统地低估或高估了目标变量，我们就说它有偏差。在机器学习中，这通常是我们选择的模型做出的统计假设或训练数据中的偏差的结果。看看这篇文章的一个偏见的例子，谷歌的云自然语言 API 通过互联网上的文本了解到“同性恋”这个词带有固有的负面内涵。
另一方面，方差在某种意义上抓住了模型的普遍性。更准确地说，这是一个衡量我们的预测会发生多大变化的指标，如果我们对不同的数据进行训练的话。高方差通常意味着我们过度适应我们的训练数据，发现模式和复杂性是随机性的产物，而不是一些真实的趋势。通常，由于过度拟合，更复杂或更灵活的模型往往具有较高的方差，但偏差较低，因为对几次预测进行平均，我们的模型会更准确地预测目标变量。另一方面，拟合不足或过于简化的模型虽然方差较低，但可能会更有偏差，因为它缺乏充分捕捉数据趋势的工具。
理想情况下，我们想要的是**低偏差-低方差。**为了了解如何做到这一点，我们先来看看典型的偏差平方方差曲线。
Fig. 2: A curve of squared bias vs variance showing the inverse correlation that is typical of the relation between the two as the model gets more complex. It is not uncommon for the resulting Total Error to follow some variant of the U-shape shown in the figure.
图 2 展示了随着我们的模型变得越来越复杂，我上面描述的偏倚减少和方差增加的总体趋势。我们的目标是选择一个最小化两个之和的模型，如虚线所示。为了了解随机森林是如何做到这一点的，让我们从一个简单的决策树开始。
决策树
Fig. 3: Representation of a single decision tree with no bootstrapping and max_depth of 3 that I created for the New York City Taxi Fare Prediction competition on Kaggle.
让我们回到出租车费用预测任务。给定特定出租车乘坐的某些特征，决策树通过简单地预测训练数据集中的平均出租车费用(＄11.33)开始，如图 3中最左边的框所示。然后，它遍历所有特性及其值的列表，找到一个给我们最大 MSE 改进的二进制分割。这通常是通过预测两个新子集的平均值并计算它们各自的 MSE 来计算的，MSE 由每个子集中的观察值的数量来加权。
在这种情况下，最佳分割恰好是行驶距离是否小于或等于 0.083(纬度/经度单位= 5.727 英里)。当它小于 5.727 英里时，该树预测为 9.28 美元，这是距离小于此值的乘坐的平均费用，通过相同的程序，对于比我们的阈值更长的乘坐，预测为 35.09 美元。这是有道理的。长途旅行更贵。
如图所示，然后根据 MSE 最大改进的相同标准，将每个分支分成新的分支，递归继续，直到每个叶(样本组)中只有一个训练观察。决策树具有极低的偏差，因为它们最大限度地过度适应训练数据。**它在验证集上做出的每个“预测”本质上都是我们的训练数据中某次出租车乘坐的费用，该数据与我们预测其费用的乘坐在同一个最终叶节点中结束。**然而，这种过度拟合也会导致不可接受的高方差，从而导致对未知数据的不良预测。
打包、引导和随机森林
虽然单个树过度适应训练数据并且可能具有较大的误差，但是bagging(BootstrapAggregating使用适当的大量不相关误差平均为零的洞察力来解决这个问题。Bagging 从训练数据中选择多个随机观察样本，通过替换，从每个样本中构建一个树。因为每棵树都从不同的数据中学习，所以它们彼此之间是不相关的。随着我们增加“袋装”树的数量，绘制我们模型的其余部分(scikit-learn称这些树为estimators)说明了这种技术的威力。
(array([ 9\. , 8.1, 8.1, 11.5, 6.1, 6.9, 6.5, 8.1, 10.5, 6.5]), 8.13)
Fig. 5: A plot showing incresing R² as n_estimators is increased from 1 to 9.
把我们森林中的每棵树都想象成从它所建模的数据子集中学习一些关于纽约市出租车费用的独特见解。将他们的每个预测平均在一起，然后给我们一个更强大、更稳定的模型，能够以更高的精度预测出租车的费用。
超参数调谐
然而，随机森林不仅仅是装袋的树，它使用了许多有趣的技术来进一步降低树之间的相关性和减少过度拟合。快速浏览一下 scikit-learn 实现RandomForestRegressor的文档，可以看到我们可以传入的超参数:
*class* sklearn.ensemble.**RandomForestRegressor**(*n_estimators=10*, *criterion=’mse’*, *max_depth=None*, *min_samples_split=2*, *min_samples_leaf=1*, *min_weight_fraction_leaf=0.0*, *max_features=’auto’*, *max_leaf_nodes=None*, *min_impurity_decrease=0.0*, *min_impurity_split=None*, *bootstrap=True*, *oob_score=False*, *n_jobs=1*, *random_state=None*, *verbose=0*, *warm_start=False*
它们有十几种，但在这里我会仔细看看n_estimators、max_depth、min_samples_leaf和max_features的作用，以及为什么它们中的每一种都有可能降低模型的误差。
n _ 估计量
n_estimators简单来说就是树的数量。森林中不相关的树木越多，它们的个体误差就越接近平均值。然而，越多并不总是越好，这里有一些注意事项要记住:
- 更多的树=更多的计算。超过某一点，权衡可能就不值得了。
- 与此相关，增加
n_estimators会导致收益减少，如图 5 所示。例如，从 370 棵树增加到 400 棵树，甚至不能保证减少验证 MSE。 - 没有任何不相关的树能够消除由模型假设或不具代表性的训练数据产生的偏差所导致的错误。
最大深度
max_depth是您希望每棵树分裂的深度。例如，max_depth = 50将限制树在任何给定的分支上最多分裂 50 次。其结果是，我们的随机森林不再能如此接近地拟合训练数据，因此更加稳定。它具有较低的方差，使我们的模型误差更小。请记住，即使严格限制max_depth可能会增加每棵树的偏差，因为它们可能无法在达到极限之前捕获数据中的某些模式，我们也不必担心这一点。选择合适的n_estimators，再加上装袋，可以确保整个森林的偏差在这个过程中不会增加。
max_depth是一个超参数，我通常不去碰它，因为我真正关心的是在禁止树进一步分裂之前，在一个分支的末端有多少观察值。这是对随机森林过度适应程度的更好预测。
最小样本叶
允许我们做我上面描述的事情。例如，min_samples_leaf = 10告诉每棵树停止分裂，如果这样做会导致任何结果分支的结束节点少于 10 个叶子。为了更好地理解为什么这是有用的，想一想决策树是如何做出预测的，我在出租车费用预测问题的背景下再次概述了这一点。一旦完成训练，它通过在树中传递出租车的特征并在树空间中找到距离该出租车最近的末端节点来预测出租车的费用。
如果这是叶节点，这将是如果min_samples_leaf = 1(缺省值)的情况，则森林正在预测该游乐设施碰巧最接近的训练集中的特定游乐设施的实际费用。几乎可以肯定的是，分支末端的分裂并没有捕捉到纽约市出租车费用的实际模式，而只是训练数据中与更高或更低费用相对应的情况。传入一些更大的min_samples_leaf意味着我们现在预测一些样本组的平均值，这些样本组在树空间中与所讨论的游乐设备最接近。这种技术的推广性明显更好。
我通常会尝试min_samples_leaf = [1, 3, 5, 10, 20, 50]，一旦增加min_samples_leaf并不能提高我感兴趣的指标，我就会停止。
最大 _ 功能
max_features告诉每棵树在寻找最佳分割时要检查多少个特征。这里的一个微妙之处是，传入max_features = 15并不意味着每棵树选择 15 个特征的子集来建模。更确切地说，一棵树为每次分裂选择了 15 个不同的随机样本。像min_samples_leaf一样，这不允许树过于接近数据。更重要的是，随机森林中的树现在彼此之间的相关性甚至更低，因为它们甚至没有在相同的数据上进行训练。有一些实用的机器学习研究表明，不太准确、不太相关的树的森林比更准确、更相关的树的森林表现更好。
实际例子
机器学习中超参数调整的一种常见方法是使用在scikit-learn中实现的一种叫做RandomizedSearchCV的技术。这将模型本身和我们感兴趣的参数空间作为必需的参数。
*class* sklearn.model_selection.**RandomizedSearchCV**(*estimator*, *param_distributions*, *n_iter=10*, *scoring=None*, *fit_params=None*, *n_jobs=1*, *iid=True*, *refit=True*, *cv=None*, *verbose=0*, *pre_dispatch=‘2*n_jobs’*, *random_state=None*, *error_score=’raise’*, *return_train_score=’warn’*)
它随机尝试这些参数的n_iter组合，并返回这些样本的最佳超参数和相应的分数。然而，为了说明改变单个参数的效果，我在这里展示了我的RandomForestRegressor对于一些手动选择的组合的表现。首先，让我们看看一个没有其他参数传入的随机森林有多好:
[4.262844864358172, 4.098490006842908, 0.8090730776697076, 0.8239641822866088]
n_jobs = -1只是告诉scikit-learn使用计算机上所有可用的内核。此外，print_score()是 fast.ai 库中的一个函数，它返回训练误差、验证误差、训练 R 和验证 R。我们的基线是大约 0.824 的验证 R。玩max_features的作用如下:
[4.289944262409593, 3.9900355584905385, 0.8066378726809564, 0.8331574522424692]
[4.322218978148121, 4.136388496420818, 0.8037174696184352, 0.820693545036434]
虽然使用max_features = 'log2'乘以特征的数量在一定程度上提高了性能，但是max_features = 'sqrt'却做了相反的事情。最有效的方法可能因情况而异，这使得某种形式的试错法成为最简单和最受欢迎的选择。您可以自己随意使用一些其他的超参数。为了简洁起见，我不会在这里这样做。最后，在选择了我的超参数之后，我使用大量的估计器训练了一个RandomForestRegressor,以进一步提高 R:
[4.013807675575337, 3.8493455368979235, 0.830729516598271, 0.8447158691316341]
结论
总之，随机森林采用了许多技术来减少预测中的方差，同时保持(在某种程度上)单独决策树的低方差特征。这主要是通过将一些非常弱相关(如果不是完全不相关)的树平均在一起来实现的。像max_features和min_samples_leaf这样的超参数是减少树之间这种相关性的有用技术之一，但它们通常以增加偏差为代价，因为每棵树现在处理的数据更少了。
因此，我们的目标是选择一组超参数，在偏差和方差之间进行权衡，以便在一些新的数据集(验证集)上最小化误差(或最大化拟合优度)，我们认为这些数据集代表了模型在解决其设计的真实世界问题(测试集)时可能遇到的情况。
神经网络的随机初始化:过去的事情
最近，神经网络已经成为我们几乎所有机器学习相关问题的到解决方案。这仅仅是因为神经网络有能力合成复杂的非线性，这种非线性几乎总是能神奇地给出以前不可能的精度。
在业内，神经网络被视为黑匣子。这是因为当我们从一个密集层移动到下一个密集层时，它们使用给定数据的特征来公式化越来越复杂的特征。研究人员试图研究这些复杂的特征生成过程，但迄今为止还没有太大的进展。神经网络仍然是黑匣子。
这一点正是让深学、深的原因。
courtesy: Machine Learning Memes for Convolutional Teens,facebook
一些研究人员也反对在自动驾驶汽车和无人机等非常重要的领域使用神经网络。他们说，与支持向量机或随机森林的决策框架相比，深度神经网络做出的决策是不合理的。如果明天出现任何问题，比如说，如果一辆自动驾驶汽车在去杂货店的路上跳下悬崖，如果是支持向量机在控制汽车的行为，那么问题背后的原因可以很容易地纠正和纠正，另一方面，由于神经网络的框架非常复杂，没有人能够预测汽车为什么跳下悬崖，为什么它会做出这个决定。
但总的来说，今天没有其他方法可以像神经网络一样准确地学习数据。神经网络是图像识别成为今天这个样子的原因。如今，复杂的卷积网络正在被制造出来，它们在识别物体方面变得越来越精确，甚至可以在这项任务中与人类竞争。
在神经网络中，每两层之间存在权重。这些权重和先前层中的值的线性变换通过非线性激活函数来产生下一层的值。这个过程在前向传播期间逐层发生，通过反向传播，可以找出这些权重的最佳值，以便在给定输入的情况下产生精确的输出。
到目前为止，机器学习工程师一直使用随机初始化的权重作为这个过程的起点。直到现在(即:2015 年)，还不知道这些权重的初始值在寻找深度神经网络成本函数的全局最小值中起到如此重要的作用
我目前正在吴恩达的 coursera 上做深度学习专业化，专业化的第二个课程涉及这些深度神经网络的超参数调整。
在我们开始前向、后向传播以找到最佳权重之前，让我们看看初始化层之间的权重的三种方式。
1:零初始化
2:随机初始化
3: he-et-al 初始化
零初始化
零初始化没有任何意义。神经网络不执行对称破坏。如果我们将所有的权重都设置为零，那么所有层的所有神经元都执行相同的计算，给出相同的输出，从而使整个深度网络变得无用。如果权重为零，整个深度网络的复杂性将与单个神经元的复杂性相同，并且预测将不会比随机更好。
w=np.zeros((层大小[l]，层大小[l-1])
courtesy: Machine Learning Memes for Convolutional Teens,facebook
随机初始化
这有助于对称性破缺的过程，并给出更好的精度。在这种方法中，权重被初始化为非常接近零，但是随机的。这有助于打破对称性，每个神经元不再执行相同的计算。
w = NP . random . randn(layer _ size[l]，layer_size[l-1])*0.01
courtesy: Machine Learning Memes for Convolutional Teens,facebook
He-et-al 初始化
这种初始化的方法通过何等人 2015 年提交的一篇论文而出名，类似于 Xavier 初始化，因子乘以 2。在这种方法中，记住前一层的大小来初始化权重，这有助于更快更有效地获得成本函数的全局最小值。权重仍然是随机的，但是范围根据前一层神经元的大小而不同。这提供了受控的初始化，因此更快和更有效的梯度下降。
w=np.random.randn(层大小[l]，层大小[l-1])* NP . sqrt(2/层大小[l-1])
[## 芝加哥大学深度网络深度学习的初始化
提供芝加哥式的深度学习。来自芝加哥大学的深度学习博客。
deepdish.io](http://deepdish.io/2015/02/24/network-initialization/)
阅读这篇文章以获得更多关于这个主题的信息。
通过在相同的数据上尝试所有三种初始化技术，我观察到以下情况:
零初始化:
15000 次迭代后的成本:0.7
精确度:0.5
随机初始化:
15000 次迭代后的成本:0.38
精确度:0.83
何等人初始化:
15000 次迭代后的成本:0.07
精确度:0.96
这本身显示了权重的初始化如何影响神经网络的性能。
看看 facebook 上的这个 rad 页面。
卷积青少年的机器学习迷因。20K 赞。在它变深之前，我就已经在做了
www.facebook.com](https://www.facebook.com/convolutionalmemes/)
一如既往，快乐学习。
用符号表示的随机回归和分类问题生成
我们描述了如何使用 SymPy，我们可以为多项式(和非线性)回归和分类问题建立随机样本生成器。这补充了 Scikit-learn 的随机数据生成方法。
介绍
对于数据科学和机器学习的初学者来说，一个常见的问题是获得良好、干净的数据集以便快速练习。回归和分类是数据科学从业者必须处理的两个最常见的监督机器学习任务。并不总是有可能得到结构良好的数据集来练习人们学习的各种算法。
如果能有一个方便的函数来快速生成大小、复杂性和随机性可控的回归和分类问题的合成示例，那就太好了。
现在， Scikit-Learn，Python 中领先的机器学习库，确实为回归和分类问题提供了随机数据集生成能力。然而，用户无法轻松控制数据生成的底层机制，回归输出也不是输入的决定性函数——它们确实是随机的。虽然这对于许多问题来说可能已经足够了，但是人们可能经常需要一种可控的方式来基于明确定义的函数(涉及线性、非线性、理性甚至超越项)产生这些问题。
在本文中，我们将使用 SymPy(Python 生态系统中的一个伟大的符号计算包)来完成示例代码。你可以 在这里 从我的 GitHub 库下载 Jupyter 笔记本，并根据你的需要进一步修改功能。
Scikit-Learn 的数据集生成功能和局限性
Scikit-learn 为生成随机回归和分类问题提供了两个实用函数。它们列在[sklearn.dataset](http://scikit-learn.org/stable/modules/classes.html#module-sklearn.datasets) API 下。它们如下:
**sklearn.dataset.make_regression**:生成随机回归问题。通过将具有确定数量的非零回归量的 随机线性回归模型 应用于先前生成的输入和具有一些可调标度的一些高斯中心噪声，来生成输出。
**sklearn.dataset.make_classification**:生成一个随机的 n 类分类问题。这首先创建正态分布在 n 维超立方体的顶点周围的点的聚类，并为每个类分配相等数量的聚类。它引入了这些特征之间的相互依赖，并给数据增加了各种类型的噪声。
这些是非常好的随机问题生成工具，但是它们不允许用户基于一些底层的确定性函数来创建数据。然而，人们可能希望为可控分析/机器学习实验生成数据集。例如，我们想要评估各种内核化 SVM 分类器在具有越来越复杂分隔符(线性到非线性)的数据集上的功效，或者想要证明线性模型对于由有理函数或超越函数生成的回归数据集的局限性。使用 scikit-learn 的这些功能很难做到这一点。此外，用户可能只想输入一个符号表达式作为生成函数(或分类任务的逻辑分隔符)。仅仅使用 scikit-learn 的实用程序很难做到这一点，必须为每个新的实验实例编写自己的函数。
SymPy 来救援！
为了解决符号表达式输入的问题，人们可以很容易地利用令人惊叹的 Python 包 SymPy，它允许理解、呈现和评估符号数学表达式，达到相当高的复杂程度。更多细节可以在他们的网站上找到。这里有几个基本的例子，
使用用户提供的符号表达式的随机回归和分类数据集生成
代码的细节可以在我的 GitHub repo 中找到，但是思路很简单。我们有一个symbolize函数，它将 Python 输入字符串转换成 SymPy 符号对象，还有一个eval_multinomial()函数，它将 SymPy 符号表达式和一个(vals)参数作为列表、字典或元组，并在内部创建一个(symbol,value)对来计算数学表达式。主要的效用函数如下:
**gen_classification_symbolic()**函数基于符号表达式生成分类样本。它计算随机生成(高斯分布)点的符号表达式的输出，并基于符号分配二进制分类。
m :符号表达式。需要 x 1、 x 2 等作为变量和要使用的常规 python 算术符号。
n _ samples:要生成的样本数
n _ features:自变量数。这是从符号表达式中自动推断出来的。因此，在提供符号表达式的情况下，该输入将被忽略。然而，如果没有提供符号表达式，则可以调用默认的简单多项式来生成具有 n_features 的分类样本。
flip_y :随机翻转分类标签的概率。较高的值会引入更多的噪声，并使分类问题更加困难。
返回:返回一个带维度的numpy ndarray(n _ samples， n_features +1)。最后一列是响应向量。
**gen_regression_symbolic()**函数基于符号表达式生成分类样本。它计算随机生成(高斯分布)点的符号表达式的输出。
:象征性表达。需要 x 1、 x 2 等作为变量和要使用的常规 python 算术符号。
n _ samples:要生成的样本数
n _ features:变量数。这是从符号表达式中自动推断出来的。因此，在提供符号表达式的情况下，这将被忽略。然而，如果没有提供符号表达式，则可以调用默认的简单多项式来生成具有 n 个特征的分类样本。
噪声 :要引入的噪声(默认为高斯)的大小(加到输出上)。
noise _ dist:噪声信号的概率分布类型。目前支持:正常，均匀，贝塔，伽马，泊松，拉普拉斯。
返回:返回一个带维度的numpy ndarray(n _ samples， n_features +1)。最后一列是响应向量。
例子
下面是一些代码片段和可视化的结果数据集。
分类样本
回归样本
**
不限于单个符号变量
尽管使用一个或两个示例示出了上述示例，但是函数不受变量数量的限制。事实上，内部方法被编码成自动地从你的符号表达式输入中推断出独立变量的数量，并相应地设置问题。这里有一个例子，用户甚至没有给出 n_features ，但是函数从符号表达式中推断出特征的数量为 3。
总结和未来扩展
基本代码设置为尽可能模拟 scikit-learn 的数据集生成实用程序功能。人们可以通过提供 Pandas 数据帧输出或 CSV 文件输出来轻松扩展它，以便在任何其他编程环境中使用，并将数据保存到本地磁盘。在一定的复杂程度上，也可以为用户提供符号表达式的 LaTeX 公式的字符串表示。当然，我们鼓励读者在 GitHub repo 中发送他们的评论或指明。
如果您有任何问题或想法要分享，请联系作者在tirthajyoti【AT】Gmail . com。此外，您可以查看作者的 GitHub 资源库 中其他有趣的 Python、R 或 MATLAB 代码片段和机器学习资源。如果你像我一样，对机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。
关键词 : #machinelearning，#symbolicmath，#supportvectormachine，#随机化，#回归，#分类
用 Python 模拟随机漫步
用 Numpy 模拟和绘制随机行走
什么是随机漫步？
简单地说，随机行走是以一种“随机”方式对当前状态采取连续步骤的过程。然后，可以将附加条件应用于这个基本描述，以便为您的特定用例创建随机漫步。粒子的布朗运动、股票行情自动收录器的运动、活细胞在基质中的运动只是现实世界中一些更为人所知的随机行走。
这里，我们模拟了从原点开始的一维、二维和三维中的简化随机行走，离散步长以相等的概率选自[-1，0，1]。起点用+表示，终点用o表示。
对于不同的应用，这些条件根据需要而改变，例如，在选定的股票价格、使用显微镜等检测的初始细胞位置开始行走，并且步骤选择通常是随机的，并且取决于来自过去数据、预测假设、被测试的假设等的附加信息。
Random Walks on networks can be used for clustering nodes too (https://en.wikipedia.org/wiki/Internet)
设置你的 Jupyter 笔记本:
%pylab inlinefrom itertools import cycle
from mpl_toolkits.mplot3d import Axes3Dcolors = cycle(‘bgrcmykbgrcmykbgrcmykbgrcmyk’)
一维随机行走:
我们从原点 ( y=0 ) 开始，选择一个步长，以相等的概率移动每一个连续的步长。起点显示为红色，终点显示为黑色。累积和绘制在下图中，该图显示了在 1D 超过 10k 步的物体所遵循的路径。
# Define parameters for the walkdims = 1
step_n = 10000
step_set = [-1, 0, 1]
origin = np.zeros((1,dims))# Simulate steps in 1Dstep_shape = (step_n,dims)
steps = np.random.choice(a=step_set, size=step_shape)
path = np.concatenate([origin, steps]).cumsum(0)
start = path[:1]
stop = path[-1:]# Plot the pathfig = plt.figure(figsize=(8,4),dpi=200)
ax = fig.add_subplot(111)ax.scatter(np.arange(step_n+1), path, c=’blue’,alpha=0.25,s=0.05);
ax.plot(path,c=’blue’,alpha=0.5,lw=0.5,ls=’ — ‘,);
ax.plot(0, start, c=’red’, marker=’+’)
ax.plot(step_n, stop, c=’black’, marker=’o’)plt.title(‘1D Random Walk’)
plt.tight_layout(pad=0)
plt.savefig(‘plots/random_walk_1d.png’,dpi=250);
二维随机行走:
我们从原点 (x=0，y=0) 开始，在每个方向上采取随机步骤，在每个步骤中给我们 9 个可能的移动方向*(∏x，∏y)⋲{-1，0，1}* :
(-1，-1)，(-1，0)，(-1，1)，
(0，-1)，(0，0)，(0，1)，
(1，-1)，(1，0)，(1，1)
10k 步以上的模拟给出了以下路径。在流体表面移动的粒子表现出 2D 随机行走，并显示如下的轨迹。
# Define parameters for the walkdims = 2
step_n = 10000
step_set = [-1, 0, 1]
origin = np.zeros((1,dims))# Simulate steps in 2Dstep_shape = (step_n,dims)
steps = np.random.choice(a=step_set, size=step_shape)
path = np.concatenate([origin, steps]).cumsum(0)
start = path[:1]
stop = path[-1:]# Plot the pathfig = plt.figure(figsize=(8,8),dpi=200)
ax = fig.add_subplot(111)ax.scatter(path[:,0], path[:,1],c=’blue’,alpha=0.25,s=0.05);
ax.plot(path[:,0], path[:,1],c=’blue’,alpha=0.5,lw=0.25,ls=’ — ‘);
ax.plot(start[:,0], start[:,1],c=’red’, marker=’+’)
ax.plot(stop[:,0], stop[:,1],c=’black’, marker=’o’)plt.title(‘2D Random Walk’)
plt.tight_layout(pad=0)
plt.savefig(‘plots/random_walk_2d.png’,dpi=250);
模拟 2D k 次随机漫步:
三维随机行走:
在体积中运动的物体是 3D 空间中随机行走的一个例子。我们从原点 (x=0，y=0，z=0) 开始，从 27 个方向*(∏x，∏y，∆z)⋲ {-1，0，1}* 中随机选择步伐:
# Define parameters for the walkdims = 3
step_n = 1000
step_set = [-1, 0, 1]
origin = np.zeros((1,dims))# Simulate steps in 3Dstep_shape = (step_n,dims)
steps = np.random.choice(a=step_set, size=step_shape)
path = np.concatenate([origin, steps]).cumsum(0)
start = path[:1]
stop = path[-1:]# Plot the pathfig = plt.figure(figsize=(10,10),dpi=200)
ax = fig.add_subplot(111, projection=’3d’)
ax.grid(False)
ax.xaxis.pane.fill = ax.yaxis.pane.fill = ax.zaxis.pane.fill = False
ax.set_xlabel(‘X’)
ax.set_ylabel(‘Y’)
ax.set_zlabel(‘Z’)ax.scatter3D(path[:,0], path[:,1], path[:,2],
c=’blue’, alpha=0.25,s=1)
ax.plot3D(path[:,0], path[:,1], path[:,2],
c=’blue’, alpha=0.5, lw=0.5)
ax.plot3D(start[:,0], start[:,1], start[:,2],
c=’red’, marker=’+’)
ax.plot3D(stop[:,0], stop[:,1], stop[:,2],
c=’black’, marker=’o’)
plt.title(‘3D Random Walk’)
plt.savefig(‘plots/random_walk_3d.png’,dpi=250);
3D 模拟 k 次随机行走:
现在我们在 3D 中模拟多个随机行走。每一次随机行走代表一个点源的运动，该点源与从 (x，y，z) ⋲ [-10，10] 中选择的点同时开始。
一些细胞/粒子在没有任何持续方向力的情况下移动，会显示出这样的轨迹。三维随机漫步的一个有趣的方面是，即使起点很近，随着时间的推移，物体会散开。
Simulating multiple random walks in the same 3D space
# Define parameters for the walkdims = 3
n_runs = 10
step_n = 1000
step_set = [-1, 0 ,1]
runs = np.arange(n_runs)
step_shape = (step_n,dims)# Plotfig = plt.figure(figsize=(10,10),dpi=250)
ax = fig.add_subplot(111, projection=’3d’)
ax.grid(False)
ax.xaxis.pane.fill = ax.yaxis.pane.fill = ax.zaxis.pane.fill = False
ax.set_xlabel(‘X’)
ax.set_ylabel(‘Y’)
ax.set_zlabel(‘Z’)
for i, col in zip(runs, colors): # Simulate steps in 3D origin = np.random.randint(low=-10,high=10,size=(1,dims))
steps = np.random.choice(a=step_set, size=step_shape)
path = np.concatenate([origin, steps]).cumsum(0)
start = path[:1]
stop = path[-1:] # Plot the path ax.scatter3D(path[:,0], path[:,1], path[:,2],
c=col,alpha=0.15,s=1);
ax.plot3D(path[:,0], path[:,1], path[:,2],
c=col, alpha=0.25,lw=0.25)
ax.plot3D(start[:,0], start[:,1], start[:,2],
c=col, marker=’+’)
ax.plot3D(stop[:,0], stop[:,1], stop[:,2],
c=col, marker=’o’);
plt.title(‘3D Random Walk - Multiple runs’)
plt.savefig(‘plots/random_walk_3d_multiple_runs.png’,dpi=250);
在这篇文章中，我们讨论了如何在 1D、2D 和 3D 中模拟一次基本的随机漫步。我们可以使用不同的方法对群体表现出的随机游走进行描述性分析*(距离、位移、速度、速率、角度分布、指示器计数、限制比等)*。我们还可以模拟和讨论有向/有偏随机行走，其中下一步的方向取决于当前位置，这是由于某种形式的现有梯度或定向力。
Python 中的新闻倾向性排名
我最近在《华盛顿邮报》上读到一篇文章，标题是“根据受众对媒体进行从自由到保守的排序”。启发我根据新闻网站在特定主题上的主观性和极性对其进行排名，在这个例子中，是唐纳德·特朗普。
我用 Python 调出了以下新闻网站中包含关键词“特朗普”的 30 篇最新文章(从《华盛顿邮报》文章的自由派到保守派):
- 纽约市人
- 噪声功率比(noise power ratio)
- 美国有线新闻网；卷积神经网络
- 福克斯新闻频道
- 德鲁吉报告
- 布莱巴特
然后对文章的描述进行文本分析，以返回一个列表，其中列出了文章的主观程度(或固执己见)以及极性(作者对特朗普的感觉是积极还是消极)。通过这样做，我可以得出一个新闻网站的(非常基本的)排名，显示他们对我们的总统有多么偏见，以及他们对他的看法如何。有了这个，我就可以和《华盛顿邮报》的文章进行比较，看新闻来源与哪个政治派别联系最紧密，哪个最有偏见。
进口
为了搜索 google，我使用了这个库、 TextBlob 进行文本分析，使用 TextTable 在终端中显示结果。
from google import google
from textblob import TextBlob
import texttable as tt
from time import sleep
搜索
为了获得和分析来自不同网站的文章，我使用了 Google Dork searches ，它允许你搜索特定网站的关键词(以及其他许多东西)。例如，您可以键入
inurl:medium.com intext:python
以便只从提到 python 的中型网站返回搜索结果。
我创建了一个名为search的函数，它接受您正在搜索的站点的参数和要搜索的关键字。然后将变量search_results设置为使用站点和关键字参数的 Google Dork 搜索，我们就可以收集文章了。
然后，我创建了一个search_results_list、subjectivity_list和一个polarity_list，以便稍后追加结果。创建num列表只是让文章按照它们在文本表格中出现的顺序编号。
def search(site, search):
site = site
search = search
num_page = 3
search_results = google.search(“inurl:” + site + “ intext:” + search, 3)
search_results_list = []
subjectivity_list = []
polarity_list = []
num = []
number = 1
情感分析
下一步是确定给定文章的主观性和极性。这可以通过在搜索结果上调用result.description方法来完成，然后将其附加到search_results_list.
通过设置 TextBlob，将search_results作为变量analysis，可以对文章进行基本的情感分析。运行analysis.sentiment.subjectivity获得结果的主观性，运行analysis.sentiment.polarity返回极性。将这些结果附加到各自的列表中。
for result in search_results:
search_results = result.description
search_results_list.append(search_results) analysis = TextBlob(search_results)
subjectivity = analysis.sentiment.subjectivity
subjectivity_list.append(subjectivity)
polarity = analysis.sentiment.polarity
polarity_list.append(polarity)
number = number + 1
num.append(number)
sleep(5)
文本表格
为了创建表格，创建一个新变量tab，并将其设置为等于tt.Texttable()。然后写出你的标题，我用了数字、结果、主观性和极性。
tab = tt.Texttable()
headings = [‘Number’,’Results’,’Subjectivity’, ‘Polarity’]
tab.header(headings)
然后运行一个for循环，将列表中的每个元素作为一行添加到表中。
for row in zip(num, search_results_list, subjectivity_list, polarity_list):
tab.add_row(row)
采用主观性和极性列表，我们可以找到每个新闻源的平均值，然后我们可以将它与给定的网站、搜索结果和表格一起打印出来。
avg_subjectivity = (sum(subjectivity_list) / len(subjectivity_list))
avg_polarity = (sum(polarity_list) / len(polarity_list))table = tab.draw()
print site
print search
print table
print (site + “ average subjectivity: “ + str(avg_subjectivity))
print (site + “ average polarity: “ + str(avg_polarity))
调用函数
最后，您必须为每个新闻站点调用search函数。
search(“newyorker”, “trump”)
search(“npr”, “trump”)
search(“cnn”, “trump”)
search(“foxnews”, “trump”)
search(“drudgereport”, “trump”)
search(“breitbart”, “trump”)
就是这样！
结果
运行该脚本，终端输出将如下所示:
显示站点、文章数量、文章描述、每篇文章的主观性和极性，然后显示站点的平均值。
网站各自主观评价的平均值如下(从最客观到最主观的顺序):
- NPR (0.21)
- 福克斯新闻频道(0.23)
- CNN (0.25)
- 《纽约客》( 0.27)
- 布莱巴特(0.34)
- 德拉吉报告(0.36)
毫不奇怪，NPR 是最客观的新闻来源，而《德拉吉报道》和布莱巴特在特朗普问题上最固执己见。然而，福克斯新闻频道在客观性上排名第二的事实让我很惊讶。
极性的排名同样令人惊讶，数值越接近-1 越负，越接近 1 越正。
- 福克斯新闻频道(0.04)
- NPR (0.05)
- CNN (0.07)
- 《纽约客》( 0.07)
- 德拉吉报告(0.11)
- 布莱巴特(0.12)
福克斯新闻频道再一次让我吃惊，在 30 篇文章中，他对川普的负面看法最多。在那之后，新闻来源如预期的那样一致。非常有趣的是，最高的正平均值仅仅在零以上！我预计德拉吉报告和布莱巴特至少在 0.6 的范围内。
布莱巴特在一篇文章上记录了 0.8 的最积极情绪，然而，它也有 0.4 的最消极情绪。这让我相信布莱巴特的文章比它的同行使用了更多的内涵语言。布莱巴特在主观性方面排名第二的事实支持了这一点。
最后的想法
显然，这是一个非常基本的排名，不应该被视为真理，因为一个非常小和有限的(仅使用描述，而不是全文)数据集。
我看到了邮报的文章，并认为这将是一个有趣的实验，运行并查看结果。希望你喜欢！
这里是 Github 上的完整源代码
查看我的其他 Python 文章:
[## 使用 Tweepy 在 Python 中创建一个 Twitter 机器人
Twitter 大约有 15%是由机器人组成的，我想尝试一下。我谷歌了如何创建一个推特机器人…
medium.freecodecamp.org](https://medium.freecodecamp.org/creating-a-twitter-bot-in-python-with-tweepy-ac524157a607) [## 基于 Python 的 Twitter 基础数据分析
在使用 Tweepy 和 Python 以及这段代码创建了免费的 Wtr bot 之后，我想用一种方式来看看 Twitter 用户是如何…
medium.freecodecamp.org](https://medium.freecodecamp.org/basic-data-analysis-on-twitter-with-python-251c2a85062e)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
