数字图像处理:数字图像介绍
图像类型的基本介绍
让我们讨论一下什么是图像。如果您来自信号处理背景，那么您可能会将图像视为二维信号，即具有二维 f(x，y)的函数，其中 x，y 是空间坐标。从几何学的角度来看，你可以把图像看作二维或三维空间中的一组点。每个(x，y)上的每个点称为图像的振幅或强度。当这个振幅和 x，y 点是离散的，那么我们称之为数字图像。如果值是连续值，那么我们称之为模拟图像。我们可以通过采样和量化将模拟图像转换成数字图像。用计算机处理数字图像的过程称为数字图像处理。
**像素:**在一幅数字图像中，二维函数上的所有坐标及其对应的值都是有限的。每个位置的每个可用值都被视为一个像素。换句话说，像素是图像的最小部分。因此，数字图像可以被认为是二维像素阵列。
**灰度:**每个像素都有一个强度值，称为灰度或灰度值。这些值通常用 8 位整数表示。所以取值范围从 0 到 255。接近 0 的值表示较暗的区域，接近 255 的值表示较亮的区域。
**图像类型:**二值、灰度、彩色
**二进制图像:**二进制图像只有两种可能的灰度值或强度 0 和 255，没有中间值。在许多图像处理任务中，二进制图像被用作指示感兴趣的像素的掩模。下面是二值图像的例子。
Binary Image (only 0 and 255)
**灰度图像:**灰度图像的值范围从 0 到 255，即每个像素位置可以有 0 到 255 之间的任何值。如果你看 20 世纪 50 年代左右的老电影，你看到的是灰度图像(电影只不过是视频，是按适当顺序排列的单个图像的集合)。下面是一个例子
Grayscale image (0–255 range)
**彩色图像:**二值图像和灰度图像都是二维数组，其中在每个位置，都有一个值来表示像素。记住，为了表示一幅彩色图像，我们需要每个像素有不止一个值。但是我们需要多少个值来代表一种颜色呢？通常，每个像素需要 3 个值来表示任何颜色。这来自于任何颜色都可以由红、蓝、绿三种基本颜色组合而成的想法。将红色和绿色混合就可以得到黄色，将红色和蓝色混合就可以得到紫色，等等。，这其实叫 RGB 色彩空间。还有许多其他方法来创建彩色图像，我们将在以后的讨论中讨论。下面是一个彩色图像的例子。
Color Image (3-dim array with 3 values at every pixel location)
**视频:**视频就是一组按适当顺序排列的图像。
本帖到此为止，谢谢大家！
订阅 FOCUS——我的每周简讯，获取人工智能的最新更新和最新进展，以及来自机器学习媒体的精选故事。
用 Java 8 对库美尔笔迹分类实验介绍 kNN 算法
机器学习是当前的热门领域，到处都在讨论。上面有很多使用一些函数式或者统计编程语言的实现，比如 Python 或者 R **。**然而 Java ，这种流行的 OOP 编程语言，仍然可以实现几乎所有的机器学习算法。作为一名 Java 开发人员，我想介绍 kNN ( K 近邻 )算法，因为它易于实现，并且不需要大量的数学或统计背景就可以理解。
1.要应用的解决方案
笔迹可以是 kNN 算法解决的问题之一，我将使用 高棉文字字符 作为解决的样本问题。高棉语是柬埔寨人所说的东南亚语言之一。它包含大量的辅音、从属或独立元音以及数字。下图是数字脚本，我们将编写一些代码来确定它是否看起来像预期的数字，或者换句话说，对它进行分类。
Khmer numerals : source from Wikipedia
2.数据准备
为了对其进行测试，需要将手写图像转换为包含表示图像上绘制的像素的位(0，1)的文本。每一个机器学习都必须有训练数据集和实验测试数据集。将图像转换成文本的过程将在另一篇文章中提到。
Text represents Khmer handwriting numeral script in bit(0,1)
3.kNN 流程图
为了对我们将要写的东西有一个准确的概念，让我们看看下面的流程图:
kNN flowchart by https://draw.io
4.使用 Java 8 实现 Java 代码
首先需要生成数据加载器类，以便将文本文件加载到内存中。正在使用地图，因为按文件夹分组是首选。
Data loader class
距离计算器用于使用欧几里德公式计算距离:
还需要生成一些类来保存一些数据和值，如下所示:
KnnClassifer 是本演示的主要逻辑。按照上面的流程图，下面是 Java 代码:
最后，我们创建主类，将所有的逻辑组合到一个应用程序中。
如果运行应用类没有任何问题，应该会显示如下图所示的结果。错误率为 0.34 ，时间为 0.572 秒(根据硬件规格不同，在您的电脑上可能会有所不同)。我们可以修改K _ CONSTANT*，NUMBER _ OF _ THREAD或者修改一些 parallelStream 部分到普通 stream 来查看不同时间的分类。*
kNN classification result
5.结论
*kNN 可以使用 Java 进行实验，并通过多线程、并行流和许多其他 Java 8 特性进行优化。kNN 的应用可以在许多领域找到，包括推荐系统、手写和其他分类。 优步预测系统 是现实世界中应用 kNN 算法系统**的一个例子。*然而，它需要大量的计算、成比例的系统以及为训练集做好准备以避免性能问题。本次演示的完整代码和数据集可以在https://github.com/engleangs/knnclassifier中找到。
希望这个基本介绍能对你有用。如果有任何反馈或建议，请告诉我，加油！！。
科特林统计学简介
Kotlin Island outside of Saint Petersburg, Russia (SOURCE: Wikimedia)
使用 Kotlin 的流畅数据科学运算符
在过去的几年里，我一直是 Kotlin 的狂热用户。但是我对 Kotlin 的癖好不仅仅是因为对语言的厌倦或者对 JetBrains 产品(包括 PyCharm，伟大的 Python IDE )的热情。Kotlin 是一个更加实用的 Scala，或者我听到有人这样描述它:“傻瓜的 Scala”。它的独特之处在于，它试图不这样做，专注于实用性和工业，而不是学术实验。它吸收了迄今为止编程语言(包括 Java、Groovy、Scala、C#和 Python)的许多最有用的特性，并将它们集成到一种语言中。
我对 Kotlin 的使用是出于需要，这是我在 2017 年 KotlinConf 演讲中谈到的事情:
你可能会说“Python 是实用的”，当然，我仍然使用 Python，尤其是当我需要某些库的时候。但是，在快速发展的生产应用程序中管理 10，000 行 Python 代码可能会很困难。虽然有些人能够成功地做到这一点，并在 Python 上运行整个公司，但像 Khan Academy 这样的一些公司正在发现 Kotlin 及其静态类型的现代方法的好处。Khan Academy 写了他们从 Python 生态系统转换到 Python/Kotlin 生态系统的经历:
在 Khan Academy，我们使用 Python 2.7 在 Google 的应用引擎标准上运行我们的 web 应用程序。我们非常喜欢 Python
engineering.khanacademy.org](https://engineering.khanacademy.org/posts/kotlin-adoption.htm)
Khan 还为希望学习 Kotlin 的 Python 开发人员写了一个文档:
[## 面向 Python 开发者的 Kotlin
对 Kotlin 的全面介绍，面向具有 Python 或其他动态语言背景的开发人员。
khan.github.io](https://khan.github.io/kotlin-for-python-developers/) 
但是我跑题了。在这篇文章中我想介绍的是一个我已经工作了一段时间的库，叫做 Kotlin-Statistics 。它最初是一个实验，用函数式和面向对象的编程来表达有意义的统计和数据分析，同时使代码清晰直观。换句话说，我想证明在不求助于数据框架和其他数据科学结构的情况下分析 OOP/功能数据是可能的。
科特林惯用的统计运算符。为托马斯尼尔德/科特林统计发展作出贡献
github.com](https://github.com/thomasnield/kotlin-statistics)
以下面这段 Kotlin 代码为例，我声明了一个Patient类型，并包含了名字、姓氏、生日和白细胞计数。我还有一个名为Gender的enum来反映男性/女性类别。当然，我可以从文本文件、数据库或其他来源导入这些数据，但是现在我打算用 Kotlin 代码来声明它们:
**import** java.time.LocalDate
**data class** Patient(**val firstName**: String,
**val lastName**: String,
**val gender**: Gender,
**val birthday**: LocalDate,
**val whiteBloodCellCount**: Int) {
**val age get**() =
ChronoUnit.**YEARS**.between(**birthday**, LocalDate.now())
}**val** *patients* = *listOf*(
Patient(
**"John"**,
**"Simone"**,
Gender.**MALE**,
LocalDate.of(1989, 1, 7),
4500
),
Patient(
**"Sarah"**,
**"Marley"**,
Gender.**FEMALE**,
LocalDate.of(1970, 2, 5),
6700
),
Patient(
**"Jessica"**,
**"Arnold"**,
Gender.**FEMALE**,
LocalDate.of(1980, 3, 9),
3400
),
Patient(
**"Sam"**,
**"Beasley"**,
Gender.**MALE**,
LocalDate.of(1981, 4, 17),
8800
),
Patient(
**"Dan"**,
**"Forney"**,
Gender.**MALE**,
LocalDate.of(1985, 9, 13),
5400
),
Patient(
**"Lauren"**,
**"Michaels"**,
Gender.**FEMALE**,
LocalDate.of(1975, 8, 21),
5000
),
Patient(
**"Michael"**,
**"Erlich"**,
Gender.**MALE**,
LocalDate.of(1985, 12, 17),
4100
),
Patient(
**"Jason"**,
**"Miles"**,
Gender.**MALE**,
LocalDate.of(1991, 11, 1),
3900
),
Patient(
**"Rebekah"**,
**"Earley"**,
Gender.**FEMALE**,
LocalDate.of(1985, 2, 18),
4600
),
Patient(
**"James"**,
**"Larson"**,
Gender.**MALE**,
LocalDate.of(1974, 4, 10),
5100
),
Patient(
**"Dan"**,
**"Ulrech"**,
Gender.**MALE**,
LocalDate.of(1991, 7, 11),
6000
),
Patient(
**"Heather"**,
**"Eisner"**,
Gender.**FEMALE**,
LocalDate.of(1994, 3, 6),
6000
),
Patient(
**"Jasper"**,
**"Martin"**,
Gender.**MALE**,
LocalDate.of(1971, 7, 1),
6000
)
)
**enum class** Gender {
**MALE**,
**FEMALE** }
先说一些基本的分析:所有患者的whiteBloodCellCount的平均值和标准差是多少？我们可以利用 Kotlin 统计数据中的一些扩展函数来快速找到这一点:
**fun** main() {
**val** averageWbcc =
*patients*.*map* **{ it**.**whiteBloodCellCount }**.*average*()
**val** standardDevWbcc = *patients*.*map* **{ it**.**whiteBloodCellCount }** .*standardDeviation*()
*println*(**"Average WBCC: $**averageWbcc**,
Std Dev WBCC: $**standardDevWbcc**"**)
*// PRINTS:
// Average WBCC: 5346.153846153846,
Std Dev WBCC: 1412.2177503341948* }
我们还可以从一组项目中创建一个DescriptiveStatistics对象:
**fun** main() {
**val** descriptives = *patients* .*map* **{ it**.**whiteBloodCellCount }** .*descriptiveStatistics
println*(**"Average: ${**descriptives.**mean}
STD DEV: ${**descriptives.**standardDeviation}"**)
*/* PRINTS
Average: 5346.153846153846 STD DEV: 1412.2177503341948
*/* }
然而，我们有时需要对数据进行切片，不仅是为了更详细的了解，也是为了判断我们的样本。例如，我们是否获得了男性和女性患者的代表性样本？我们可以使用 Kotlin Statistics 中的countBy()操作符，通过一个keySelector来计数一个Collection或Sequence项目，如下所示:
**fun** main() {
**val** genderCounts = *patients*.*countBy* **{ it**.**gender }** *println*(genderCounts)
*// PRINTS
// {MALE=8, FEMALE=5}* }
这将返回一个Map<Gender,Int>，反映打印时显示{MALE=8, FEMALE=5} 的按性别分类的患者计数。
好吧，我们的样本有点男性化，但让我们继续。我们还可以使用averageBy()通过gender找到平均白细胞数。这不仅接受一个keySelector lambda，还接受一个intSelector来从每个Patient中选择一个整数(我们也可以使用doubleSelector、bigDecimalSelector等)。在这种情况下，我们从每个Patient中选择whiteBloodCellCount并通过Gender进行平均，如下所示。有两种方法可以做到这一点:
方法 1:
**fun** main() {
**val** averageWbccByGender = *patients* .*groupBy* **{ it**.**gender }** .*averageByInt* **{ it**.**whiteBloodCellCount }** *println*(averageWbccByGender)
*// PRINTS
// {MALE=5475.0, FEMALE=5140.0}* }
方法二:
**fun** main() {
**val** averageWbccByGender = *patients*.*averageBy*(
keySelector = **{ it**.**gender }**,
intSelector = **{ it**.**whiteBloodCellCount }** )
*println*(averageWbccByGender)
*// PRINTS
// {MALE=5475.0, FEMALE=5140.0}* }
所以男性的平均 WBCC 是 5475，女性是 5140。
年龄呢？我们对年轻和年长的患者进行了很好的取样吗？如果你看看我们的Patient类，我们只有一个birthday可以使用，那就是 Java 8 LocalDate。但是使用 Java 8 的日期和时间工具，我们可以像这样导出keySelector中的年龄:
**fun** main() {
**val** patientCountByAge = *patients*.*countBy*(
keySelector = **{ it.age }** )
patientCountByAge.forEach **{** age, count **->** *println*(**"AGE: $**age **COUNT: $**count**"**)
**}** */* PRINTS:
AGE: 30 COUNT: 1
AGE: 48 COUNT: 1
AGE: 38 COUNT: 1
AGE: 37 COUNT: 1
AGE: 33 COUNT: 3
AGE: 43 COUNT: 1
AGE: 27 COUNT: 2
AGE: 44 COUNT: 1
AGE: 24 COUNT: 1
AGE: 47 COUNT: 1
*/* }
如果您查看我们的代码输出，按年龄计数并没有太大的意义。如果我们能够按照年龄范围来计算，比如 20-29 岁、30-39 岁和 40-49 岁，那就更好了。我们可以使用binByXXX()操作符来做到这一点。如果我们想要通过一个Int值(比如年龄)来进行分类，我们可以定义一个从 20 开始的BinModel，并且将每个binSize递增 10。我们还使用valueSelector提供了我们是宁滨的值，即患者的年龄，如下所示:
**fun** main() {
**val** binnedPatients = *patients*.*binByInt*(
valueSelector = **{ it.age }**,
binSize = 10,
rangeStart = 20
)
binnedPatients.*forEach* **{** bin **->** *println*(bin.**range**)
bin.**value**.*forEach* **{** patient **->** *println*(**" $**patient**"**)
**}
}** }/* PRINTS:[20..29]
Patient(firstName=Jason, lastName=Miles, gender=MALE...
Patient(firstName=Dan, lastName=Ulrech, gender=MALE...
Patient(firstName=Heather, lastName=Eisner, gender=FEMALE...
[30..39]
Patient(firstName=John, lastName=Simone, gender=MALE...
Patient(firstName=Jessica, lastName=Arnold, gender=FEMALE...
Patient(firstName=Sam, lastName=Beasley, gender=MALE...
Patient(firstName=Dan, lastName=Forney, gender=MALE...
Patient(firstName=Michael, lastName=Erlich, gender=MALE...
Patient(firstName=Rebekah, lastName=Earley, gender=FEMALE...
[40..49]
Patient(firstName=Sarah, lastName=Marley, gender=FEMALE...
Patient(firstName=Lauren, lastName=Michaels, gender=FEMALE...
Patient(firstName=James, lastName=Larson, gender=MALE...
Patient(firstName=Jasper, lastName=Martin, gender=MALE...*/
我们可以使用 getter 语法查找给定年龄的 bin。例如，我们可以像这样检索年龄为 25 的Bin，它将返回 20-29 的 bin:
**fun** main() {
**val** binnedPatients = *patients*.*binByInt*(
valueSelector = **{ it.age }**,
binSize = 10,
rangeStart = 20
)
*println*(binnedPatients[25])
}
如果我们不想将项目收集到 bin 中，而是对每个项目执行聚合，我们也可以通过提供一个groupOp参数来实现。这允许您使用 lambda 来指定如何为每个Bin减少每个List<Patient>。以下是按年龄范围划分的平均白细胞数:
**val** avgWbccByAgeRange = *patients*.*binByInt*(
valueSelector = **{ it.age }**,
binSize = 10,
rangeStart = 20,
groupOp = **{ it**.*map* **{ it**.**whiteBloodCellCount }**.*average*() **}** )
*println*(avgWbccByAgeRange)/* PRINTS:
BinModel(bins=[Bin(range=[20..29], value=5300.0),
Bin(range=[30..39], value=5133.333333333333),
Bin(range=[40..49], value=5700.0)]
)
*/
有时，您可能希望执行多个聚合来创建各种指标的报告。这通常可以使用 Kotlin 的 let()操作符来实现。假设您想按性别找出第 1、25、50、75 和 100 个百分点。我们可以有策略地使用一个名为wbccPercentileByGender()的 Kotlin 扩展函数，它将选取一组患者，并按性别进行百分位数计算。然后我们可以为五个期望的百分点调用它，并将它们打包在一个Map<Double,Map<Gender,Double>>中，如下所示:
**fun** main() {
**fun** Collection<Patient>.wbccPercentileByGender(
percentile: Double) =
*percentileBy*(
percentile = percentile,
keySelector = **{ it**.**gender }**,
valueSelector = **{
it**.**whiteBloodCellCount**.toDouble()
**}** )
**val** percentileQuadrantsByGender = *patients*.*let* **{** *mapOf*(1.0 *to* **it**.*wbccPercentileByGender*(1.0),
25.0 *to* **it**.*wbccPercentileByGender*(25.0),
50.0 *to* **it**.*wbccPercentileByGender*(50.0),
75.0 *to* **it**.*wbccPercentileByGender*(75.0),
100.0 *to* **it**.*wbccPercentileByGender*(100.0)
)
**}** percentileQuadrantsByGender.*forEach*(::println)
}/* PRINTS:
1.0={MALE=3900.0, FEMALE=3400.0}
25.0={MALE=4200.0, FEMALE=4000.0}
50.0={MALE=5250.0, FEMALE=5000.0}
75.0={MALE=6000.0, FEMALE=6350.0}
100.0={MALE=8800.0, FEMALE=6700.0}
*/
这是对科特林统计学的简单介绍。请务必阅读该项目的自述文件以查看库中更全面的可用操作符集合(它也有一些不同的工具，如朴素贝叶斯分类器和随机操作符)。
我希望这能证明 Kotlin 在战术上的有效性，但也很强大。Kotlin 能够快速周转以进行快速的特别分析，但是您可以使用静态类型的代码，并通过许多编译时检查对其进行改进。虽然您可能认为 Kotlin 没有 Python 或 R 所拥有的生态系统，但它实际上在 JVM 上已经有了很多库和功能。随着 Kotlin/Native 获得牵引力，看看什么样的数字库会从 Kotlin 生态系统中崛起将会很有趣。
为了获得一些关于将 Kotlin 用于数据科学目的的资源，我在这里整理了一个列表:
管理图书馆、媒体、链接和其他资源，将 Kotlin 用于数据科学…
github.com](https://github.com/thomasnield/kotlin-data-science-resources/blob/master/README.md)
以下是我为演示 Kotlin 进行数学建模而撰写的一些其他文章:
关于制作模型动画的经验教训
towardsdatascience.com](/animating-the-traveling-salesman-problem-56da20b95b2f) [## 数独和时间表
用树搜索解决调度问题
towardsdatascience.com](/sudokus-and-schedules-60f3de5dfe0d)
语言模型:N 元语法
Photo by Erik Eastman on Unsplash
介绍
统计语言建模的一个步骤
介绍
统计语言模型本质上是一种为单词序列分配概率的模型。在本文中，我们将了解为句子和单词序列分配概率的最简单模型，即 n 元语法
你可以把一个 N-gram 看作是 N 个单词的序列，根据这个概念，一个 2-gram(或二元模型)是两个单词的序列，如“请转”、“转你的”或“你的作业”，而一个 3-gram(或三元模型)是三个单词的序列，如“请转你的”或“转你的作业”
直觉公式
先说方程 P(w|h)，给定一些历史，单词 w 的概率， h 。举个例子，
在这里，水是如此的透明
而且，估算上述概率函数的一种方法是通过相对频率计数法，在这里你会取一个相当大的语料库，统计你看到 的次数，它的水是如此透明以至于 ，然后统计它后面是的次数。换句话说，你在回答这个问题:
在你看到历史 h 的次数中，单词 w 跟随了多少次
现在，你可以想象在整个语料库上执行这个是不可行的；尤其是它的尺寸很大。
这一缺点和使用链式法则分解概率函数的方式充当了 N-gram 模型的基本直觉。在这里，你不是使用整个语料库来计算概率，而是用几个历史单词来近似计算概率
二元模型
顾名思义，二元模型通过仅使用一个前面单词的条件概率来近似给定所有前面单词的单词的概率。换句话说，你用概率来近似它:P(the | that)
因此，当您使用二元模型来预测下一个单词的条件概率时，您会得出以下近似值:
这种一个词的概率只取决于前一个词的假设也被称为马尔可夫假设。
马尔可夫模型是一类概率模型，它假设我们可以预测某个未来单位的概率，而不用考虑太远的过去。
您可以进一步将二元模型推广到三元模型，它查看过去的两个单词，因此可以进一步推广到 N 元模型
概率估计
现在，我们理解了 N 元模型的基础，你会想，我们如何估计概率函数。最直接和直观的方法之一是最大似然估计(MLE)
例如，给定前一个单词 x ，计算单词 y 的特定二元模型概率，您可以确定二元模型 C(xy)的计数，并通过共享相同首词 x 的所有二元模型的总和对其进行归一化。
挑战
当然，每一种建模方法和评估方法都存在挑战。让我们看看影响 N-gram 模型的关键因素，以及 MLE 的使用
对训练语料的敏感度
*与许多统计模型一样，N-gram 模型非常依赖于训练语料库。因此，**，*概率通常编码关于给定训练语料库的特定事实。此外，N 元模型的性能随着 N 值的变化而变化。
此外，你可能有一个语言任务，其中你知道所有可能出现的单词，因此我们提前知道词汇量 V。封闭词汇表假设没有未知单词，这在实际场景中不太可能。
平滑
MLE 方法的一个显著问题是数据稀疏。也就是说，任何出现足够多次的 N-gram 都可能对其概率有一个合理的估计。但是因为任何语料库都是有限的，一些完全可以接受的英语单词序列必然会从其中缺失。
因此，任何训练语料库的 N-gram 矩阵必然具有大量假定的“零概率 N-gram”的情况
来源:
[1]章节草稿— | Stanford Lagunita。https://lag unita . Stanford . edu/c4x/Engineering/CS-224n/asset/sl P4 . pdf
[2]语音和语言处理:自然语言处理、计算语言学和语音导论
感谢阅读。如果您有任何反馈，请对本文发表评论，在LinkedIn上给我发消息，或者给我发电子邮件(shmkapadia[at]gmail.com)
如果你喜欢这篇文章，请访问我的其他文章
* [## Python 中的主题建模:潜在狄利克雷分配(LDA)
如何开始使用 Python 中的 LDA 进行主题建模
towardsdatascience.com](/end-to-end-topic-modeling-in-python-latent-dirichlet-allocation-lda-35ce4ed6b3e0) [## 评估主题模型:潜在狄利克雷分配(LDA)
构建可解释主题模型的分步指南
towardsdatascience.com](/evaluate-topic-model-in-python-latent-dirichlet-allocation-lda-7d57484bb5d0) [## 构建块:文本预处理
本文是关于自然语言处理的后续文章的第二篇。这一系列…的目的
towardsdatascience.com](/building-blocks-text-pre-processing-641cae8ba3bf)*
潜在矩阵分解推荐系统简介
Latent Factors are “Hidden Factors” unseen in the data set. Let’s use their power. Image URL: https://www.3dmgame.com/games/darknet/tu/
在创建推荐系统时，潜在矩阵分解是一种非常强大的方法。自从潜在矩阵分解在网飞推荐竞赛中被证明优于其他推荐方法以来，它就成为了构建推荐系统的基石。这篇文章的目的是给你一些直觉，告诉你什么时候使用潜在矩阵分解进行推荐，同时也给你一些直觉，告诉你为什么它会起作用。如果你想看完整的实现，可以去我的 Kaggle 内核:概率矩阵分解。
开始之前，让我们先回顾一下我们要解决的问题。潜在矩阵分解是一种解决**推荐问题的算法:**给定一组 m 个用户和 n 个项目，以及一组用户对某些项目的评分，尝试为每个用户推荐排名靠前的项目。这个问题有很多味道和交替的偏差，大多数都给问题增加了更多的维度，就像添加标签一样。潜在矩阵分解之所以强大，是因为它从核心问题中产生了非常强大的结果，并且可以成为一个很好的基础。
当使用用户项目评分矩阵，以及阅读关于矩阵分解的文章时，首先要看的是线性代数。直觉是正确的，但它不完全是你所期望的。
稀疏不完全矩阵代数:
传统的线性代数是机器学习的基石，这是因为大多数机器学习应用程序拥有推荐系统所没有的东西:没有 nan(不完整数据条目)的数据集。例如，无论何时构建模型，nan 或缺失数据都会在数据预处理步骤中被删除，因为大多数函数无法处理未填充的值。如果有缺失值，则像主成分分析这样的函数是未定义的。然而，如果你摆脱了 nan，推荐系统就无法工作。那些 nan 的存在是有原因的:不是每个用户都对每个项目进行了评级，期望他们这样做有点荒谬。处理稀疏数据是非常不同的事情——这使得推荐成为一个有趣的问题。
稀疏使事情复杂化。奇异值分解是一种将矩阵分解为奇异值和正交值的分解，如果矩阵中的任何元素未定义，则该分解是未定义的。这意味着我们不能以这样一种方式显式分解矩阵，即我们可以找到哪个对角(或潜在)因子在数据集中具有最大权重。
相反，我们将使用一种叫做**概率矩阵分解的技术来近似矩阵的最佳分解。**这项技术归功于 Simon Funk，他在他的 FunkSVD 算法中使用了这项技术，并在网飞竞赛中取得了巨大成功。更多阅读，请查看西蒙的原帖。
方法:
我先解释算法，再解释直觉。
Image URL: https://www.slideshare.net/RussiaAI/deep-learning-for-audiobased-music-recommendation
我们将首先从高斯分布初始化两个矩阵(或者，随机初始化它们)。第一个将是一个 m x k 矩阵 P 而第二个将是一个 k x n 矩阵 Q 。当这两个矩阵相乘时，它们会产生一个 m x n 矩阵，这正好是我们试图预测的评级矩阵的大小。维度 k 是我们的超参数之一，它代表了我们用来估计评级矩阵的潜在因素的数量。一般来说， k 在 10–250 之间，但不要相信我的话——使用线搜索(或网格搜索)找到适合您应用的最佳值。
Source: katbailey.github.io
对于我们的矩阵 P，Q，，我们将通过使用**随机梯度下降来优化它们的值。**因此，您将有另外两个超参数需要优化，即学习率和时期。对于每个时期，我们将遍历我们原始的 m x n 矩阵中的每个已知评级。
然后，我们将得到一个误差或残差值 e ，通过 P 中的原始评分用户行和 q 中的项目列的点积减去原始评分值。
在正常的随机梯度下降方式中，我们将通过将 P 和 Q 的当前行加上学习率乘以误差乘以另一个矩阵的值的乘积来同时更新矩阵 P 和 Q。
这是 python 语言。在我的 Kaggle 内核中完整查看。
#randomly initialize user/item factors from a Gaussian
P = np.random.normal(0,.1,(train.n_users,self.num_factors))
Q = np.random.normal(0,.1,(train.n_items,self.num_factors))
#print('fit')for epoch in range(self.num_epochs):
for u,i,r_ui in train.all_ratings():
residual = r_ui - np.dot(P[u],Q[i])
temp = P[u,:] # we want to update them at the same time, so we make a temporary variable.
P[u,:] += self.alpha * residual * Q[i]
Q[i,:] += self.alpha * residual * tempself.P = P
self.Q = Qself.trainset = train
现在我们有了算法，为什么它会工作，我们如何解释它的结果？
潜在因素代表数据中存在的类别。对于电影数据集的 k=5 个潜在因素，这些因素可以代表动作、浪漫、科幻、喜剧和恐怖。有了更高的 *k，*你就有了更具体的类别。我们正在尝试预测用户 u 对项目 i. 的评级。因此，我们查看 P 以找到代表用户 *u、*以及他们对所有潜在因素的偏好或“亲和力”的向量。然后，我们查看 Q 以找到一个代表项目 I 的向量，以及它对所有潜在因素的“亲和力”。我们得到这两个向量的点积，这将返回给我们一个用户在潜在因素的上下文中有多喜欢这个项目的感觉。
来源及延伸阅读:
大量的信息和灵感来自于这篇关于概率矩阵分解的文章和Charu Aggarwal 的《推荐系统:教科书》第三章。
你可以在这里找到 python 实现。
线性回归和多项式回归简介
介绍
在这个博客中，我们将讨论两个重要的主题，它们将构成机器学习的基础，即“线性回归”和“多项式回归”。
什么是回归？
回归分析是预测建模技术的一种形式，它研究因变量和自变量之间的关系。
以上定义是一个书生气十足的定义，简单来说回归可以定义为，“利用变量之间的关系来寻找最佳拟合直线或可以用来进行预测的回归方程”。
Regression | Image: Wikipedia
回归有许多类型，如“线性回归”、“多项式回归”、“逻辑回归”等，但在这篇博客中，我们将学习“线性回归”和“多项式回归”。
线性回归
线性回归是一种基本且常用的预测分析类型，通常用于连续数据。我们将基于一个例子来理解线性回归:
Aarav 是一个想买房子的人，他正在收集住房数据，以便根据房子的“居住面积”(以英尺为单位)来估算房子的“成本”。
Housing data | Andrew Ng course
他观察了数据，并在绘制散点图后得出数据是线性的结论。在他的第一个散点图中，Aarav 使用了两个变量:“居住面积”和“价格”。
Scatter plot | Image: Andrew Ng course
他一看到数据中的模式，就计划在图上画一条回归线，这样他就可以用这条线来预测“房子的价格”。
使用训练数据，即“价格”和“居住面积”，得到一条给出最小误差的回归线。要做到这一点，他需要画一条尽可能接近多点的线。这个“线性方程”然后被用于任何新的数据，以便他能够预测所需的输出。
这里，β1 是参数(也称为权重),β0 是 y 轴截距，єi 是随机误差项，其作用是增加偏差。上面的方程是需要以最小的误差得到的线性方程。
上面的方程是一个简单的“*直线的方程”*即
y(预测)= (β1*x + βo) +误差值
其中’ β1 ‘为斜率，’ βo '为 y 轴截距，类似于直线的方程。必须选择值“β1”和“β0 ”,以使误差最小。为了检查误差，我们必须计算误差平方和，并调整参数以尽量减少误差。
误差=σ(实际输出-预测输出)
Cost function
键: 1。 Y(预测) 也叫假设函数*。
2。****J(θ)**是代价函数，也可以称为误差函数。我们的主要目标是使成本最小化。
3。**y(I)是的预测输出。
4。【x(I))*称为假设函数基本上就是 Y(预测)值。
现在问题来了，我们如何减少误差值。嗯，这可以通过使用**梯度下降来实现。梯度下降的主要目标是最小化成本值。**即 min J(θo，θ1T53)
Gradient Descent Visualization | Gif: mi-academy.com
梯度下降有一个类比，我们必须想象自己在一个山谷的山顶，被蒙住眼睛，束手无策，我们的目标是到达山脚。感觉你周围地形的坡度是每个人都会做的。这个动作类似于计算梯度下降，而走一步类似于更新参数的一次迭代。
Gradient Decent Analogy | Image: Andrew Ng course
选择一个完美的 学习速率 是一项非常重要的任务，因为它取决于我们在每次迭代中走下坡路的幅度。如果我们迈得太大，我们可能会跳过最小值。然而，如果我们采取小步骤，将需要多次迭代才能达到最小值。
Linear Regression
多项式线性回归
在上一节中，我们看到数据集中的两个变量是相关的，但如果我们知道我们的数据是相关的，但这种关系看起来不是线性的，会发生什么呢？因此，根据数据的情况，我们可以对数据进行多项式回归，以拟合多项式方程。
Left: Linear Regression, Right: Polynomial regression | GIF: Towards Data Science
因此，如果我们试图在上图中使用一个简单的线性回归，那么线性回归线将不会很好地拟合。很难在上面的图表中拟合出误差值很低的线性回归线。因此，我们可以尝试使用多项式回归来拟合多项式线，以便我们可以实现最小误差或最小成本函数。上述图表数据的多项式回归方程为:
y =θo+θ₁x₁*+θ₂x*₁
这是多项式回归的一般方程是:
y=θo+θ₁x+θ₂x+…+θₘxᵐ+残差
使用多项式回归的优点:
- 多项式提供了因变量和自变量之间关系的最佳近似。
- 在它下面可以安装多种功能。
- 多项式基本上适合大范围的曲率。
使用多项式回归的缺点
- 数据中存在一两个异常值会严重影响非线性分析的结果。
- 这些对异常值过于敏感。
- 此外，不幸的是，用于检测非线性回归中异常值的模型验证工具比用于线性回归的工具少。
结论
在这篇博客中，我已经向你介绍了线性回归和多项式回归的基本概念。
逻辑回归介绍
介绍
在这个博客中，我们将讨论逻辑回归的基本概念以及它能帮助我们解决什么样的问题。
GIF: University of Toronto
逻辑回归是一种分类算法，用于将观察值分配给一组离散的类。分类问题的一些例子是电子邮件垃圾邮件或非垃圾邮件、在线交易欺诈或非欺诈、恶性肿瘤或良性肿瘤。逻辑回归使用逻辑 sigmoid 函数转换其输出，以返回概率值。
逻辑回归有哪些类型
- 二元(如恶性肿瘤或良性肿瘤)
- 多线性函数失败类(如猫、狗或羊的)
逻辑回归
逻辑回归是一种用于分类问题的机器学习算法，它是一种基于概率概念的预测分析算法。
Linear Regression VS Logistic Regression Graph| Image: Data Camp
我们可以将逻辑回归称为线性回归模型，但是逻辑回归使用更复杂的成本函数，该成本函数可以定义为“ Sigmoid 函数，或者也称为“逻辑函数”，而不是线性函数。
逻辑回归的假设倾向于将成本函数限制在 0 和 1 之间。因此，线性函数不能表示它，因为它可以具有大于 1 或小于 0 的值，根据逻辑回归的假设，这是不可能的。
Logistic regression hypothesis expectation
什么是乙状结肠函数？
为了将预测值映射到概率，我们使用 Sigmoid 函数。该函数将任何实数值映射到 0 和 1 之间的另一个值。在机器学习中，我们使用 sigmoid 将预测映射到概率。
Sigmoid Function Graph
Formula of a sigmoid function | Image: Analytics India Magazine
假设表象
使用线性回归时，我们使用假设的公式，即
hθ(x)=β₀+β₁x
对于逻辑回归，我们将对其稍加修改，即
σ(Z) = σ(β₀ + β₁X)
我们预计我们的假设将给出介于 0 和 1 之间的值。
Z = β₀ + β₁X
hθ(x)= sigmoid(Z)
即 hθ(x)= 1/(1+e^-(β₀+β₁x)
The Hypothesis of logistic regression
判别边界
当我们通过一个预测函数传递输入并返回一个介于 0 和 1 之间的概率分数时，我们期望我们的分类器根据概率给出一组输出或类。
例如，我们有 2 个类，让我们像猫和狗一样对待它们(1 —狗，0 —猫)。我们基本上确定一个阈值，高于该阈值的值我们将其分类为第 1 类，低于该阈值的值我们将其分类为第 2 类。
Example
如上图所示，我们选择阈值为 0.5，如果预测函数返回值为 0.7，则我们会将此观察结果分类为 1 类(狗)。如果我们的预测返回值为 0.2，那么我们会将观察结果分类为第 2 类(CAT)。
价值函数
我们在线性回归中学习了成本函数 J ( θ ，成本函数代表优化目标，即我们创建一个成本函数并将其最小化，以便我们可以开发一个误差最小的精确模型。
The Cost function of Linear regression
如果我们试图在“逻辑回归”中使用线性回归的成本函数，那么它将是无用的，因为它最终将是一个具有许多局部最小值的非凸函数，其中很难使最小化成本值并找到全局最小值。
Non-convex function
对于逻辑回归，成本函数定义为:
如果 y = 1，log( hθ ( x ))
如果 y = 0，log(1hθ*(x))*
Cost function of Logistic Regression
**
Graph of logistic regression
上述两个函数可以压缩成一个函数，即
Above functions compressed into one cost function
梯度下降
*现在问题来了，我们如何降低成本价值。嗯，这个可以用**梯度下降来实现。梯度下降的主要目标是最小化成本值。*即 min J( θ )。
现在，为了最小化成本函数，我们需要对每个参数运行梯度下降函数，即
Objective: To minimize the cost function we have to run the gradient descent function on each parameter
Gradient Descent Simplified | Image: Andrew Ng Course
梯度下降有一个类比，我们必须想象自己在一个山谷的山顶，被蒙住眼睛，束手无策，我们的目标是到达山脚。感觉你周围地形的坡度是每个人都会做的。这个动作类似于计算梯度下降，而走一步类似于更新参数的一次迭代。
Gradient Descent analogy
结论
在这篇博客中，我向你介绍了逻辑回归的基本概念。我希望这篇博客对你有所帮助，并能激发你对这个话题的兴趣。
演奏爵士乐时介绍 LSTM 单元
了解长短期记忆(LSTM)单位，并运用它们生成爵士乐使用 Keras
Photo by Chris Bair on Unsplash
长短期记忆(LSTM)单元允许学习很长的序列。它是门控循环单元( GRU )的一个更加通用和健壮的版本，在这篇文章中不会讨论。
在这篇文章中，我们将学习 LSTM 单元是如何工作的，我们将应用它来生成一些爵士音乐。
我们开始吧！
对于机器学习、深度学习和人工智能的实践视频教程，请查看我的 YouTube 频道。
You can call me Al is a great song!
LSTM 的结构
LSTM 的主要特征是有三个门:
- 更新门
- 忘记大门
- 输出门
下面是一个 LSTM 单位的示意图。三个门通过三个符号的出现来显示:
Schema of an LSTM unit
从上图中，注意在 LSTM 单元的顶部有一条从左到右的线。这条线代表早期的信息如何在网络中传递到下一步，这就是为什么 LSTM 单元如此擅长于记忆长序列。因此，这允许模型捕捉更长范围的依赖性。
这看起来好像没有太多关于 LSTM 的知识，但是要理解这只是一个循环神经网络中的一个单元(MAKE LINK)。上面的绿框只是代表一个 RNN 的一个单位。然后，连接多个单元，形成一个完整的网络。
使用 LSTMs 生成 jazz
现在，我们将使用 LSTM 实现一个 RNN 来生成爵士乐！我们将使用 Keras 实现网络，它将生成一个 15 秒的爵士乐剪辑。
一如既往的全笔记本可供咨询。
不幸的是，用于训练的数据太大，无法上传到 Github 上
概观
我们模型的架构将如下所示:
RNN architecture to generate jazz music. Source
基本上，这个模型会被输入一个音乐值，然后它会产生一系列的音乐值来产生音乐。
在这里，“值”代表一个音符、一个持续时间，它还包含是否同时演奏另一个音符的信息(也称为和弦)。
步骤 1:初始模型设置
首先，我们定义网络中隐藏状态的数量。在这种情况下，我们将使用 64。
现在，Keras 有简单的内置函数来构建模型。然而，对于序列生成，不是所有的输入值都是已知的；它们一次生成一个。因此，我们需要添加一个定制的 for 循环，并定义层对象，以便在步骤之间共享权重。
步骤 2:构建模型
现在，我们准备构建模型:
步骤 3:创建、编译、适应
现在，我们可以创建模型，对其进行编译，并使其符合数据:
第四步:创作音乐
现在，我们开始有趣的部分:让我们用我们的模型产生音乐！
在每个采样步骤中，来自前一个 LSTM 单元的激活和单元状态将在下一个单元中传播，并且它们将用于生成另一个输出。
How the output propagates in the network. Source
要生成音乐，我们需要首先对音符进行采样:
有了这些，我们现在可以预测并创造一个音乐序列:
然后用这个代码单元生成音乐:
out_stream = generate_music(inference_model)
你可以找到我生成的音乐文件(。midi 文件)存储在库中。
就是这样！您学习了什么是 LSTM 单元，以及如何用 Keras 应用它来生成音乐。请记住，LSTM 单位只是 RNN 中使用的块。
对于进一步的阅读，我建议你看看 GRU 单元，因为它是一个 LSTM 的简单版本。
干杯！
机器学习的简单介绍
关于 ML 的数据科学入门帖子。
Credit: congerdesign on Pixabay
本帖与一个 视频 有关，名为《机器学习导论》变现为 走向数据科学 。这个视频的剧本是用 安妮·邦纳 写的。视频中你能听到的声音是爱丽丝·伊里扎里的声音。
Introduction to Machine Learning
介绍
我们目前生活在一个“数据时代”，每天都有大量的数据被收集和存储。面对这种不断增长的数据量，机器学习方法已经变得不可避免。以至于你可能一天用几十次，甚至都没有注意到！
让我们从一个对数百万用户的“日常”机器学习贡献的例子开始:脸书新闻订阅背后的算法。脸书使用机器学习来利用用户的数据和反馈来个性化他们的订阅。如果你“喜欢”一个帖子或停止滚动阅读某个内容，该算法会从中学习，并开始用更多类似的内容填充你的提要。这种学习是持续进行的，因此新闻提要中建议的内容会随着您的偏好而发展，从而使您的用户体验更加愉快。
Facebook uses likes, comments and other signals from users to learn what they are interested in and populate their new feeds in consequences.
这只是一个例子！还有很多其他的。苹果可以在你刚拍的照片里认出你朋友的脸。亚马逊 Echo 理解你，可以回答你的问题。你的吸尘器甚至可以在你的房子周围导航，而网飞会推荐符合你个人资料的视频！机器学习已经成为我们日常生活的一个重要部分，而且不会很快消失。
Machine learning can now be found in many tools that we use on a daily basis.
机器学习的定义
但是机器学习到底是什么？这些看起来很神奇的算法背后是什么？他们是如何利用数据工作得如此出色的？
从形式上来说，机器学习是让计算机在没有明确编程的情况下实现一项任务的科学。换句话说，经典算法和机器学习算法之间的巨大差异在于我们定义它们的方式。
经典算法被赋予精确完整的规则来完成任务。机器学习算法被给予定义模型的一般准则，以及数据。这些数据应该包含模型完成任务所需的缺失信息。因此，当模型已经相对于数据进行了调整时，机器学习算法可以完成其任务。我们说**“根据数据拟合模型”或者“必须根据数据训练模型。”**
让我们用一个简单的例子来说明这个问题。假设我们想根据房子的大小、花园的大小和房间的数量来预测房子的价格。
Features we are going to consider in our house pricing example.
我们可以尝试建立一个经典算法来解决这个问题。该算法必须采用三种房屋特征，并根据显式规则返回预测价格。在这个例子中，确切的房价公式必须是已知的，并明确编码。但在实践中，这个公式往往不为人知。
For our house pricing example, a classical programming approach would consists in coding explicitly the formula that gives the price of a house depending on the three features we are considering.
另一方面，我们可以建立一个机器学习算法。首先，这种算法将定义一个模型，该模型可以是根据我们有限的知识创建的不完整的公式。然后，通过对给定的房价实例进行训练来调整模型。为此，我们将模型与一些数据结合起来。
For our house pricing example, a machine learning approach would consists in defining a model that contains a partial knowledge about the house pricing formula and use the available data to “specify” the model (we fit the model on the data).
**总的来说，当我们拥有不完整的信息或太复杂而无法手工编码的信息时，机器学习对于困难的任务非常有用。**在这种情况下，我们可以将现有的信息提供给我们的模型，让这个模型自己“学习”它需要的缺失信息。然后，该算法将使用统计技术直接从数据中提取缺失的知识。
监督和非监督模型
机器学习技术的两个主要类别是监督学习和非监督学习。
在监督学习中，我们希望得到一个模型，根据数据的特征来预测数据的标签。为了学习特征和标签之间的映射，模型必须适合于具有相关标签的特征的给定示例。我们说“模型是在一个有标签的数据集上训练的。”
预测标签可以是数字或类别。例如，我们可以构建一个预测房价的模型，这意味着我们想要预测一个数字标签。在这种情况下，我们将讨论一个回归模型。否则，我们可能还想定义一个模型，根据给定的特征预测一个类别，比如“猫”或“不是猫”。在这种情况下，我们将讨论一个分类模型。
Overview of supervised learning (not exhaustive).
**在无监督学习中，我们希望定义一个模型，揭示一些数据中的结构，这些数据只通过它们的特征来描述，而没有标签。**例如，无监督学习算法可以帮助回答诸如“我的数据中有组吗？”或者“有什么方法可以简化我的数据描述？”。
该模型可以在数据中寻找不同种类的底层结构。如果它试图在数据中找到组，我们将讨论一个聚类模型。聚类模型的一个示例是根据客户的配置文件对公司客户进行细分的模型。否则，如果我们有一个模型来转换数据，并用较少的特征来表示它们，我们会谈到一个降维模型。这方面的一个例子是将一些汽车的多种技术特征总结成几个主要指标的模型。
Overview of unsupervised learning (not exhaustive).
总之，监督学习模型将标签与其特征描述的每个数据点相关联，而非监督学习模型在所有数据点中寻找结构。
从某种意义上说，监督学习类似于从一本图画书中学习水果的名称:你将水果的特性——特征——与写在页面上的名称——标签联系起来。监督学习算法的经典例子是线性回归、逻辑回归、支持向量机、神经网络等等。
另一方面，无监督学习就像拿着同一本水果图画书，分析所有的水果以检测模式，然后决定按颜色和大小对水果进行分组。无监督学习算法的经典例子是 k 均值聚类、层次聚类、主成分分析、自动编码器等等。
结论
让我们以提到机器学习并不那么新来结束这篇文章，驱动今天的应用程序的许多算法已经存在多年了。然而，随着时间的推移，我们取得了一些重大进步:我们建立了比以往任何时候都大的数据集，我们提高了计算能力，我们想象出了新的前沿模型。如果这些进步已经使我们有可能在许多任务上接近甚至超越人类的能力，那么毫无疑问，我们只是触及了可能的表面！
我们真的希望你喜欢这篇文章。不要犹豫，留下你的反馈，在评论区告诉我们你对即将到来的视频感兴趣的话题。
感谢您的阅读，我们将在迈向数据科学节目中再见！
与 Baptiste Rocca 共同撰写的关于该主题的前一篇帖子:
一些机器学习和深度学习概念的软介绍。
towardsdatascience.com](/a-gentle-journey-from-linear-regression-to-neural-networks-68881590760e) [## 机器学习中不平衡数据集的处理
面对不平衡的班级问题，应该做什么，不应该做什么？
towardsdatascience.com](/handling-imbalanced-datasets-in-machine-learning-7a0e84220f28)
初学者机器学习入门
初学者机器学习入门
在过去的几年中，我们已经将机器学习视为一个热门词汇，其原因可能是应用程序产生了大量的数据，过去几年中计算能力的增加以及更好的算法的开发。
从自动化日常任务到提供智能见解，机器学习被用于任何地方，每个行业都试图从中受益。您可能已经在使用利用它的设备。比如 Fitbit 这样的可穿戴健身追踪器，或者 Google Home 这样的智能家居助手。但是使用 ML 的例子要多得多。
- 预测-机器学习也可以用于预测系统。以贷款为例，为了计算错误的概率，系统需要对可用数据进行分组。
- 图像识别-机器学习也可以用于图像中的人脸检测。在几个人的数据库中，每个人都有一个单独的类别。
- 语音识别——它是将口语单词翻译成文本。它被用于语音搜索等等。语音用户界面包括语音拨号、呼叫路由和设备控制。它也可以用来进行简单的数据输入和编写结构化文档。
- 医疗诊断— ML 经过训练，能够识别癌组织。
- 金融行业和贸易—公司在欺诈调查和信用检查中使用 ML。
机器学习简史
Image: Linked In | Machine Learning vs Deep learning
第一个手动操作的计算机系统 ENIAC(电子数字积分器和计算机)是在 20 世纪 40 年代发明的。在那个时候,“计算机”这个词被用来称呼具有密集的数值计算能力的人，所以，ENIAC 被称为数值计算机器！嗯，你可能会说跟学习无关？！错了，从一开始这个想法就是建造一台能够模仿人类思维和学习的机器。
EIMC — Electronic Numerical Integrator and Computer | Image: www.computerhistory.org
在 20 世纪 50 年代，我们看到第一个声称能够打败跳棋世界冠军的电脑游戏程序。这个程序帮助跳棋玩家提高了他们的技能很多！大约在同一时间，弗兰克·罗森布拉特发明了感知器，这是一个非常非常简单的分类器，但当它在网络中大量组合时，它就变成了一个强大的怪物。嗯，怪物是相对于时间而言的，在那个时间里，它是一个真正的突破。然后，我们看到神经网络领域由于难以解决某些问题而停滞了几年。
多亏了统计学，机器学习在 20 世纪 90 年代变得非常有名。计算机科学和统计学的交叉催生了人工智能中的概率方法。这使得该领域进一步转向数据驱动的方法。有了大规模的可用数据，科学家们开始构建能够分析和学习大量数据的智能系统。作为一个亮点，IBM 的深蓝系统击败了国际象棋世界冠军，特级大师加里·卡斯帕罗夫。是的，我知道卡斯帕罗夫指控 IBM 作弊，但这已经是历史了，深蓝现在正在博物馆里安息。
什么是机器学习？
根据亚瑟·塞缪尔的说法，机器学习算法使计算机能够从数据中学习，甚至改进自己，而无需显式编程。
机器学习(ML)是一种算法，它允许软件应用程序在预测结果时变得更加准确，而无需显式编程。机器学习的基本前提是建立可以接收输入数据并使用统计分析来预测输出的算法，同时随着新数据的出现更新输出。
机器学习的类型？
机器学习可以分为 3 种类型的算法。
- 监督学习—[链接将在未来的博客中发布]
- 无监督学习—[链接即将出现在未来的博客中]
- 强化学习—[链接将在未来的博客中发布]
3 Types of Learning
监督学习算法综述
在监督学习中，人工智能系统提供了带标签的数据，这意味着每个数据都贴上了正确的标签。
目标是很好地逼近映射函数，以便当您有新的输入数据(x)时，可以预测该数据的输出变量(Y)。
Example of Supervised Learning
如上例所示，我们最初获取了一些数据，并将其标记为“垃圾邮件”或“非垃圾邮件”。该标记数据由训练监督模型使用，该数据用于训练模型。
一旦它被训练，我们可以通过用一些测试新邮件测试它来测试我们的模型，并且模型的检查能够预测正确的输出。
监督学习的类型
- 分类:一个分类问题是当输出变量是一个类别时，比如“红”或“蓝”或“病”和“没病”。
- 回归:回归问题是当输出变量是一个实值时，比如“美元”或者“重量”。
无监督学习算法综述
在无监督学习中，人工智能系统呈现的是未标记、未分类的数据，系统的算法在没有事先训练的情况下对数据进行操作。输出取决于编码算法。让系统接受无监督学习是测试人工智能的一种方式。
Example of Unsupervised Learning
在上面的例子中，我们给了我们的模型一些角色，它们是“鸭子”和“不是鸭子”。在我们的训练数据中，我们不为相应的数据提供任何标签。无监督模型能够通过查看数据类型来区分两种特征，并对数据中的底层结构或分布进行建模，以便了解更多信息。
无监督学习的类型
- 聚类:聚类问题是你想要发现数据中的内在分组，比如按照购买行为对客户进行分组。
- 关联:关联规则学习问题是你想要发现描述大部分数据的规则，比如购买 X 的人也倾向于购买 y
强化学习概述
强化学习算法或代理通过与其环境交互来学习。代理通过正确执行获得奖励，通过错误执行获得惩罚。代理通过最大化它的奖励和最小化它的惩罚在没有人类干预的情况下学习。它是一种动态编程，使用奖惩系统来训练算法。
Example of Reinforcement Learning
在上面的例子中，我们可以看到代理有两个选项，即有水的路径或有火的路径。强化算法对奖励系统起作用，即，如果代理使用火道，则奖励被减去，代理试图学习它应该避开火道。如果它选择了水路或者安全的路径，那么一些点将会被加到奖励点上，代理将会试着学习什么路径是安全的，什么路径是不安全的。
它基本上是利用获得的回报，代理提高其环境知识来选择下一个行动。
摘要
在这篇博客中，我已经向你介绍了机器学习的基本概念，我希望这篇博客是有帮助的，并且会激发你对这个主题产生足够的兴趣。
用 ML 介绍 C#中的机器学习。网
当想到数据科学和机器学习时，两种编程语言 Python 和 R 立即浮现在脑海中。这两种语言支持所有常见的机器学习算法、预处理技术等等，因此可以用于几乎所有的机器学习问题。
然而，有时个人或公司不能或不想使用 Python 或 r。这可能是因为许多原因之一，包括已经有了另一种语言的代码库或没有 Python 或 r 的经验。当今最流行的语言之一是 C#，它用于许多应用程序。为了在 C#中使用机器学习的力量，微软创建了一个名为 ML.NET 的包，它提供了所有基本的机器学习功能。
在本文中，我将向您展示如何使用 ML.NET 创建一个二进制分类模型，讨论其 AutoML 功能，并向您展示如何使用张量流模型与 ML.NET。二进制分类模型的完整代码可以在 my Github 上找到。
将 ML.NET 添加到 C#项目中
将 ML.NET 添加到你的 C#或 F#项目中实际上是相当容易的。唯一需要的就是安装微软的T3。ML 包。根据你的使用情况，你可能还需要安装一些额外的包，比如微软的 。微软图像分析公司。ML.TensorFlow 或 微软。ML 变压器 。
加载数据集并创建数据管道
在 ML.NET 加载和预处理数据集与使用其他机器学习包/框架非常不同，因为它要求我们显式地陈述我们的数据结构。为此，我们在名为 DataModels 的文件夹内创建一个名为model input . cs的文件。在这个文件中，我们将陈述数据集的所有列。
对于本文，我们将使用可以在 Kaggle 上免费下载的信用卡欺诈检测数据集。这个数据集包含 31 列。交易的类别(0 或 1)、交易的金额、交易发生的时间以及 28 个匿名特征。
这里，我们为数据集中的每一列创建一个字段。重要的是指定正确的数据类型和列索引。
既然我们已经对数据进行了建模，我们还需要对我们的输出进行建模。这可以通过与上述脚本类似的方式来完成。
这里我们有两个字段。分数字段以百分比表示输出，而预测字段是布尔值。
既然我们已经建模了输入和输出数据，我们可以使用 LoadFromTextFile 方法加载实际数据。
创建和训练模型
要使用 model 创建和训练模型，我们需要创建一个管道，其中包含所需的数据预处理和训练算法。对于这个特殊的数据集，很难做任何预处理，因为它有 28 个匿名特征，因此我选择保持简单，只连接所有特征(这必须总是在 ML 中完成。网)。
对于模型，我选择了 LightGBM 算法。这个算法实际上并没有包含在微软的 中。ML 因此你需要安装 微软。ML . light GBM来使用。
现在我们可以使用 Fit 方法训练模型，并使用ml context . model . save保存它。
评估模型
现在我们的模型已经训练好了，我们需要检查它的性能。最简单的方法是使用交叉验证。ML.Net 为我们提供了各种不同数据集的交叉验证方法。因为我们的数据集是一个二元分类数据集，我们将使用 mlContext。binary classification . CrossValidateNonCalibrated方法对我们的模型进行评分。
做预测
使用 ML.NET 对新数据进行预测非常简单。我们只需要创建一个prediction engine，专门为我们的模型做的另一个表示，并调用它的 Predict 方法，传递它一个 ModelInput 对象。
自动毫升
ML.NET 的另一个伟大之处是它出色地实现了自动 ML 。使用 Auto-ML，我们可以通过指定我们正在处理的问题并提供我们的数据来构建基本的机器学习解决方案。
要在 ML.NET 开始使用 Auto-ML，您需要下载“ML.NET 模型构建器(预览)”Visual Studio 扩展。这可以通过扩展选项卡来完成。
成功安装扩展后，可以通过在解决方案浏览器中右键单击您的项目并选择添加- >机器学习来使用 Auto-ML。
这将打开“模型构建器”窗口。模型构建器将指导您完成构建机器学习模型的过程。
有关如何完成所有步骤的信息，请务必查看官方入门教程。完成所有步骤后，模型构建器将自动生成代码。
使用预先训练的张量流模型
ML.NET 的另一个伟大之处是它允许我们使用 Tensorflow 和 ONNX 模型进行推理。要使用 Tensorflow 模型，您需要安装微软的 。ML.TensorFlow 使用 NuGet。安装必要的包后，您可以使用 模型加载 Tensorflow 模型。LoadTensorFlowModel 方法。之后需要调用ScoreTensorFlowModel方法，并传递给它输入输出层名称。
有关如何在 ML.NET 使用 Tensorflow 模型的更多信息，请查看“使用 ML.NET c#代码运行从 Azure Cognitive Services Custom Vision 导出的 TensorFlow 模型”。
结论
ML。NET 是一个. NET 包，允许您在. NET 中创建和使用机器学习模型。在本文中，您学习了如何使用 ML.NET 创建一个信用卡欺诈检测模型。
这就是这篇文章的全部内容。如果你有任何问题或者只是想和我聊天，请在下面留下评论或者在社交媒体上联系我。如果你想获得我博客的持续更新，请确保在 Medium 上关注我，并加入我的时事通讯。
机器学习模型解释简介
Figure 1: Photo by Christopher Gower on Unsplash
不管你在解决什么问题，一个可解释的模型总是首选的，因为最终用户和你的老板/同事都能理解你的模型真正在做什么。模型可解释性还可以帮助您调试您的模型，让您有机会看到模型真正认为什么是重要的。
此外，你可以使用可解释的模型来打击普遍认为机器学习算法是黑盒，我们人类无法获得关于它们如何工作的任何见解。
本文是我系列文章的第一篇，旨在解释我们如何实现可解释的机器学习/人工智能的不同方法。
为这个系列做计划
我的系列文章将涵盖关于如何让机器学习变得可解释的理论和实践信息。文章的结构如下:
第 1 部分:机器学习模型的可解释性
- 什么是模型解释？
- 模型解释的重要性
- 什么特性对模型很重要？
- 理解个人预测
第二部分:哪些特性是重要的
- 如何获得不同类型模型的特征重要性
- 什么是部分相关图，如何使用它们
第 3 部分:解读个人预测
- 局部可解释的模型不可知解释(LIME)
- SHapley 加法解释(shap 值)
为什么机器学习中的可解释性很重要？
即使在今天，数据科学和机器学习应用仍然被视为能够神奇地解决没有它就无法解决的任务的黑匣子。这是完全不正确的，为了数据科学项目的成功，开发团队必须对他们试图解决的问题有很好的理解，并且知道他们需要什么样的模型来解决手头的问题。
然而，考虑到大多数商业人士不会对机器学习管道有直观的理解，因此不会理解你花哨的精度指标或损失函数，你需要另一种方式向他们展示你的模型的性能。
此外，良好的性能并不总是意味着您的模型在做正确的事情，因此经常会出现以下问题:
- 我为什么要相信这个模型？
- 模型是如何做出预测的？
数据科学家和研究人员多年来一直试图回答这些问题，并提出了多种方法来提取有关机器学习模型决策过程的信息。
这些方法中的一些是特定于模型的，而另一些适用于所有的模型，不管模型有多复杂。说到复杂性，每个数据科学家都知道模型可解释性与模型性能之间的权衡，这基本上就是说，如果我们增加模型的复杂性，就更难正确解释它。
一般来说，线性模型以及基于树的模型可以很容易地解释，因为它们以直观的方式获得预测，但是您可能需要牺牲准确性，因为这些模型很简单，并且很容易根据问题欠拟合或过拟合。
另一方面，您有更复杂的模型，如集合模型(如随机森林、XGBoost 等)以及深度神经网络，由于其复杂性，这些模型尤其难以解释。
对于欺诈检测、无人驾驶汽车或贷款等现实世界的问题，该模型不仅需要表现良好，还需要易于解释，以便我们可以了解贷款被批准/未被批准的原因，并使用我们的领域专业知识来验证或纠正决策。
理解模型解释
如上所述，模型可解释性试图理解和解释机器学习模型在进行预测时采取的步骤和决策。它让我们能够质疑模型的决策，并了解以下方面。
- **什么特征/属性对模型很重要？**你应该能够提取关于哪些功能是重要的，以及功能如何相互作用以创建强大信息的信息。
- **为什么模型会得出这个结论？**你还应该能够提取关于特定预测的信息，以验证和证明为什么模型会产生某种结果。
模型可解释性的类型
多年来，数据科学家和研究人员开发了许多不同类型的模型可解释性技术。这些技术可以分为不同的类型，如 Christoph Molnar 的优秀免费在线书籍“可解释的机器学习，使黑盒模型可解释的指南”中所述。
**内在的还是事后的？**内在可解释性是指由于结构简单而被认为是可解释的模型，如线性模型或树。事后可解释性是指在训练模型后，通过应用模型可解释性方法(如特征重要性、部分相关性或时间)来解释类似神经网络或集成的黑盒模型。
特定于模型还是与模型无关？特定于模型的解释工具专用于单个模型或一组模型。这些工具在很大程度上依赖于特定模型的工作和功能。相比之下，模型不可知的工具可以用在任何机器学习模型上，不管它有多复杂。这些不可知的方法通常通过分析要素输入和输出对来工作。
**本土还是全球？**解释方法是解释单个预测还是整个模型行为？
哪些特征是重要的，它们如何影响预测
模型一般表现如何？什么特征驱动预测？哪些特性不值得收集它们所花费的金钱和时间？这些都是公司在考虑为某种任务构建机器学习解决方案时可能会问的重要问题。全局模型可解释性通过解释什么特征是重要的、它们如何重要以及它们如何相互作用来帮助回答这些问题。
特征重要性
特征的重要性是在我们置换了特征的值之后模型的预测误差的增加，这打破了特征和真实结果之间的关系。— 可解释的机器学习，一个让黑盒模型变得可解释的指南
Figure 2: Feature Importance Example
特征重要性是一个非常简单的概念，在大多数主要的机器学习库中都有实现，包括 Scikit Learn、XGBoost、LightGBM。
如果打乱某个特征的值会使模型误差大幅增加，则该特征被认为是重要的，因为这意味着模型依赖于该特征进行预测。相比之下，如果打乱某个特征的值对模型的误差没有影响，那么该特征就不重要。
部分相关图
虽然特性重要性向我们展示了哪些特性是重要的，但它并没有给我们关于特性中特定变化的影响的信息。部分相关性图可以显示目标和特征之间的关系是线性的、指数的还是更复杂的。
Figure 3: Partial Dependence Plot Example
部分函数告诉我们特征 s 的给定值的平均边际效应。它通过强制所有数据点具有相同的特征值(例如，将性别列的每个值替换为女性)来获得特征中每个唯一值的 PDP 估计值。
有关部分依赖图如何工作的更多信息，请查看可解释机器学习的部分依赖图部分，这是一个使黑盒模型可解释的指南。
理解个人预测
模型为什么做出这个具体的预测？随着机器学习模型越来越多地用于欺诈检测或医疗任务等应用，这个问题变得越来越重要，因为对于这些类型的应用，能够验证和证明模型产生的结果尤为重要。
LIME(局部可解释的模型不可知解释)
局部代理模型是可解释的模型，用于解释黑盒机器学习模型的个体预测— Christoph Molnar
在论文《我为什么要相信你？作者提出了一种称为局部可解释模型不可知解释(LIME)的方法，其中代理模型被训练为局部地而不是全局地近似底层黑盒模型的预测。
它通过围绕感兴趣的数据点从置换的数据点创建新的数据集，以及黑盒模型的相应预测来实现这一点。然后，LIME 使用这个新的数据集来训练一个可解释的模型，如树或线性模型，然后可以用来解释这个局部点的黑盒模型。
沙普利值
沙普利值是一种根据玩家对总支出的贡献将支出分配给玩家的方法。但是这和机器学习有什么关系呢？
在机器学习的情况下，“游戏”是对数据点的预测任务。“增益”是预测减去所有实例的平均预测，而“玩家”是数据点的特征值。
Shapley 值是一个特性值在所有可能的联合中的平均边际贡献。这是一种解释单个预测的极好方法，因为它不仅给出了每个特征值的贡献，而且这些贡献的大小也是正确的，这与 LIME 等其他技术不同。
Figure 4: Shap example
在本系列的第三部分中，我们将更仔细地研究局部解释方法，如 LIME 和 Shapley 值，我们不仅将学习这些技术的理论，还将在真实数据集上实现它们。
进一步阅读
机器学习算法通常作为黑盒运行，不清楚它们如何得出某种决定。这个…
christophm.github.io](https://christophm.github.io/interpretable-ml-book/) [## 人类可解释的机器学习的重要性
人类可解释机器学习和模型解释简介
towardsdatascience.com](/human-interpretable-machine-learning-part-1-the-need-and-importance-of-model-interpretation-2ed758f5f476)
结论
模型可解释性不仅有助于调试您的模型，使您作为机器学习工程师的生活更加轻松，而且还有助于建立人类与模型之间的信任，随着机器学习在越来越多的行业中得到使用，这变得越来越重要。
下一步是什么？
在本系列的第 2 部分中，我们将更仔细地研究特性重要性和部分依赖图，不仅深入研究这些技术的细节，还将使用 eli5 和 pdpbox 库应用我们的知识。
感谢您阅读帖子。如果你对我接下来应该报道的内容有任何反馈、建议或想法，请随时在社交媒体上发表评论或联系我。
机器学习自顶向下方法简介
超级流畅的机器学习入门
我们从未想象过计算机会改进到什么程度，成为我们今天拥有的巨大机器，它们不仅在自己的工作上变得更好，还在征服其他工作。
在我写这篇文章的时候
- 互联网上有 4，156，513，325 个用户，如果你试图去数他们，需要 128 年以上。
- 互联网上的 1755606975 个网站。
- 仅今天就发了 168，673，726，872 封邮件。
- 仅今天就有 4723747823 次谷歌搜索。
- 仅今天就有 4033234 篇博文。
- 仅今天在 youtube 上就有 4553543234 次视频观看。
我可以永远这样下去，这些数字增长得令人难以置信地快，大量的数据存在，我们甚至可以让计算机了解这些数据，我们可以对计算机进行编程，从这些数据中获得某种经验，并形成一个简单的小型大脑(大多数情况下是愚蠢的)，但致力于解决一个特定的问题，甚至一个以上的问题，只要你是忍者级别的程序员/研究员。
这个大脑我们经常称之为模型，它很可能是一个函数，如果你有大量的数据，并且想要大脑/模型变得复杂和精密，你可以让它成为一个更高次的函数**(又名神经网络)**，我说的更高次不是指我们在学校学的三次或二次函数，我指的是更高。
这并不像听起来那么复杂，一切都很容易
好消息是(**机器学习介绍)**不是带你深入这个复杂的数学东西的地方。
首先，我会让你相信机器学习是一个非常有趣的领域，并告诉你一些关于机器人、人脸检测、垃圾邮件检测等等的东西，但我希望这是简短而中肯的，所以请阅读下面的内容，尝试在你的脑海中绘制一幅地图，并保持专注，从现在开始！
定义一个大纲
—机器学习系统读取数据集并优化大脑/模型以解决问题。
关注这些关键词，我们将逐一讨论。 **-machine learning-System(ML-System)😗*控制整个过程的算法 - Dataset: 提供给系统的数据。 **-模型:**我们优化解决问题的大脑或功能。 **-问题:**令人惊讶的是这正是我们要解决的问题。
机器学习系统
让我们从谈论**machine learning-System(ML-System)**开始，它只是一个完成工作的算法，遍历数据集，初始化模型并将数据馈送给模型以从中学习。
机器学习系统的分类:
我们可以将机器学习系统分为多个类别，如下所示。
1.模型是否经过人工监督训练(有监督、无监督、半监督和强化学习)、**、**用更简单的话说:
- 在监督ML-系统中，您输入算法的训练数据(数据集)包括所需的解决方案，称为 标签。
- 在无监督 ML-System 中，你馈送给算法的训练数据(数据集)是未标记的(不包括期望的解)，系统尝试在没有老师的情况下学习。
- 在半监督ML-系统中，您提供给算法的训练数据(数据集)被部分标记。
- 在强化ML-系统中，它有一点不同，这里的模型被称为代理，它的工作是执行动作，他获得奖励，代理然后学习，因为他试图最大化奖励，这就像用糖果训练你的宠物。
2.模型是否可以动态增量学习(在线学习、批量学习)，用更简单的话来说:
- 在**批量学习中，**模型不能增量学习。首先，我们让模型根据所有数据进行训练，然后将其投入生产。
- 在**在线学习中，**模型通过顺序输入实例进行增量训练，或者单独输入，或者通过称为小批量的小组输入。
资料组
它是提供给系统进行训练的训练数据，我们将数据集的复杂性降低到特征中，以便于模型从数据中学习
特征是被观察现象的个体可测量的属性或特征。
例如，让我们使用房价数据集，它主要是一个表，其中每行代表一所房子，列= [ ‘house_id ‘，’ house_size ‘，’ no_of_rooms ‘，’ price’ ]，而问题是预测房子的价格。
决定使用哪些功能是非常重要的一步，您必须考虑很多事情，我将在另一篇文章中带您完成这一步，但我们可以从 features = [house_size，no_of_rooms]开始，因为这是一个简单的示例。
我们正在使用的模型将试图了解如何根据给定的特征来估计这些标签(输出)，换句话说，房子的价格如何受到其大小和房间数量的影响。这个过程叫做，训练 。
我们在数据集上可能面临的问题
- 训练数据量不足。 模型需要成千上万个例子来解决简单的问题，而对于图像识别等更复杂的问题，它们需要数百万个例子
在 2001 年发表的一篇著名论文中，微软研究人员 Michele Banko 和 Eric Brill 表明，一旦给定足够的数据，非常不同的机器学习算法(包括简单的算法)在复杂的问题上表现得一样好。
由此可见训练数据的数量有多重要。 - 非代表性训练数据。 使用代表您想要归纳的案例的训练数据至关重要，数据集应覆盖尽可能多的不同案例。
- 数据质量差。 这意味着它充满了意想不到的错误、噪音和异常值，这将使模型更难检测模式，并且很可能不会执行得很好。有一些时间清理数据或者丢弃有噪声的部分。
- 无关的特征。 特征选择是一个非常重要的步骤，模型可以检测出期望的标签(解)和一个不相关的特征之间的关系，这将使预测更加随机。
- 过拟合。 表示模型在训练数据上表现很好，但泛化能力不好。换句话说，模型已经很好地学习了训练数据，它记住了它，这很可能是因为模型相对于数据量和噪声来说太复杂了。(如果你在另一篇文章中遇到这个问题，我会告诉你怎么做)。
- 营养不良。 很明显是过度拟合的反义词，这种情况发生在模型过于简单无法理解数据的时候。
要知道为你的项目选择哪个模型，阅读本文 使用哪个机器学习模型？
这里有一些模型你可以看看，我会写文章解释它们是如何工作的。
监督学习算法示例
- k-最近邻
- 线性回归
- 逻辑回归
- 支持向量机
- 决策树和随机森林
- 神经网络——注意:一些神经网络可以是无监督的(如自动编码器和受限玻尔兹曼)或半监督的。
无监督学习算法示例
- 聚类(例如，k 均值、层次聚类分析 HCA)
- 可视化和维度缩减(例如主成分分析 PCA)
- 关联规则学习(例如 Eclat)
你可以阅读 5 步和 10 步，来学习机器学习发表在《走向数据科学》刊物上的文章
祝你的机器制造愉快创意 。
用口袋妖怪介绍机器学习
使用 R 进行逻辑回归和决策树分析的指南。
R 是什么？
r 是一种免费的统计编程语言。
根据 guru99 ，
r 是一种编程语言，被数据科学家和大公司广泛使用，如谷歌、Airbnb、脸书等。用于数据分析。
什么是机器学习？
机器学习是人工智能的一个分支。机器学习的主要目的是教会程序如何训练自己并从错误中学习。目标是让程序不断学习和发展其预测的准确性**，而不需要**定期接受训练。如果你有兴趣了解更多，这里有一个有用的链接。
许多类型的模型可以用于机器学习，但是对于本文的目的；我将重点介绍逻辑回归和决策树。
逻辑模型
逻辑回归用于确定事件发生或不发生的概率。当因变量是分类变量时使用。
例如，预测某人是男性(1)还是女性(0)。
决策图表
决策树是用于分类和预测的标准工具。它使用一个易于理解的图表来展示测试并输出两个结果。这种模式一直持续到测试有一个合理的预测结果。
对于这个分析，我将使用一个包含 800 个口袋妖怪角色和几个变量的数据集。如果你想访问这个数据集来进行你的实验，这里有一个链接来下载它。
目标
这样做的目的是建立一个逻辑模型和一个决策树来帮助预测一个口袋妖怪是否会被归类为传奇的概率。只有少数口袋妖怪被认为是传奇，所以我们想看看我们的模型是否能准确预测它。
我的分析假设你已经熟练使用 r。
设置
library(ggplot2)
library(gplots)
library(readr)
library(rpart)
library(ROCR)
library(rpart.plot)
库 rpart ， ROCR ， rpart.plot 是 r 中决策树所必需的
读入文件
pkdf <- read.csv("Pokemon.csv")
head(pkdf)
We see in the last column on the right the Legendary status of the pokemon
逻辑回归模型
我们将需要使用glm()函数来获取 logistic 模型。该函数要求我们传入自变量，后跟一个波浪号(~)。**
- 第一个逻辑模型—所有变量
首先，我将尝试使用所有因变量的模型。
*pk_logit_model_1 <- glm(Legendary ~ Attack + Defense + Sp_Atk + Sp_Def + HP + Speed, data = pkdf, family = "binomial")
summary(pk_logit_mode_1)*
Logistic Model 1
在 R 中，每个变量右边的让我们知道这个变量是否重要。正如我们看到的，所有的变量都是重要的。让我们再测试几个模型，看看是否会得到不同的结果。*
2。第二个逻辑模型—移除防御变量**
对于这个模型，我将去掉防御变量，观察结果。每次删除变量时，一次删除一个变量是很重要的。
*pk_logit_model_2 <- glm(Legendary ~ Attack + Sp_Atk + Sp_Def + HP + Speed, data = pkdf, family = "binomial")
summary(pk_logit_mode_2)*
Logistic Model 2
我们可以看到所有变量都保持显著，但如果我们看一下顶部的偏差残差，我们可以看到中值偏差残差下降了，这很好。
如果你不熟悉中位数偏差残差，这里的是一个很好的解释。
3。第三个逻辑模型—移除速度变量**
为了测试另一个模型，让我们试着移除速度并查看结果。
*pk_logit_model_3 <- glm(Legendary ~ Attack + Sp_Atk + Sp_Def + HP, data = pkdf, family = "binomial")
summary(pk_logit_model_3)*
Logistic Model 3
我们可以再次看到中值偏差残差下降，这意味着我们的第三个模型更适合我们的预测。
我们如何解释基本回归系数？
让我们看看我们刚刚做的第三个模型。查看第一列，标有的估计值*(系数)帮助我们更好地理解我们的模型。重点是攻击变量，其系数为 0.029982。*
使用 exp()，计算一个数或数向量的指数值。
*exp(0.029982)-1*
这一行代码的输出是 0.0304 。这可以理解为，
如果攻击增加 1 点，这个口袋妖怪成为传奇的几率增加 3.04%
决策图表
我们已经为决策树模型加载了所有必要的库。使用 rpart() 函数，其结构类似于逻辑建模中使用的【glm()函数。
*pk_tree_model <- rpart(Legendary ~ Attack + Sp_Atk + Sp_Def + HP, data = pkdf, method = "class")rpart.plot(pk_tree_model, type = 1, extra=1, box.palette =c("pink", "green"), branch.lty=3, shadow.col = "gray")*
现在，我们已经完成了决策树模型，我们将把它与我们的第三个逻辑模型进行比较，看看它们在预测一个传奇口袋妖怪方面如何相互竞争。
比较两种模型
接下来的几个代码步骤是必要的，以查看哪个模型执行得最好。获得我们的结果有四个步骤。我称之为 4p。
- 预测
- 预言；预测；预告
- 性能
- 情节
我们的目标是预测每个观察值为 1 的概率。
预测
在我们的模型上使用 predict()函数，并提供我们的数据集进行测试。
*pk_predict_logit <- predict(pk_logit_model, pkdf, type="response")
pk_predict_tree <- predict(pk_tree_model, pkdf, type="prob")*
在继续之前，我们可以做一些初步的测试来了解我们的模型性能。
对 ID 为 59 的口袋妖怪进行测试
*pk_predict_logit[59]
pk_predict_tree[59]*
*结果表明 **Logit 是 0.002，**和 Tree 是 0.974 。这意味着树(97%)非常有信心认为口袋妖怪 59 是传奇，而 Logit (0.2%)并不这么认为。我们可以通过手动拉起口袋妖怪 59 来查看，就是口袋妖怪— 波斯 **。*波斯不是传说中的口袋妖怪，所以我们的树模型不好。
让我们测试另一个口袋妖怪来仔细检查。
使用 ID 799 对口袋妖怪进行测试
*pk_predict_logit[799]
pk_predict_tree[799]*
结果表明 Logit 为 0.983，和树为 0.3 。这意味着树(3%)不认为口袋妖怪 799 是传奇，Logit (98%)认为它是传奇。口袋妖怪 799 是 胡帕胡帕未绑定其中，根据数据集，被归类为传奇。从而再次证明我们的逻辑模型比树表现得更好。
下面我们可以继续测试这两种模型。
预言；预测；预告
对我们的预测输出使用预测()函数，并提供传奇变量。它用于转换输入数据。
**pk_logit_prediction <- prediction(pk_predict_logit, pkdf$Legendary)
pk_tree_prediction <- prediction(pk_predict_tree[,2], pkdf$Legendary)**
表演
在我们的预测输出上使用性能()函数，来评估谁被评估得好。
输入“tpr”表示真阳性，“fpr”表示假阳性。
**pk_performance_logit <- performance(pk_logit_prediction,"tpr","fpr")
pk_performance_tree <- performance(pk_tree_prediction,"tpr","fpr")**
情节
在我们的性能上使用 plot()函数来获得我们的两个模型表现如何的可视化表示。
**plot(pk_performance_logit,col="blue",lty=3, lwd=3)
plot(pk_performance_tree,col="black",lty=3, lwd=3, add=TRUE)**
Comparisons of the two models
蓝线代表逻辑模型，黑线代表决策树模型。
正如我们所看到的，蓝线(逻辑)在那里表现更好，这是一个更好的选择，用来帮助确定口袋妖怪有传奇分类的概率。
我的资源:
Python 中 Matplotlib 的介绍
在matplotlib库中使用数据可视化技术的快速指南
什么是数据可视化？
是以图形、图标、演示等方式可视化数据的实践。它最常用于将复杂的数据转化为非技术受众易于理解的见解。
如果你是数据可视化的新手，这是一本很好的入门书籍— 用数据讲故事
Python 是什么？
Python 是一种编程语言，可以让你更快地工作，更有效地集成你的系统。
Python 是最流行的编程语言之一，有各种各样有用的应用。对于本文，我假设您已经掌握了 Python 语言的基本知识。
如果你不知道，这里有一些很好的资源，
什么是 Matplotlib？
Python 中有成千上万个 库 ，Matplotlib 是 Python 中最强大的数据可视化工具之一。
Matplotlib 试图让容易的事情变得容易，让困难的事情变得可能。您可以生成图表、直方图、功率谱、条形图、误差图、散点图等。，只需要几行代码。
让我们开始吧！
导入库
为了让 matplotlib 在我们的环境中运行，我们需要导入它。
import **matplotlib.pyplot** as plt
在别名 plt — 下导入 matplotlib 是常见的做法，这样，我们只需键入更少的代码来引用它。
无论何时使用 matplotlib 绘图，两个主要代码行应该是:
- 图表类型—这是您定义条形图、折线图等的地方。
- 显示图表—这是为了显示图表
曲线图
#create data for plotting
x_values = [0,1,2,3,4,5]
squares = [0,1,4,9,16,25]#the default graph style for plot is a line
plt.**plot**(x_values, squares)#display the graph
plt.show
条形图
#create data for plotting
x_values = [5,6,3,7,2]
y_values = ["A", "B", "C", "D", "E"]plt.**bar**(y_val,x_values, **color = "green"**)
plt.show()
当使用条形图时，代码的变化将从 plt.plot() 变为 plot.bar() 将其变为条形图。如果你看看代码的内部，我还添加了一个参数 颜色——这有助于我们快速定制图形的颜色。
我们也可以用下面的方法水平翻转条形图，
#create data for plotting
x_values = [5,6,3,7,2]
y_val = ["A", "B", "C", "D", "E"]# Adding an "h" after bar will flip the graph
plt.**barh**(y_val,x_values, color ="**yellowgreen**")
plt.show()
Notice the change in the color argument
散点图
#create data for plotting
x_values = [0,1,2,3,4,5]
squares = [0,1,4,9,16,25]plt.**scatter**(x_values,squares, **s=10,** color = "pink")
plt.show()
你能看出模式吗？现在代码从 plt.bar() 变成了 *plt.scatter()。*我还加了 s 的参数。s 代表大小，它允许我们控制我们想要图上的点有多大。
直方图
#generate fake data
x = [2,1,6,4,2,4,8,9,4,2,4,10,6,4,5,7,7,3,2,7,5,3,5,9,2,1]#plot for a histogram
plt.**hist**(x, **bins = 10**, color='blue', **alpha=0.5**)
plt.show()
查看代码片段，我添加了两个新参数。
- bin-是直方图特有的参数，允许用户自定义想要多少个 bin。
- Alpha 显示数据点透明度级别的参数。
如果我同时调整仓位和 alpha，我会得到这样的结果，
x = [2,1,6,4,2,4,8,9,4,2,4,10,6,4,5,7,7,3,2,7,5,3,5,9,2,1]
num_bins = 10plt.hist(x, **bins= 4**, color='blue', **alpha=0.1**)
plt.show()
概观
我们只是触及了 matplotlib 强大功能的表面。一旦你更深入地研究这个主题，你会发现你可以有多少定制能力来创建丰富多彩的、详细的和生动的图形。
matplotlib 库和 python 中的其他流行库提供了更多的图形，包括 seaborn ，pandas plot，和 plotly 。探索所有不同的选项并找到适合您的编码和分析风格的库是值得的。
请继续关注——我将分享一个关于在 matplotlib 中定制图表的教程。
矩阵轮廓简介
一种新的时间序列挖掘数据结构
在时间序列分析中，人们通常对两件事感兴趣；异常和趋势。例如，医生检查 EKG(心电图——心跳读数),看是否有异常事件表明患者存在风险。在零售业工作的个人需要了解销售什么商品以及何时销售(季节性)以增加利润。发现时间序列中异常和趋势的一种方法是执行相似性连接。本质上，您可以通过计算每对片段之间的距离来比较时间序列的片段。虽然使用嵌套循环实现一个简单的算法只需很少的努力，但使用这种方法可能需要几个月或几年的时间才能得到中等大小的时间序列的答案。利用矩阵轮廓算法大大减少了计算时间。
Matrix Profile 是一种相对较新的数据结构，于 2016 年推出，由加州大学河滨分校的埃蒙·基奥和新墨西哥大学的阿卜杜拉·穆恩开发。使用矩阵轮廓的一些优点是它是领域不可知的、快速的、提供精确的解决方案(当需要时是近似的)并且只需要单个参数。
本文的主要目标是让您熟悉这些好处，以便您可以利用它们。由于矩阵轮廓主要是可视化的，所以我们在本文中利用这一点，尽可能避开数学符号，而将重点放在可视化上。如果你想要学术描述，请阅读基奥博士网页上的研究出版物。
这篇介绍性文章将涵盖以下内容:
- 矩阵轮廓由什么组成？
- 什么是不和？
- 什么是主题？
- 哪些算法用于计算矩阵轮廓？
- 这些算法有什么区别？
- 从哪里可以得到这些算法？
- 一个简短但实用的不和谐发现的例子。
矩阵简介概述
矩阵轮廓有两个主要组成部分；一个距离轮廓和轮廓索引。距离轮廓是最小 Z 归一化欧几里德距离的矢量。轮廓索引包含其第一个最近邻的索引。换句话说，它是其最相似的子序列的位置。
计算矩阵轮廓的算法使用滑动窗口方法。窗口大小为 m ，算法:
- 计算加窗子序列相对于整个时间序列的距离
- 设置一个排除区域以忽略无关紧要的匹配
- 用最小值更新距离轮廓
- 设置第一个最近邻索引
上面概述的距离计算发生 n-m + 1 次；其中 n 是时间序列的长度，而 m 是窗口大小。由于子序列是从时间序列本身中提取的，因此需要一个排除区来防止的琐碎匹配。例如，匹配自身的代码片段或非常接近自身的代码片段被认为是微不足道的匹配。在当前窗口索引之前和之后，禁止区仅仅是窗口大小的一半( m )。计算最小距离和最近邻索引时，这些索引处的值将被忽略。显示从第二个窗口开始的距离轮廓计算的可视化如下所示。
第二个值窗口，从 X2 到 X5，在时间序列上滑动，计算每个子序列的点积。计算完所有的点积后，将排除区域应用于距离，最小距离存储在矩阵配置文件中。扔掉多余的距离，只保留最小距离，将空间复杂度降低到 0(n)。
主题和主题
简单地说，母题是时间序列中的重复模式，而不一致是异常。计算出矩阵的轮廓后，很容易找到前 K 个基序或不一致。矩阵轮廓在欧几里德空间中存储距离，这意味着接近 0 的距离最类似于时间序列中的另一个子序列，而远离 0 的距离，比如 100，不像任何其他子序列。提取最小的距离给出了主题，最大的距离给出了主题。
矩阵轮廓算法
有一些算法可以计算矩阵轮廓。下表提供了算法的非穷举列表和关于它们的简短描述。
下面的图说明了使用 STAMP、STOMP 或 SCRIMP++比简单的方法有明显的优势。时间序列长度为 1，024，窗口大小为 32，naive 算法需要 50 多秒才能完成！另一方面，其他算法只需几分之一秒就能完成。
矩阵轮廓挖掘算法
一旦计算出矩阵轮廓，就必须使用额外的算法来从中提取信息。在讨论主题和不一致时，我简单地提到了这一点。以下是在矩阵配置文件上运行的算法的非详尽列表。
例子
对于我们的实际示例，我们将检查 2018 年的“纽约市黄色出租车乘客数量”。纽约市公开了许多数据集，以便每个人都可以探索它们。原始数据集带有许多其他属性，并且每分钟都提供详细信息。我汇总并整理了数据，以获得每小时的乘客数量。为了使这个例子简短，我就不详细介绍数据是如何聚合的了。我也避免在整个例子中展示代码。对于那些感兴趣的人，本文有一个公共代码库。
上面显示的原始数据为我们正在处理的问题提供了一些背景信息。您可能已经在数据中直观地看到了一些模式，但是想象一下，如果这是一年多的数据，或者我们查看每分钟的乘客数。如果没有某种类型的转换，很难直观地看到发生了什么。我们将计算不同窗口大小的矩阵轮廓，看看是否有什么有趣的东西突出出来。
上面使用的不同窗口大小说明了选择适当值的重要性。我不明白纽约出租车系统在 4、8 甚至 12 小时周期内的复杂细节。然而，我能够使用搜索引擎研究每天甚至每周的事件。由于在 24 小时和 7 天的窗口内有一些明显的不一致(图中的峰值),我们将把重点放在那些矩阵曲线上。为了提取不一致，我们使用“前 K 个不一致”算法。
上面的图用红色显示了前 5 个不一致。我花了一些时间研究这些可能与什么有关，并在情节中对它们进行了注释。对于每日矩阵配置文件，夏令时似乎对乘客数量有巨大影响。在夏令时，我们在凌晨 2 点左右各慢一个小时。乘客计数受到重复计数的影响，或者计数的乘客非常少。例如，在夏令时开始，我们失去了凌晨 2 点，但一些系统仍然设法在这个时候计数乘客。在这个特定的数据集中，仍然计算了 3 名乘客。
用 7 天矩阵图来观察时间序列，我们会得到稍微不同的结果。独立日和圣诞节在 7 天内有不同的波动。这并不罕见，因为大多数人在独立日会花时间在户外，在圣诞节会和家人在一起。
收尾工作
在本文中，向您介绍了 Matrix Profile 以及如何使用它来分析时间序列数据。这是一种鲜为人知的方法，因为它仍然是新的，但它是一种快速和领域不可知的方法。一旦你有了矩阵的轮廓，提取共同的模式(图案)和异常(不一致)是很容易的。在我们简短的纽约出租车例子中，我通过可视化说明了异常提取。
请记住，我只介绍了矩阵概要文件和一些概念。它提供了更多的功能。流数据分析的增量模式、语义分段和片段发现是更多的功能。我强烈建议任何对 Matrix Profile 或时间序列分析感兴趣的人查看补充部分。
承认
感谢 Tawni Marrs、Andrew Van Benschoten、Francisco Bischoff 和 Jackson Green 花时间阅读本文。最重要的是，我要感谢埃蒙·基奥、阿卜杜拉·穆恩和他们的合作者。没有他们的研究努力，这篇文章就不会存在。
补充的
- 本文的源代码:
https://github . com/matrix-profile-foundation/article-matrix-profile-intro
2.关于矩阵简介的研究论文在埃蒙·基奥的网页上:
【https://www.cs.ucr.edu/~eamonn/MatrixProfile.html 号
3.一个志愿者组织，矩阵档案基金会，链接可以在这里找到:
【https://matrixprofile.org/
4.矩阵轮廓算法的 Python 实现可在此处找到:
https://github.com/matrix-profile-foundation/matrixprofile
5.矩阵分析算法其余实现可在此处找到:
https://github.com/franzbischoff/tsmp
6.矩阵轮廓算法的 Golang 实现可在此处找到:
https://github . com/matrix-profile-foundation/go-matrix profile
Mesa 简介:Python 中基于代理的建模
基于 Python 的 NetLogo、Repast 或 MASON 的替代品，用于基于代理的建模
Simulation result showing segregation between blue and red agent
基于代理的建模依赖于模拟自主代理的动作和交互来评估它们对系统的影响。它通常用于预测给定复杂现象时我们将获得的投影。主要目的是在给定一组特定规则的情况下，获得关于代理将如何行为的解释性见解。基于 Agent 的建模已经广泛应用于生物学、社会科学、网络和商业等众多行业。本文涵盖了使用名为 Mesa 的开源 python 模块启动基于代理的建模项目的必要步骤。本教程有 4 个部分:
- 设置
- 谢林分离模型
- 形象化
- 结论
1.设置
对于 Mesa 来说，设置非常简单。确保创建一个新的虚拟环境。我把这个环境命名为 mesaenv。打开您的终端，将目录更改为 mesaenv，并使用以下代码激活虚拟环境:
虚拟环境
根据您的使用情形，运行以下命令来激活虚拟环境。
#Anaconda
conda activate mesaenv#Terminal
source bin/activate
Python 模块
本教程需要三个模块:
- 平顶山
- matplotlib
- 朱皮特
python3 -m pip install mesa
python3 -m pip install matplotlib
python3 -m pip install jupyter
基本文件夹
创建一个名为 Mesa 的基本文件夹，用于存储所有 python 文件。在本节末尾的基本文件夹中应该有以下文件:
如果您在教程中迷失了方向，请随意下载它。完成后，让我们继续下一部分。
2.谢林分离模型
在本教程中，我们将使用著名的谢林分离模型作为用例。请注意，mesa 官方网站上的介绍性教程是基于波尔兹曼财富模型的。谢林隔离模型是一个更好的用例，用来解释我们如何利用基于主体的建模来解释为什么种族隔离问题难以根除。尽管实际的模型非常简单，但它提供了关于个体如何自我隔离的解释性见解，即使他们没有明确的愿望这样做。我们来看看 Mesa 官方 github 页面提供的对这个模型的解释:
谢林隔离模型是一个经典的基于主体的模型，它证明了即使是对相似邻居的轻微偏好也能导致比我们直觉预期更高的隔离程度。该模型由正方形网格上的代理组成，每个网格单元最多可以包含一个代理。代理有两种颜色:红色和蓝色。如果他们八个可能的邻居中有一定数量的人是同一种颜色，他们会感到高兴，否则会不高兴。不开心的代理会随机选择一个空单元格移动到每一步，直到他们开心为止。模型一直运行，直到没有不开心的代理。
默认情况下，代理需要满意的相似邻居的数量设置为 3。这意味着代理会非常满意他们的大多数邻居是不同的颜色(例如，一个蓝色代理会满意五个红色邻居和三个蓝色邻居)。尽管如此，该模型始终导致高度隔离，大多数代理最终没有不同肤色的邻居。
Model.py
创建一个名为 model.py 的新 python 文件。
**代理:**我们将从单个代理类开始。
代码非常简单:
- 初始化代理类。
- 创建一个步骤功能。
- 计算相似邻居的数量。
- 如果代理不满意，请将代理移到空的位置。
**型号:**为型号类。我们将逐一浏览每一部分，以便更清楚地了解基于代理的建模是如何工作的。首先，创建一个谢林类，并将一个 init 函数定义为构造函数。
class Schelling(Model):
def __init__():
**变量:**系统将由至少一个基本代理类和一个模型类组成。我们先从写模型开始。我们需要定义 5 个主要变量:
- Width :网格的横轴，与高度一起用于定义系统中代理的总数。
- 高度:网格的纵轴，与宽度一起定义系统中代理的总数。
- 密度:定义系统中代理的群体密度。从 0 到 1 的浮点值。
- 分数少数:蓝色和红色的比例。蓝色代表少数，而红色代表多数。从 0 到 1 的浮点值。如果该值高于 0.5，蓝色反而会成为多数。
- 同向性:定义代理快乐所需的相似邻居的数量。整数值范围从 0 到 8，因为你只能被 8 个邻居包围。
self.height = height
self.width = width
self.density = density
self.minority_pc = minority_pc
self.homophily = homophily
记住在 init 函数中添加所需的参数作为输入参数。
网格:我们需要使用 mesa 下的空间模块来设置网格。
from mesa.space import SingleGridself.grid = SingleGrid(height, width, torus=True)
**调度器:**接下来，我们需要一个调度器。调度程序是一个特殊的模型组件，它控制代理的激活顺序。最常见的调度程序是随机激活，它以随机顺序每步激活所有代理一次。还有一种叫同时激活。查看 API 参考以了解更多信息。
from mesa.time import RandomActivationself.schedule = RandomActivation(self)
数据收集:数据收集对于确保我们在模拟的每一步后都获得必要的数据至关重要。您可以使用内置的数据收集模块。在这种情况下，我们只需要知道代理人是否快乐。
from mesa.datacollection import DataCollectorself.happy = 0self.datacollector = DataCollector( {"happy": "happy"},
{"x": lambda a: a.pos[0], "y": lambda a: a.pos[1]}
)
**代理设置:**我们现在将使用以下代码设置代理:
init 函数的最后一部分是设置以下参数:
self.running = True self.datacollector.collect(self)
一旦满足条件，运行变量可有条件地关闭模型。一旦所有的代理都满意了，我们就把它设置为假。
**步骤:**这个类需要一个表示每次运行的步骤函数。
- 在每一步重置快乐代理的计数器。
- 开始收集数据并确定满意的代理人数。
- 一旦所有代理都满意，就停止模型。
Run.py
创建一个名为 run.py 的新 python 文件，并输入以下代码。
Server.py
创建一个名为 server.py 的新 python 文件。
**导入:**将以下导入语句添加到文件中:
from mesa.visualization.ModularVisualization import ModularServerfrom mesa.visualization.modules import CanvasGrid, ChartModule, TextElementfrom mesa.visualization.UserParam import UserSettableParameter from model import Schelling
HappyElement: 创建一个名为 HappyElement 的类，并添加两个函数:
- 初始化
- 提供；给予
**Draw 函数:**定义一个名为谢林 _draw 的函数。
在运行服务器时，该部件充当可视化部件。
- 首先，我们定义基础波特拉尔。描绘是一个字典(可以很容易地转换成 JSON 对象),它告诉 JavaScript 方如何绘制它。
- 我们根据代理的类型改变描绘的颜色和笔触。在这种情况下，我们将有红色和蓝色的代理。
- 初始化画布和图表。
- 设置模型的参数。 UserSettableParameter 表示用户可以在网页中修改该参数。它有 6 个参数(类型、名称、初始值、最小值、最大值、每步值)。
- 最后，我们用上面定义的所有配置初始化服务器。
3.形象化
让我们通过在终端运行下面的代码来测试一下。确保你在基本文件夹(台面)。
mesa runserver
将启动一个 web 浏览器，您应该会看到以下输出:
帆布
我们之前定义的画布网格的可视化。每个点代表一个代理。
Image by Author
环境
您可以修改设置来测试它将如何影响模拟。修改这不会影响当前模拟。记得点击重置按钮进行更改。
Image by Author
每秒传输帧数
您可以定义自己的每秒帧数来加快模拟速度。
Image by Author
开始、步进、复位
您可以使用以下按钮:
- **开始/停止:**开始模拟。一旦启动，你可以点击相同的按钮来关闭它。
- **步骤:**只运行一个步骤来查看变化。
- **复位:**根据设置复位板卡。如果您在模拟运行时使用它，电路板将被重置，模拟将照常运行。
Image by Author
运转
点击开始按钮，您应该会看到画布的以下变化。
Gif by Author
图表
底部有一个图表，显示了满意的代理人数和满意的步骤数。
Image by Author
结果
模型应该在某一点停止，这取决于您设置的设置。你可以注意到代理人几乎是隔离的。
Image by Author
4.结论
让我们回顾一下今天所学的内容。
我们从设置和安装必要的 python 模块的一些简单步骤开始。
然后，我们学习了谢林分离模型，以及如何使用 Mesa 轻松地对其建模。我们创建了 3 个 python 文件，并进一步深入研究了 Mesa 中可用组件的基本用法。
之后，我们运行服务器来查看可视化效果。我们修改了一些设置，并进行模拟。事实上，官方的 Mesa github 为我们提供了更多可以探索的例子。查看以下链接了解更多信息。
希望你喜欢这个教程。祝您愉快，下次教程再见。
参考
- https://github.com/projectmesa/mesa
- https://mesa . readthe docs . io/en/master/tutorials/adv _ tutorial . html
- https://mesa . readthe docs . io/en/master/tutorials/intro _ tutorial . html
- https://github.com/projectmesa/mesa/tree/master/examples
- https://mesa.readthedocs.io/en/master/apis/api_main.html
使用 TensorFlow 的 Keras API 介绍多层神经网络
了解如何使用 TensorFlow 的高级 API Keras 构建和训练多层感知器！
Keras的开发始于 2015 年初。时至今日，它已经发展成为构建在Theano和TensorFlow之上的最流行和最广泛使用的库之一。它的一个突出特点是，它有一个非常直观和用户友好的 API，允许我们只用几行代码来实现神经网络。
Keras也从 1.1.0 版本集成到了TensorFlow中。它是contrib模块的一部分(包含由TensorFlow贡献者开发的包，被认为是实验代码)。
在本教程中，我们将通过浏览以下内容来了解这个高级TensorFlow API:
- 前馈神经网络的基础
- 加载和准备流行的 MNIST 数据集
- 构建图像分类器
- 训练神经网络并评估其准确性
我们开始吧！
本教程改编自 Next Tech 的 Python 机器学习 系列的 Part 4 ，带你从 0 到 100 用 Python 进行机器学习和深度学习算法。它包括一个浏览器内沙盒环境，预装了所有必要的软件和库，以及使用公共数据集的项目。这里 可以免费上手 ！
多层感知器
多层前馈神经网络是一种特殊类型的具有多个单个神经元的全连接网络。它们也被称为多层感知器 ( MLP )。下图说明了由三层组成的 MLP 的概念:
上图中描绘的 MLP 有一个输入图层、一个隐藏图层和一个输出图层。隐藏层中的单元完全连接到输入层，输出层完全连接到隐藏层。如果这样的网络有不止一个隐含层，我们也称之为深度人工神经网络。
我们可以向 MLP 添加任意数量的隐藏层来创建更深层次的网络架构。实际上，我们可以将神经网络中的层数和单元数视为我们希望针对给定问题任务进行优化的附加超参数。
如上图所示，我们将第 i 层中的第 i 个激活单元表示为 a_i^(l).为了使数学和代码实现更加直观，我们将使用上标中的作为输入层，使用 h 上标作为隐藏层，使用 o 上标作为输出层。
例如， a_i^(in) 是指输入层的第 i 个值， a_i^(h) 是指隐藏层的第 i 个单元， a_i^(out) 是指输出层的第 i 个单元。这里，激活单元 a_0^(in) 和 a_0^(out) 是偏置单元，我们设置为等于 1 。输入层中单元的激活仅仅是其输入加上偏置单元:
层 l 中的每个单元通过一个权重系数连接到层 l + 1 中的所有单元。例如，层 l 中第 k 个单元到层 l + 1 中第 j 个单元的连接将写成 w_{k，j}^(l) 。回头参考前面的图，我们将连接输入到隐藏层的权重矩阵表示为 W^(h) ，将连接隐藏层到输出层的矩阵表示为 W^(out) 。
我们通过矩阵总结了连接输入层和隐藏层的权重:
其中 d 是隐藏单元的数量， m 是包括偏置单元在内的输入单元的数量。因为理解这种符号对于理解本教程后面的概念很重要，所以让我们在一个简化的 3–4–3 多层感知器的描述性图示中总结一下我们刚刚学到的内容:
MNIST 数据集
为了查看通过tensorflow.keras ( tf.keras)高级 API 进行的神经网络训练是什么样的，让我们实现一个多层感知器来对来自流行的混合国家标准与技术研究所( MNIST )数据集的手写数字进行分类，该数据集用作机器学习算法的流行基准数据集。
为了跟随本教程中的代码片段，您可以使用这个 Next Tech 沙箱，它已经安装了 MNIST 数据集和所有必要的包。否则，您可以使用您的本地环境，在这里下载数据集。
MNIST 数据集分为四个部分，如下所示:
- 训练集图像 :
train-images-idx3-ubyte.gz— 6 万个样本 - 训练集标签:
train-labels-idx1-ubyte.gz—60000 个标签 - 测试集图像 :
t10k-images-idx3-ubyte.gz— 1 万个样本 - 测试集标签:
t10k-labels-idx1-ubyte.gz—10000 个标签
训练集由来自 250 个不同人的手写数字组成(50%是高中生，50%是人口普查局的员工)。测试集包含来自不同人的手写数字。
注意TensorFlow也提供了相同的数据集，如下所示:
但是，我们将使用 MNIST 数据集作为外部数据集，分别学习数据预处理的所有步骤。通过这种方式，您可以了解需要如何处理自己的数据集。
第一步是通过在终端中运行以下命令来解压缩 MNIST 数据集的四个部分:
load_mnist函数返回两个数组，第一个是一个 n x m 维NumPy数组(images)，其中 n 是样本的数量， m 是特征的数量(这里是像素)。MNIST 数据集中的图像由 28 x 28 像素组成，每个像素由一个灰度强度值表示。这里，我们将 28 x 28 像素展开成一维的行向量，表示我们的images数组中的行(每行或每幅图像 784)。由load_mnist函数返回的第二个数组(labels)包含相应的目标变量，即手写数字的类标签(整数 0-9)。
然后，按如下方式加载和准备数据集:
[Out:]
Rows: 60000, Columns: 784
Rows: 10000, Columns: 784
(60000, 784) (60000,)
(10000, 784) (10000,)
为了了解 MNIST 的这些图像，让我们通过 Matplotlib 的imshow函数来可视化数字 0-9 的例子:
我们现在应该可以看到一个 2 x 5 子图形的图，显示了每个唯一数字的代表性图像:
现在让我们开始建立我们的模型！
使用 TensorFlow 的 Keras API 构建 MLP
首先，让我们为NumPy和TensorFlow设置随机种子，以便获得一致的结果:
为了继续准备训练数据，我们需要将类标签(整数 0–9)转换为独热格式。幸运的是，Keras为此提供了一个方便的工具:
First 3 labels: [5 0 4]First 3 labels (one-hot):
[[0\. 0\. 0\. 0\. 0\. 1\. 0\. 0\. 0\. 0.]
[1\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0\. 0.]
[0\. 0\. 0\. 0\. 1\. 0\. 0\. 0\. 0\. 0.]]
现在，让我们实现我们的神经网络！简而言之，我们将有三层，其中前两层(输入层和隐藏层)各有 50 个带有tanh激活函数的单元，最后一层(输出层)有 10 层，用于 10 个类别标签，并使用softmax给出每个类别的概率。Keras让这些任务变得非常简单:
首先，我们使用Sequential类初始化一个新模型，以实现一个前馈神经网络。然后，我们可以添加尽可能多的层。然而，由于我们添加的第一层是输入层，我们必须确保input_dim属性匹配训练集中的特征(列)数量(在神经网络实现中为 784 个特征或像素)。
此外，我们必须确保两个连续层的输出单元(units)和输入单元(input_dim)的数量匹配。我们的前两层各有 50 个单元和一个偏置单元。输出图层中单元的数量应等于唯一分类标注的数量-一次性编码分类标注数组中的列数。
注意，我们使用glorot_uniform to 作为权重矩阵的初始化算法。 Glorot 初始化 是深度神经网络更鲁棒的初始化方式。偏差被初始化为零，这更常见，事实上是Keras中的默认设置。
在编译我们的模型之前，我们还必须定义一个优化器。我们选择了随机梯度下降优化。此外，我们可以设置权重衰减常数和动量学习的值，以调整每个时期的学习速率。最后，我们将成本(或损失)函数设置为categorical_crossentropy。
二元交叉熵只是逻辑回归中成本函数的技术术语，分类交叉熵是通过 softmax 对多类预测的推广。
编译完模型后，我们现在可以通过调用fit方法来训练它。这里，我们使用小批量随机梯度，批量大小为每批 64 个训练样本。我们训练 MLP 超过 50 个历元，我们可以通过设置verbose=1在训练过程中跟踪代价函数的优化。
validation_split参数特别方便，因为它将在每个时期后保留 10%的训练数据(这里是 6000 个样本)用于验证，这样我们可以监控模型在训练期间是否过度拟合:
打印成本函数的值在训练期间非常有用，可以快速发现训练期间成本是否在下降，并尽早停止算法。否则，需要调整超参数值。
为了预测类标签，我们可以使用predict_classes方法直接返回整数形式的类标签:
First 3 predictions: [5 0 4]
最后，让我们在训练集和测试集上打印模型准确性:
Training accuracy: 98.81
Test accuracy: 96.27
我希望你喜欢这篇关于使用TensorFlow的keras API 来建立和训练一个用于图像分类的多层神经网络的教程！注意，这只是一个非常简单的神经网络，没有优化的调整参数。
在实践中，你需要知道如何通过调整学习率、动量、重量衰减和隐藏单元的数量来优化模型。您还需要学习如何处理消失梯度问题，即随着网络中图层的增加，误差梯度会变得越来越小。
我们将在 Next Tech 的 Python 机器学习(第四部分) 课程中讨论这些主题，以及:
- 分解
*TensorFlow*的机制，如张量、激活函数、计算图、变量、占位符 - 低级
*TensorFlow*和另一个高级 API，*Layers* - 建模时序数据使用 递归神经网络*【RNN】和* 长短期记忆*【LSTM】网络*
- 用深度 卷积神经网络 (CNN)对图像进行分类。
这里 可以免费上手 ！
朴素贝叶斯分类器简介
机器学习和深度学习之旅
从理论到实践，学习朴素贝叶斯的基本原理
Source: https://thatware.co/naive-bayes/
本博客将涵盖以下问题和主题:
1.什么是朴素贝叶斯分类器？
2.如何在朴素贝叶斯分类器中计算参数并进行预测？
3.拉普拉斯平滑
4.python 中的应用
- 什么是朴素贝叶斯分类器？
朴素贝叶斯分类器属于概率分类器家族，使用贝叶斯定理。之所以称之为‘幼稚’，是因为它要求输入变量之间刚性的独立性假设。因此，称之为简单贝叶斯或独立贝叶斯更为恰当。自 20 世纪 60 年代以来，该算法得到了广泛的研究。尽管简单，朴素贝叶斯分类器仍然是解决文本分类问题的流行方法之一，即判断文档属于一个类别或另一个类别的问题，如垃圾邮件检测。
朴素贝叶斯分类器的目标是计算条件概率:
对于每个 K 可能的结果或类别 Ck。
设 x=(x1，x2，…，xn) 。利用贝叶斯定理，我们可以得到:
联合概率可以写成:
假设所有特征 x 相互独立，我们可以得到:
因此，公式可以写成:
因此，这是朴素贝叶斯分类器的最终公式。
2。 如何在朴素贝叶斯分类器中计算参数并进行预测？
最大似然估计(MLE)用于估计参数——先验概率和条件概率。
先验概率等于 y 发生的某些情况的数量除以记录总数。
p(x1=a1|y=C1) 的条件概率等于 x1 等于 a1 和 y 等于 C1 的情况数除以 y 等于 C1 的情况数。
朴素贝叶斯分类器使用以下公式进行预测:
例如，下表中的 15 条记录用于训练朴素贝叶斯模型，然后对新记录 X(B，S)进行预测。
使用上面的公式来估计先验概率和条件概率，我们可以得到:
最后，截止到 *X(B，S)*我们可以得到:
*P(Y = 0)P(X1 = B | Y = 0)P(X2 = S | Y = 0)>P(Y = 1)P(X1 = B | Y = 1)P(X2 = S | Y = 1)*所以 y=0。
3。拉普拉斯平滑
在统计学中，拉普拉斯平滑是一种平滑分类数据的技术。引入拉普拉斯平滑来解决零概率问题。应用这种方法，先验概率和条件概率可以写成:
K 表示 y 中不同值的个数， A 表示 *aj 中不同值的个数。*通常公式中的λ等于 1。
通过应用拉普拉斯平滑，先前示例中的先验概率和条件概率可以写成:
4。python 中的应用
步骤 1:创建数据集。
步骤 2:通过计算先验和条件概率来训练朴素贝叶斯模型。
第三步:做一个预测。
概要:
朴素贝叶斯分类器易于快速训练，可作为基准模型。当变量选择适当时，朴素贝叶斯可以表现得和其他统计模型一样好，甚至更好，如逻辑回归和 SVM。朴素贝叶斯需要对独立预测器的强假设，因此当模型表现不佳时，导致这种情况的原因可能是预测器之间的相关性。
你可以点击以下链接阅读更多博客:
这一系列博客将从理论和实现两个方面对深度学习进行介绍。
medium.com](https://medium.com/@songyangdetang_41589/table-of-contents-689c8af0c731)
参考:
[1] Christopher M. Bishop，(2009)，模式识别和机器学习
扫一扫
722
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
