顺便对比一下在用的文献阅读工具

图像处理中的image matting技术，中文简称抠图技术。Image Matting也是一个基本的计算机视觉问题，有着广泛的应用。

证件照换背景应该算是最简单的Image Matting，由于证件照背景属性的特殊性，这个抠图很容易可以实现。算法分为几个步骤：

1. 读入原始证件照图片
2. 转换到HSV色彩空间（色调（H），饱和度（S），明度（V））
3. 设置HSV空间的阈值获得图片背景的mask（抠图的结果）
4. 腐蚀膨胀去除干扰点
5. 遍历像素点替换背景颜色

使用python+opencv库可以很容易实现，有兴趣的可以自己了解一下

抠图技术与图像分割有什么区别

刚接触这项技术时一直有些疑虑，这个和图像分割技术有什么差别，

然后大概明白。图像分割是将原图分割成若干块，分割的好与不好就看分出来的块是否与图像的内容对应了，例如如果分割结束后某一块只包含半张人脸，另外半张在另一块上，那肯定就不是好的分割了。至于抠图技术，基本只会分成两块，一块是前景，另一块是背景，而大多数时候我们抠图也就是为了把前景给拿出来。基本抠图都要人工交互，而分割技术则是全自动的，当然有人工介入的抠图分割在准确性上要远高于常规的图像分割技术，优秀的抠图算法是有能力将前景中非常细小的毛发细节都能提取出的好算法，这点是传统图像分割技术做不到的。也不少文章会将分割技术作为抠图的第一步融入进去。

抠图技术早期应用

早期这项技术主要被用在电影工业中，所以这是一项古老的技术，只是现在依然在不断发展进步。你有时会看到拍电影的摄影棚都是全绿色背景，以及一群穿着全绿色衣服的工作人员。这些都会在后期的抠图技术下被抠掉换上“真正的”背景，这用的就是最原始的蓝屏抠图技术，即背景是纯色时用的抠图技术，纯色的背景可以确保前景被准确抠出。

不过纯色背景的情况在现实中太少，应用面狭窄，抠图技术重点在背景是自然图像的复杂图片。

复杂图片的image matting

在复杂图片的Image Matting课题上，主要包括经典的传统方法和近年来兴起的深度学习方法。

在传统方法部分，有比较典型的三种经典算法：

Bayesian Matting（贝叶斯抠图）

Closed Form Mating（闭型抠图）

KNN Matting（K近邻抠图）

而在深度学习方面的主要有

Deep Image Matting

AlphaGAN Matting

抠图界的上帝公式

图像或视频中的前景准确估计问题，在实际应用中具有十分重要的意义。它是图像编辑和电影制作中的一项关键技术。虽然这项古老的技术发展至今已经数十年了，但几乎所有的解决方案都是在想办法做成一件事情，把这个公式“C = αF + (1-α)B”给解出来，这个公式就是1996年Alvy Ray Smith等人的《Blue Screen Matting》的paper中正式定义的Image Matting问题提出的，可以把它称为抠图界的“上帝公式”。

其中C是原始图像的像素（例如下面的左图就是一张待处理的图像），为已知量；α是透明度，F是前景像素（例如图中的人物），B是背景像素（例如图中的树丛），这三个变量为未知量。

对于这个公式的理解，我们可以把原始图像看做是前景和背景按照一定权重（α透明度）叠加组成的。对于完全确定是前景的像素，α = 1;对于完全确定是背景的像素，α=0; 但问题是我们不能100%确定每个像素它是否是属于前景或是背景，如果一个像素一个像素分析后你也确实可以确定哪个属于前景，哪个属于背景，但这时图也已经抠好了，计算机就没用了，这里也就引出了抠图技术真正需要计算机出马的部分了，就是处理在图像中那些人工不是那么容易辨认是前景还是背景的细节部分。不容易确定的部分则为未知区域由计算机处理。对于不确定是前景还是背景的像素，a是介于0到1之间的浮点数。 Image Matting问题研究的是，如何通过C，推测出未知的三个变量α、F和B，难度可想而知。

获取到每个像素的α值后就可以生成一张α图，这张图看起来是只有前景是白的，其余都是黑的，这就像是我们都曾见过的在艺术创作中使用的蒙版（matte），只把前景露出来，其他背景被挡住。它和原图结合后就完成了抠图的工作了。之后只要继续按照上帝公式就可将抠出的前景移到新的背景中了。读入一张新的背景图片（如下图中间所示），并将前景（经由α 矩阵）融合到新的背景中，最终结果如上图右所示。

问题是一个等式解不出三个变量啊？

1996年Alvy Ray Smith等人的《Blue Screen Matting》给出了Triangulation Matting的方法，整体思想是：既然Image Matting原问题那么难，不如把条件放松，使得问题简单一些，假设我知道了 B和 C，那么有没有可能得到 α 和 F，于是作者提出针对同一张前景，切换背景，来应用最小二乘法，计算得到对应的透明度和前景。

2004年Jian Sun等人的《Poisson matting》开始在Image Matting课题上提出使用Trimap作为辅助工具。Trimap分为三种颜色，黑色代表完全背景（此处 α为0），白色代表完全前景（此处 α 为1），灰色代表不确定区域（ α为0.5），所以说trimap图就是包含前景、背景和未知区域的图。因为前面提到过由于方程是病态的，所以要有约束条件才有解，而Trimap就相当于约束条件，并且简化计算。自此，Image Matting变为下图所示过程：

基本上所有在文献中的抠图算法都是在教计算机如何更准确更快地通过用户指定的前景和背景估计出未知区域的α、B、F，而用户指定的方式一般分为两种，一种是这种提到的信息量很大的trimap图，另一种则是信息量具少的草图（scribbles）。然而trimap图的构建是很麻烦的，用户需要几乎把整张图都涂满才行，而草图就方便很多，只要在前景和背景处画几笔即可。所以对草图的处理才是未来抠图技术的发展趋势。

近年来，随着深度学习技术的发展，使得Deep Learning在计算机视觉领域的应用变得越来越广泛。主要介绍2017年CVPR的Deep Image Matting和AlphaGAN。

Deep Image Matting

这个网络基于典型的Encoder-Decoder结构，做深度学习的应该比较熟悉这种结构在图像分割和以图得图的GAN（生成对抗网络）网络中最常见。Encoder用pre-trained的VGG16，把fc6从全连接换成了卷积，并在输入增加了第四通道channel4，用来存放输入的trimap，因为channel4而增加的weights全部初始化为0。Decoder用简单的unpooling（上池化）和convolution的组合来做upsampling（上采样）和空间结构推断。右边的refine network是为了解决第一阶段预测输出边缘blur（模糊）的情况。

值得一提的是这篇文章提出了两种Loss，这两种Loss分别是Alpha-prediction Loss和Compositional Loss。

Alpha-prediction Loss即Ground Truth α值和预测每个像素α 值之间的绝对差异。

Compositional Loss，即Ground Truth 前景、背景和预测alpha matting组成的预测RGB图片与Ground Truth RGB图片之间的绝对差异。

而神经网络训练的Loss是由两种Loss加权，翻

在实验中作者设置 ω l = 0.5 ，即两种Loss的贡献一样。

AlphaGAN

基于前面Deep Image Matting的启发，我们知道Image Matting这个任务本质上是一个以图得图的任务，而处理这种任务最常见的就是图像分割和GAN（生成对抗网络）。这里我们选择接着探究GAN网络在Image Matting问题上的应用。

（生成对抗网络GAN由生成网络G(Generator)和判别网络D(Discriminator)组成。在训练过程中，生成网络G的目标是尽量生成真实的图片去欺骗判别网络D。而D的目标是尽量把G生成的图片和真实的图片区分开来。这样G和D构成了一个动态的“零和博弈”。GAN就是通过Generator和discriminator进行零和博弈，来不断生成，不断欺骗来获得更好的效果。）

2018年BMVC有一篇论文：AlphaGAN。这篇文章是基于前面的Deep Image Matting做的。AlphaGAN matting 很大程度上借鉴了Deep Image matting。

AlphaGAN matting 将Deep Image matting中的深度网络拿来作为了GAN的generator，改进只是只是把encoder中的VGG16换成了ResNet50，并把少部分卷积层替换，采用的损失函数和上面提到的loss一致。AlphaGAN matting 的discriminator采用PatchGAN，也是以图得图问题中比较先进且常用的discriminator （鉴别器）。PatchGAN对图片中每个N×N的小块(Patch)计算概率，然后将这些概率求平均值作为整体的输出，这样做可以加快速度以及加快收敛。

结合显著性检测自动生成Trimap

到目前为止，大家都能看出来Image Matting最大的弊端：给定一张图，需要一张手工标记的trimap才能开始Image Matting。

手动生成trimap

前面提到的Image Matting方法都需要手工标注的Trimap才可以进行抠图。而这些trimap大多依赖手工标记生成，如利用Photoshop （PS）等，但这些专业的图像操作软件对于普通人利用起来并非易事。于是网上也有封装好的Robust Matting程序来协助我们手工标记来生成trimap。

下面我们讨论怎样让trimap的生成变得更加智能。

自动生成trimap

我们想到用显著图（saliency map）结合一些图像处理方法来实现从原始图片到trimap，再从trimap到图。从而实现只需要给定一张原始图片，就可以输出抠完图的结果。

算法流程：

1利用目前比较先进的显著物体检测算法（salient object detection）来得到显著图。

2对显著图进行阈值分割，粗略地划分前景区域和背景区域。

3对得到的二值图分别进行一次腐蚀和一次膨胀操作。

4两次操作的差记为未知区域。

5由前景区域、背景区域、未知区域生成trimap。

实验结果

在对标准数据集的图片进行测试后，我们采用自己找来的图片来提取trimap后利用之前提到的四种方法进行抠图，实验效果如下图所示，相关结果也比较优秀。

最后是我们提出的利用显著性检测来实现对一些图片生成trimap的结果展示，可以看出在一些显著性比较明显的图片上，trimap生成也还不错：

贝叶斯抠图

引言

这里要讲的paper是2001年CVPR上的文献：《A Bayesian Approach to Digital Matting》。

先看一下文献的抠图效果：

感觉很牛的样子，连头发都可以进行抠，然而其实这个算法的计算效率挺低的，到了后面你了解了这个算法，你就会知道速度有多么慢了。

贝叶斯抠图算法

在融合方程中，已知的只有C，而F、B和α 都是未知的。于是可以从条件概率的角度去考虑这个问题，即给定C时，F、B和α的联合概率应为

其中第一个等号是根据贝叶斯公式得到的，第二个等号则是考虑F、B和α 是彼此独立的。

上式表明Matting问题可以被转化为已知待计算像素颜色C的情况下，如何估计它的F、B和α 的值以最大化后验概率P ( F , B , α ∣ C )的问题，即MAP问题。

上述等式中的右端项，需要通过采样统计的方式进行估计，而这种估计结果的准确性，很大程度上决定了算法的融合质量。具体来说，算法会采用一个连续滑动的窗口对邻域进行采样，窗口从未知区域和己知区域之间的两条边开始向内逐轮廓推进，计算过程也随之推进。下图左显示了Bayesian Matting方法的采样过程。

这篇paper中将采样窗口定义为一个以待计算点为中心，半径r的圆域。进行采样时，不但要对已知区域进行采样，同时为了在待计算像素周围保持一个连续的α分布，也要对之前计算出的邻域像素点进行采样。需要说明的是，采样窗口必须覆盖己知的前景和背景区域。这是因为用户提供的Trimap不能保证一定是足够精致的，换句话说，未知区域覆盖的像素有很多是纯粹的前景或背景，而非混合像素。如果采样半径内不能保证有己知区域内的像素采样，就有可能造成无法采样到前景或背景色。

算法的核心假设是在前景和背景的交界区域附近，其各自的颜色分布在局部应该是基本一致的。算法的目标是通过上面给出的采样统计结果，在未知区域的每一个待计算点上重建它的前景和背景颜色概率分布，并根据这种分布恢复出它的前景色F，背景色B和α 值。

跟朴素贝叶斯法中处理情况一致，再利用对数似然L ( · ) ，所以有

使用对数似然的目的在于等价地把乘法转化成加法。因为P（c）是一个常数，所以在考虑最大化问题时可以将其忽略，上图右展示了一个应用这一规则求解最优F、B和α 的过程。我们就是要求解最优的参数：F、B、alpha值，使得上面的式子的概率最大化。

然而贝爷斯为了保证空间的连贯性，就以每个未知像素的N个邻域点，进行聚类，为了简化起见，paper先假设，前景色只有一类，背景色也只有一类，记住这个只是对于一个像素点的N个领域点而言。至于N的值大小，paper选择200，也就是说每个未知的像素选择最近的200个进行相关的高斯建模。也就是说这200个邻域点，聚类模型前景和背景都是单高斯模型，这样我们就可以求得着200个邻域点属于这个高斯模型的概率了。

泊松图像融合

数学可以说是现代数字图像处理技术的一个重要基石，一些效果显著的同时也非常流行的图像处理技术中大量地借鉴和利用了经典数学理论中的一些著名的成果。尽管这些经典数学理论在其原有场景中的意义与其在图像处理技术中的应用二者之间的关系并没有那么明显！

泊松方程（Poisson Equation）在泊松图像编辑（Poisson Image Editing）以及泊松融合（Poisson Matting）中的应用就是一个典型的例子。

左图 这个人物是西莫恩·德尼·泊松（Siméon-Denis Poisson）是十九世纪法国著名数学家，曾经师从拉普拉斯和拉格朗日两位大师学习数学，数学中许多重要的概念（例如泊松分布、泊松积分、泊松方程 … …） 都以他的名字命名。

泊松编辑

经典物理中，引力场和电场都可以导出泊松方程，这里会设计到很多物理知识，下面重点说一下图像的泊松编辑

引力加速度场中的泊松公式中各物理量的关系如左图所示，下面将这其中的概念平行地转移到数字图像中。理解其中的对应关系是非常有意义的。

对于一组数字信号而言，它的能量在时域上主要是指它的振幅。而这种振幅对应到图像中，其实就是指各像素的灰度值。所以一幅图像的势能对应的就是原图像自身。对势能求梯度，可以得到相应的场。在图像处理中，可以利用哈密尔顿算子计算原图像的梯度结果，所以这里的场对应的就是图像梯度（注意这里有一个负号）。同理，利用拉普拉斯算子处理原图像，相应得到的就是密度图像。这些概念的对应关系如上图所示。

泊松方程之于图像处理的一个重要应用就是进行图像合成。图像合成是图像处理的一个基本问题，其通过将源图像中一个物体或者一个区域 （抠图） 嵌入到目标图像生成一个新的图像。

Poisson Image Editing

这就引出来2004年Siggraph的经典paper：《Poisson Image Editing》，在图像融合领域，融合效果最牛逼的paper。开始这个算法前，我需要先讲解一个数学问题：

散度计算

现在假设一幅图像为3*3的单通道灰度图像

我们假设每一点的像素值为V，V(1)表示像素点1的值，那么我们可以定义像素点5的散度的计算公式为：

div(5)=[V(2)+V(4)+V(6)+V(8)]-4*V(5)

说白了就是通过拉普拉斯卷积核，进行卷积，就可以求解散度了。

当然正规的过程应该是先求解像素点5的梯度值，然后在对梯度求导，这样就能得到散度，不过得到的结果其实就是上面的计算公式。

泊松重建

OK，现在如果我给定一张图像，那么是不是可以利用拉普拉卷积核，求解每个点的散度

现在反过来，如果我给定每个像素点的散度，我要你求解每个像素点的值，要怎么求取。这便是泊松方程的灵魂了。为了更好的理解重建过程，我现在假设图像的大小是4*4的16个像素点图片，如下：

ok，假设我给你像素点6、7、10、11的散度值div(6)、div(7)、div(10)、div(11)，那么我们是不是可以列出如下4个方程：

这个时候，如果我们只有四个方程，可是里面有16个像素点，也就是说有16个未知数。因此单单靠上面的4个方程，就想把所有的像素值求解出来是不可能的，这样方程有无数多个解。因此我们需要添加约束方程，这个便是泊松重建方程的约束条件了。假设我们添加边界约束条件，也就是说如果我已经知道了上面那副图像最外围一圈的每个像素点的值u，这样我们就可以得到12个约束方程。即：

上面有12个方程，外加给定的散度4个方程，这样我们有16个方程。这样就可以求解方程组了，这样就能实现通过散度+边界约束条件，实现图像重建。这个便是泊松方程的主要过程

因此泊松融合，说的再简单一点，就是求解方程组：

Ax=b

算法的整个过程在于求解系数稀疏矩阵A、及b。只要A、b求出来了，那么我们就可以求解方程组得到x，而x就是我们得到的融合结果的像素颜色值。

泊松图像编辑的主要思想是，根据原图像的梯度信息以及目标图像的边界信息，利用插值的方法重新构建出和成区域内的图像像素。如图上所示，其中u表示原图像中被合成的部分，V是u的梯度场，S是合并后的图像，Ω是合并后目标图像中被覆盖的区域，∂Ω是其边界。设合并后图像在Ω内的像素值由 f 表示，在外的像素值由 f*表示。
注意到图像合并的要求是使合并后的图像看上去尽量的平滑，没有明显的边界。所以，Ω内的梯度值应当尽可能的小。

最后展示一下这个算法的神器融合效果

实时高分辨率背景抠图

Real-Time High-Resolution Background Matting

CVPR 2021 最佳论文提名

为了使用户更方便地替换背景，研究人员陆续开发了一系列抠图方法。2020年 4 月份，华盛顿大学研究者提出了 background matting 方法，不在绿幕前拍摄也能完美转换视频背景，让整个世界都变成你的绿幕。但是，这项研究无法实现实时运行，只能以低帧率处理低分辨率下（512×512）的背景替换，有很多需要改进的地方。

八个月过去，2021这些研究者推出了 background matting 2.0 版本，并表示这是一种完全自动化、实时运行的高分辨率抠图方法，分别以 30fps 的帧率在 4k（3840×2160）和 60fps 的帧率在 HD（1920×1080）图像上产生非常好结果。

先来看一些效果展示场景：

非常自然流畅的背景替换。

数据集

设计一个对高分辨率人物视频进行实时抠图的神经网络极具挑战性，特别是头发等细粒度细节特别重要的情况。1.0 版本只能以 8fps 的帧率实现 512×512 分辨率下的背景替换。若要在 4K 和 HD 这样的大分辨率图像上训练深度网络，则运行会非常慢，需要的内存也很大。此外，它还需要大量具备高质量前景蒙版（alpha matte）的图像以实现泛化，然而公开可用的数据集也很有限。

为此，他们创建了两个数据集 VideoMatte240K 和 PhotoMatte13K/85，二者均包含高分辨率前景蒙版以及利用色度键软件提取的前景层。研究者首先在这些包含显著多样化人体姿势的较大型前景蒙版数据集上训练网络以学习鲁棒性先验，然后在手动制作的公开可用数据集上继续训练以学习细粒度细节。

模型架构图

此外，为了设计出能够实时处理高分辨率图像的网络，研究者观察发现图像中需要细粒度细化的区域相对很少。所以他们提出了一个 base 网络，用来预测低分辨率下的前景蒙版和前景层，并得到误差预测图（以确定哪些图像区域需要高分辨率细化）。然后 refinement 网络以低分辨率结果和原始图像作为输入，在选定区域生成高分辨率输出。

结果表明，Background Matting 2.0 版本在具有挑战性的真实视频和人物图像场景中取得了 SOTA 的实时背景抠图结果。研究者还将公布 VideoMatte240K 和 PhotoMatte85 数据集以及模型实现代码。

实际使用

研究人员将此方法应用到了 Zoom 视频会议和抠图这两种场景中。

在 Zoom 实现中，研究人员构建了拦截摄像头输入的 Zoom 插件，收集一张无人的背景图，然后执行实时视频抠图和合成，实际效果很好。

此外，研究人员对比了该方法和绿幕色度抠图的效果，发现在光照不均匀的环境下，该方法的效果胜过专为绿幕设计的方法，如下图所示：

“蓝桥杯”练习系统 (lanqiao.cn)

资源限制

​ 内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s

问题描述

　　共有n种图案的印章，每种图案的出现概率相同。小A买了m张印章，求小A集齐n种印章的概率。

输入格式

　　一行两个正整数n和m

输出格式

　　一个实数P表示答案，保留4位小数。

样例输入

​ 2 3

样例输出

​ 0.7500

数据规模和约定

​ 1≤n，m≤20

+++

此题采用动态规划（Dynamic Programming，DP）的方法求解，动态规划的三要素：最优子结构、边界和状态转移函数。

边界 问题最小子子集的解（初始范围）
最优子结构 每个阶段的最优状态可以从之前某个阶段的某个或某些状态直接得到
状态转移函数 从一个阶段向另一个阶段过度的具体形式,描述的是两个相邻子问题之间的关系(递推式)
对于本题，

1

1

深度学习：对于可统计的、但不可推理的（即象限Ⅲ），可通过神经网络这种特定的机器学习方法，达到性能提升的目的

深度学习在本质上，就是层数非常多的人工神经网络，深度学习属于统计学习的范畴，统计机器学习的对象，其实就是数据。

简单来说，深度学习就是一种包含多个隐含层（层数越多即为越深）的多层感知机，深度学习将“特征提取”和“分类”合二为一，即达成所谓的端到端。

深度学习的感性认知

把初恋期当作输入，磨合期当中调参，稳定期当作输出

书画琴棋诗酒花，
当年件件不离他。
而今七事都更变，
柴米油盐酱醋茶。

这首诗说的是在过日子的洗礼中，各种生活琐事的变迁，恋爱是过日子的一部分，双方需要不断磨合。

调参：磨合。磨合中的权重取舍，就相当于深度学习中隐含层的参数调整

深度学习发展简史

无法承受参数之重的全连接前馈网络

1968年，大卫·休伯尔在实验中发现两个有趣的现象

1. 神经元局部感知

2. 动物大脑皮层是分级、分层处理信息的

它对人工智能的启发意义在于：

1. 不必考虑使用神经元的”全连接“模式
2. 神经网络拟合的复杂函数可分级、分层次来完成

1980年，日本学者福岛邦彦：神经认知机，是一个使用无监督学习训练的神经网络模型，也是卷积神经网络的雏形

1989年，Yann LeCun：利用BP算法重大改进 卷积神经网络

LeCun把自己研究的网络命名为LeNet，主要用于字符识别

20世纪90年代，俄罗斯统计学家V.Vapnik提出支持向量机（SVM）

2006年，深度学习的开山之作

两个重要结论：

1. 多层的神经网络具有优秀的特征学习能力，能够学习到数据更本质的特征
2. 多层神经网络的初始化参数可通过逐层预训练获得

卷积神经网络

所谓卷积是指一个函数和另一个函数在某个维度上的“叠加累计”作用。

深度学习”层“的内涵

深度学习中的所谓“层”：就是对数据实施某种加工的过程。我们可以把神经网络层理解为数据过滤器。数据从输入端进来，经过转换，以另一种更有用的模式出去，这个过程叫做数据蒸馏（data distillation）

图像处理中的卷积

计算机看到的是数字矩阵

卷积运算

1D卷积运算

二维图像数据的卷积

3D卷积运算

卷积在传统图像处理中的应用

用python实现对图像的卷积(滤波)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import matplotlib.pyplot as plt
import pylab
import cv2
import numpy as np

img = plt.imread("dog.jpg")                        #在这里读取图片

plt.imshow(img)                                     #显示读取的图片
pylab.show()

fil = np.array([[ -1,-1, 0],                        #这个是设置的滤波，也就是卷积核
                [ -1, 0, 1],
                [  0, 1, 1]])

res = cv2.filter2D(img,-1,fil)                      #使用opencv的卷积函数

plt.imshow(res)                                     #显示卷积后的图片
# plt.imsave("dog.jpg",res)
pylab.show()

卷积神经网络的结构

卷积层

卷积的目的：作为特征提取器

用卷积来代替全连接

卷积层是构建卷积神经网络的核心层，它产生了网络中大部分的计算量。注意是计算量而不是参数量。

卷积层的作用：

1. 滤波器的作用或者说是卷积的作用。卷积层的参数是有一些可学习的滤波器集合构成的。每个滤波器在空间上（宽度和高度）都比较小，但是深度和输入数据一致。直观地来说，网络会让滤波器学习到当它看到某些类型的视觉特征时就激活，具体的视觉特征可能是某些方位上的边界，或者在第一层上某些颜色的斑点，甚至可以是网络更高层上的蜂巢状或者车轮状图案。

2. 可以被看做是神经元的一个输出。神经元只观察输入数据中的一小部分，并且和空间上左右两边的所有神经元共享参数（因为这些数字都是使用同一个滤波器得到的结果）。

3. 降低参数的数量。这个由于卷积具有“权值共享”这样的特性，可以降低参数数量，达到降低计算开销，防止由于参数过多而造成过拟合。

感受野（重点理解）:

在处理图像这样的高维度输入时，让每个神经元都与前一层中的所有神经元进行全连接是不现实的。相反，我们让每个神经元只与输入数据的一个局部区域连接。该连接的空间大小叫做神经元的感受野（receptive field），它的尺寸是一个超参数（其实就是滤波器的空间尺寸）。在深度方向上，这个连接的大小总是和输入量的深度相等。需要再次强调的是，我们对待空间维度（宽和高）与深度维度是不同的：连接在空间（宽高）上是局部的，但是在深度上总是和输入数据的深度一致，这一点会在下面举例具体说明。

在图 2 中展现的卷积神经网络的一部分，其中的红色为输入数据，假设输入数据体尺寸为[32x32x3]（比如CIFAR-10的RGB图像），如果感受野（或滤波器尺寸）是5x5，那么卷积层中的每个神经元会有输入数据体中[5x5x3]区域的权重，共5x5x3=75个权重（还要加一个偏差参数）。注意这个连接在深度维度上的大小必须为3，和输入数据体的深度一致。其中还有一点需要注意，对应一个感受野有75个权重，这75个权重是通过学习进行更新的，所以很大程度上这些权值之间是不相等（也就对于同一个卷积核，它对于与它连接的输入的每一层的权重都是独特的，不是同样的权重重复输入层层数那么多次就可以的）。在这里相当于前面的每一个层对应一个传统意义上的卷积模板，每一层与自己卷积模板做完卷积之后，再将各个层的结果加起来，再加上偏置，注意是一个偏置，无论输入输入数据是多少层，一个卷积核就对应一个偏置。

激活层

激活层：非线性变换 –> 提升神经网络的表达能力

池化层

通常在连续的卷积层之间会周期性地插入一个池化层。它的作用是逐渐降低数据体的空间尺寸，这样的话就能减少网络中参数的数量，使得计算资源耗费变少，也能有效控制过拟合。

池化带来的好处：平移不变性（Invariance）

全连接层

全连接层:为分类服务

CNN的反向传播（BP）过程：

神经网络的过拟合

过拟合是指，模型过于表征训练数据，导致在其他数据集上表现下降

基于卷积神经网络的手写数字识别

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue May 12 12:56:10 2020
参考代码：https://www.tensorflow.org/tutorials/quickstart/advanced
"""
# （1）读入数据
import os
import tensorflow as tf
import keras as K
# mnist = tf.keras.datasets.mnist
class DataSource():
    def __init__(self):
        # mnist数据集存储的位置，如何不存在将自动下载
        data_path = os.path.abspath(os.path.dirname(__file__)) + '/data/mnist.npz'
        # (x_train, y_train), (x_test, y_test) = datasets.mnist.load_data(path=data_path)
        (x_train, y_train), (x_test, y_test) = K.datasets.mnist.load_data()
        # 6万张训练图片，1万张测试图片
        #        train_images = train_images.reshape((60000, 28, 28, 1))
        #        test_images = test_images.reshape((10000, 28, 28, 1))
        x_train = x_train[..., tf.newaxis]
        x_test = x_test[..., tf.newaxis]
        # 像素值映射到 0 - 1 之间
        x_train, x_test = x_train / 255.0, x_test / 255.0

        self.train_images, self.train_labels = x_train, y_train
        self.test_images, self.test_labels = x_test, y_test

data = DataSource()

# (2)搭建模型
import tensorflow as tf
# from tensorflow.keras import datasets, layers, models
from tensorflow.python.keras import layers, models

class CNN():
    def __init__(self):
        model = models.Sequential()
        # 第1层卷积，卷积核大小为3*3，32个，28*28为待训练图片的大小
        model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
        model.add(layers.MaxPooling2D((2, 2)))
        # 第2层卷积，卷积核大小为3*3，64个
        model.add(layers.Conv2D(64, (3, 3), activation='relu'))
        model.add(layers.MaxPooling2D((2, 2)))
        # 第3层卷积，卷积核大小为3*3，64个 
        model.add(layers.Conv2D(64, (3, 3), activation='relu'))
        # 增加一个平坦层，拉平数据
        model.add(layers.Flatten())
        model.add(layers.Dense(64, activation='relu'))
        model.add(layers.Dense(10, activation='softmax'))

        model.summary()

        self.model = model

cnn = CNN()

参考资料

人工智能极简入门-张玉宏 第七章

图像处理中滤波器(卷积核) - Liu_xiang - 博客园 (cnblogs.com)

用python实现对图像的卷积(滤波) - swuxyj - 博客园 (cnblogs.com)

卷积神经网络（CNN）详解 - 知乎 (zhihu.com)

1
2

a, b = input().split(" ")
print(int(a)+int(b))

BASIC-13 数列排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

问题描述

　　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

输入格式

　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。

输出格式

　　输出一行，按从小到大的顺序输出排序后的数列。

样例输入

5
8 3 6 4 9

样例输出

3 4 6 8 9

1
2
3
4

n = int(input())
s = sorted(list(map(int, input().split())))
for i in s:
    print(i, ' ', end="")

BASIC-12 十六进制转八进制

问题描述
　　给定n个十六进制正整数，输出它们对应的八进制数。

输入格式
　　输入的第一行为一个正整数n （1<=n<=10）。
　　接下来n行，每行一个由09、大写字母AF组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。

输出格式
　　输出n行，每行为输入对应的八进制正整数。

　　【注意】
　　输入的十六进制数不会有前导0，比如012A。
　　输出的八进制数也不能有前导0。

样例输入
　　2
　　39
　　123ABC

样例输出
　　71
　　4435274

提示
　　先将十六进制数转换成某进制数，再由某进制数转换成八进制。

1
2
3
4
5

n = int(input())
for i in range(n):
    a = input()
    result = int(a, base=16)  # int 十六进制转换为十进制
    print(oct(result)[2:])  # oct 十进制转换为八进制

BASIC-11 十六进制转十进制

1
2
3

a = input()
result = int(a, base=16)
print(result)

BASIC-10 十进制转十六进制

1
2
3

a = int(input())
result = hex(a)[2:]
print(result.upper())

BASIC-9 特殊回文数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

问题描述

　　123321是一个非常特殊的数，它从左边读和从右边读是一样的。
　　输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。

输入格式

　　输入一行，包含一个正整数n。

输出格式

　　按从小到大的顺序输出满足条件的整数，每个整数占一行。

样例输入

52

样例输出

899998
989989
998899

数据规模和约定

　　1<=n<=54。

1
2
3
4
5

n = int(input())
for i in range(10000, 1000000):  # 1000000
    i = str(i)
    if i[::-1] == i and sum(int(j) for j in i) == n:
        print(i)

字符串逆置 str[::-1]

求一个整数各位之和 sum(int(i) for i in str(num))

注意 n=input()输入的是字符串类型，要转换成int

BASIC-8 回文数

问题描述

　　1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。

输出格式

　　按从小到大的顺序输出满足条件的四位十进制数。

1
2
3
4

for i in range(1000, 10000):
    i = str(i)
    if i[::-1] == i:
        print(i)

BASIC-7 特殊的数字

问题描述

　　153是一个非常特殊的数，它等于它的每位数字的立方和，即153=111+555+333。编程求所有满足这种条件的三位十进制数。

输出格式

　　按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。

1
2
3
4

for num in range(100, 1000):
    p_num = pow(int(str(num)[:1]), 3) + pow(int(str(num)[1:2]), 3) + pow(int(str(num)[2:3]), 3)
    if num == int(p_num):
        print(num)

BASIC-6 杨辉三角形

问题描述

杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。

它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。

下面给出了杨辉三角形的前4行：

1

1 1

1 2 1

1 3 3 1

给出n，输出它的前n行。

输入格式

输入包含一个数n。

输出格式

输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。

样例输入

4

样例输出

1
1 1
1 2 1
1 3 3 1

数据规模与约定

1 <= n <= 34。

首先初步创建一个n*n的二维列表矩阵，内容初步使用for循环填充，便于接下来的数据调整。根据杨辉三角基本性质，先将主对角线以上部分填充0，然后将第一列及主对角线填充为1，剩余部分根据性质计算得pascallist[i][j] = pascallist[i - 1][j - 1] + pascallist[i - 1][j]，即该数据等于对应左上方和正上方值之和。去零输出，当数据为零时，continue直接进入下一次循环，并按照题目格式输出矩阵。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

num = int(input())
pl = [[i for i in range(num)] for i in range(num)]
for i in range(num):
    for j in range(num):
        if j > i:
            pl[i][j] = 0
        elif i == j:
            pl[i][j] = 1
        elif j == 0:
            pl[i][j] = 1
        else:
            pl[i][j] = pl[i - 1][j - 1] + pl[i - 1][j]
for i in range(num):
    for j in range(num):
        if pl[i][j] == 0:
            continue
        else:
            print(pl[i][j], end=" ")
    print("")

BASIC-5 查找整数

问题描述

给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。

输入格式

第一行包含一个整数n。

第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。

第三行包含一个整数a，为待查找的数。

输出格式

如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。

样例输入

6
1 9 4 8 3 9
9

样例输出

2

数据规模与约定

1 <= n <= 1000。

1
2
3
4
5
6
7
8
9
10
11

n = int(input())
num = list(input().split(" "))
a = int(input())
flag = 0
for i in range(n):
    if a == int(num[i]):
        print(i+1)
        flag = 1
        break
if flag == 0:
    print(-1)

BASIC-4 数列特征

问题描述

给出n个数，找出这n个数的最大值，最小值，和。

输入格式

第一行为整数n，表示数的个数。

第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。

输出格式

输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。

样例输入

5
1 3 -2 4 5

样例输出

5
-2
11

数据规模与约定

1 <= n <= 10000。

1
2
3
4
5

n = int(input())
num = list(map(int, input().split()))
print(max(num))
print(min(num))
print(sum(num))

BASIC-3 字母图形

问题描述

利用字母可以组成一些美丽的图形，下面给出了一个例子：

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。

输入格式

输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。

输出格式

输出n行，每行m个字符，为你的图形。

样例输入

5 7

样例输出

ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC

数据规模与约定

1 <= n, m <= 26。

参考了BASIC-6杨辉三角形的解题方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

num = list(map(int, input().split()))
n, m = num
a = [[i for i in range(m)] for i in range(n)]
t = b =65
for i in range(n):
    for j in range(m):
        if i == 0:
            a[i][j] = chr(t)
            t = t + 1
        elif j == 0:
            b = b + 1
            a[i][j] = chr(b)
        else:
            a[i][j] = a[i-1][j-1]

for i in range(n):
    for j in range(m):
        print(a[i][j], end="")
    print("")

法二：

1
2
3
4
5
6
7
8
9

try:
    n, m = map(int, input().split())
    letter = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
    x = letter[:m]
    for i in range(1, n+1):
        print(x)
        x = letter[i] + x[0:-1]
except:
    pass

注意：代码的except的设计，实际上是“当索引溢出了，程序还能正常退出”。否则会运行错误

法三：

1
2
3
4
5
6
7

n, m = map(int, input().split())
letter = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(n):
    r = letter[1:i+1]
    f = letter[0:m-i]
    s = r[::-1] + f
    print(s[0:m])

BASAIC-2 01字串

问题描述

对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：

00000

00001

00010

00011

00100

请按从小到大的顺序输出这32种01串。

输入格式

本试题没有输入。

输出格式

输出32行，按从小到大的顺序每行一个长度为5的01串。

样例输出

00000
00001
00010
00011

1
2
3
4

a = "0"
for i in range(32):
    print("%05d" % int(a))
    a = bin(int(a, base=2) + int("1", base=2))[2:]

法二：

1
2

for i in range(32):
    print('{:05b}'.format(i))

:b 代表二进制

BASIC-1 闰年判断

问题描述

给定一个年份，判断这一年是不是闰年。

当以下情况之一满足时，这一年是闰年：

1. 年份是4的倍数而不是100的倍数；

2. 年份是400的倍数。

其他的年份都不是闰年。

输入格式

输入包含一个整数y，表示当前的年份。

输出格式

输出一行，如果给定的年份是闰年，则输出yes，否则输出no。

样例输入

2013

样例输出

no

样例输入

2016

样例输出

yes

数据规模与约定

1990 <= y <= 2050。

1
2
3
4
5

year = int(input())
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
    print("yes")
else:
    print("no")

BASIC-04 Fibonacci数列

问题描述

Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。

当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。

输入格式

输入包含一个整数n。

输出格式

输出一行，包含一个整数，表示Fn除以10007的余数。

说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。

样例输入

10

样例输出

55

样例输入

22

样例输出

7704

数据规模与约定

1 <= n <= 1,000,000。

1
2
3
4
5
6
7
8

n = int(input())
sum = 1
b = 1
for i in range(3, n+1):
    t = sum
    sum = (sum + b) % 10007
    b = t
print(sum%10007)

法二：

1
2
3
4
5
6
7

n = int(input())
def fibo(n):
    a, b = 1, 1
    for i in range(2, n+1):
        a, b = b, (a+b)%10007
    return a
print(fibo(n))

BASIC-03 圆的面积

问题描述

给定圆的半径r，求圆的面积。

输入格式

输入包含一个整数r，表示圆的半径。

输出格式

输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。

说明：在本题中，输入是一个整数，但是输出是一个实数。

对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。

实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。

样例输入

4

样例输出

50.2654825

数据规模与约定

1 <= r <= 10000。

提示

本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。

1
2
3
4
5

import math

r = int(input())
s = math.pi * r * r
print("%.7f" % s)

BASIC-02 序列求和

资源限制

时间限制：1.0s 内存限制：256.0MB

问题描述

求1+2+3+…+n的值。

输入格式

输入包括一个整数n。

输出格式

输出一行，包括一个整数，表示1+2+3+…+n的值。

样例输入

4

样例输出

10

样例输入

100

样例输出

5050

数据规模与约定

1 <= n <= 1,000,000,000。

说明：请注意这里的数据规模。

本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。

本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。

如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。

下面的代码会运行超时：

1
2
3
4
5

n = int(input())
sum = 0
for i in range(n+1):
    sum = sum + i
print(sum)

直接用求和公式：

1
2

n = int(input())
print(n*(n+1)//2)

两个斜杠即双斜杠（//）表示地板除，即先做除法（/）

著名学者赫伯特·西蒙教授（Herbert Simon，1975年图灵奖获得者、1978年诺贝尔经济学奖获得者）曾对“学习”给了一个定义：“如果一个系统，能够通过执行某个过程，就此改进了它的性能，那么这个过程就是学习”。
大牛就是大牛，永远都是那么言简意赅，一针见血。从西蒙教授的观点可以看出，学习的核心目的，就是改善性能。

其实对于人而言，这个定义也是适用的。比如，我们现在正在学习“机器学习”的知识，其本质目的就是为了“提升”自己在机器学习上的认知水平。如果我们仅仅是低层次的重复性学习，而没有达到认知升级的目的，那么即使表面看起来非常勤奋，其实我们也仅仅是个“伪学习者”, 因为我们没有改善性能。

按照这个解释，那句著名的口号“好好学习，天天向上”，就会焕发新的含义:如果没有性 能上的“向上”，即使非常辛苦地“好好”，即使长时间地“天天”，都无法算作“学习”。

什么是机器学习？

赫伯特·西蒙认为Machine learning is the ability to “learn” (i.e., progressively improve performance on a specific task) with data, without being explicitly programmed

英雄所见略同。卡内基梅隆大学的Tom Mitchell教授，在他的名作《机器学习》一书中，也给出了更为具体（其实也很抽象）的定义：对于某类任务（Task，简称T）和某项性能评价准则（Performance，简称P），如果一个计算机程序在T上，以P作为性能的度量，随着很多经验（Experience，简称E）不断自我完善，那么我们称这个计算机程序在从经验E中学习了。

比如说，对于学习围棋的程序AlphaGo，它可以通过和自己下棋获取经验，那么它的任务T就是“参与围棋对弈”；它的性能P就是用“赢得比赛的百分比”来度量。“类似地，学生的任务T就是“上课看书写作业”；它的性能P就是用“期末成绩”来度量”

在前面的文章中已提到，一般说来，人类的知识在两个维度上可分成四类，见上图。即从可统计与否上来看，可分为：是可统计的和不可统计的。从能否推理上看，可分为可推理的和不可推理的。

在横向方向上，对于可推理的，我们都可以通过机器学习的方法，最终可以完成这个推理。传统的机器学习方法，就是试图找到可举一反三的方法，向可推理但不可统计的象限进发（象限Ⅱ）。目前看来，这个象限的研究工作（即基于推理的机器学习）陷入了不温不火的境地，能不能峰回路转，还有待时间的检验。

而在纵向上，对于可统计的、但不可推理的（即象限Ⅲ），可通过神经网络这种特定的机器学习方法，以期望达到性能提升的目的。目前，基于深度学习的棋类博弈（阿尔法狗）、计算机视觉（猫狗识别）、自动驾驶等等，其实都是在这个象限做出了了不起的成就。
从图1可知，深度学习属于统计学习的范畴。用李航博士的话来说，统计机器学习的对象，其实就是数据[3]。这是因为，对于计算机系统而言，所有的“经验”都是以数据的形式存在的。作为学习的对象，数据的类型是多样的，可以是各种数字、文字、图像、音频、视频，也可以是它们的各种组合。

统计机器学习，就是从数据出发，提取数据的特征（由谁来提取，是个大是大非问题，下面将给予介绍），抽象出数据的模型，发现数据中的知识，最后又回到数据的分析与预测当中去。

我们今天所有的软件系统，大部分都是人造的长颈鹿，没有学习能力，它所有的能力都是天生给它的，就是人给它的知识，我们都写在了软件代码里面了。沒有學習能力，看再多世界也沒用

机器学习近似于找一个好用的函数

机器学习的核心特征就是–“从数据中学习，获得性能提升“

为什么机器学习不容易

实验：手写体识别

MNIST介绍

MNIST数据集分为训练图像和测试图像。训练图像60000张，测试图像10000张，每一个图片代表0-9中的一个数字，且图片大小均为28*28的矩阵。

train-images-idx3-ubyte.gz: training set images (9912422 bytes) 训练图片

train-labels-idx1-ubyte.gz: training set labels (28881 bytes) 训练标签

t10k-images-idx3-ubyte.gz: test set images (1648877 bytes) 测试图片

t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes) 测试标签

获取MNIST数据的几种方法

方法1
官网下载MNIST数据集的版权在Yann LeCun教授手上，在他的主页下载即可。http://yann.lecun.com/exdb/mnist/下载4个`gz`文件，实际上这也是旧版`TensorFlow`中获取`mnist`的方法。注意，图像数据取值为0到1之间。

方法2
谷歌 https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz 下载1个npz文件，实际上这也是新版TensorFlow中获取mnist的方法。注意，图像数据取值为0到255之间。

方法3
通过TensorFlow获取，提前下载好放在这里就可以避免无法下载的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#tensorflow 1.7以前
#下载好数据集，放到mnist文件夹下，可以避免无法下载的问题，然后指定datapath来读取。
from tensorflow.examples.tutorials.mnist import input_data
datapath = "./mnist/"
mnist = input_data.read_data_sets(datapath, one_hot=True)
train_x = mnist.train.images
train_y = mnist.train.labels
test_x = mnist.test.images
test_y = mnist.text.labels
 
#tensorflow 1.7以后
#下载好数据集mnist.npz，放于~/.keras/datasets/下，可以避免无法下载的问题
import tensorflow as tf 
 
(train_x, train_y), (test_x, test_y) = tf.keras.datasets.mnist.load_data(path='mnist.npz')

方法4

通过Keras获取

1
2
3
4
5

from keras.datasets import mnist
(train_x, train_y), (test_x, test_y) = mnist.load_data()
 
#:\Program Files\Python\Python36-64\Lib\site-packages\keras\datasets
# C:\Users\user_name\.keras\datasets

简单实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# -*- coding: utf-8 -*-
"""
程序运行条件：
（1）安装Python 3.6+
（2）安装Keras（版本不能太高，2.2.5即可）
    在命令行输入：
    pip3 install keras
    或使用conda安装
    conda install keras
"""

import keras as K
import matplotlib.pyplot as plt # 绘图


def draw_digital():
    print("\nBegin show MNIST image \n")

    (train_x, train_y), (test_x, test_y) = K.datasets.mnist.load_data()

    # print(train_x.shape)  # (60000, 28, 28)
    # print(train_y.shape)  # (60000,)

    digital = train_x[0]
    digital = digital.reshape(28, 28)
    for row in range(0, 28):
        for col in range(0, 28):
            print("{0:02X} ".format(digital[row][col]), end="")
        print("")

    label = train_y[0]
    print("\n手写数字：", label)

    plt.imshow(digital, cmap=plt.get_cmap('gray_r'))
    plt.show()


if __name__ == "__main__":
    draw_digital()

机器学习的分类

监督学习

在监督式学习下，输入数据被称为“训练数据”，每组训练数据有一个明确的标识或结果。在建立预测模型的时候，监督式学习建立一个学习过程，将预测结果与“训练数据”的实际结果进行比较，不断的调整预测模型，直到模型的预测结果达到一个预期的准确率。

监督学习（Supervised Learning）:用数据挖掘大家韩家炜（Jiawei Han）老师的观点来说，监督学习基本上就是“分类（classification）”的代名词。它从有标签的训练数据中学习，然后给定某个新数据，预测它的标签（given data, predict labels）。这里的标签（label），其实就是某个事物的分类。

比如说，小时候父母告诉我们某个动物是猫、是狗或是猪，然后我们的大脑里就会形成或猫或狗或猪的印象，然后面前来了一条“新”小狗，如果你能叫出来“这是一条小狗”，那么恭喜你，你的标签分类成功！但如果你说“这是一头小猪”。这时你的监护人就会纠正你的偏差，“乖，不对呦，这是一头小狗”，这样一来二去的训练，就不断更新你的大脑认知体系，聪明如你，下次再遇到这类新的“猫、狗、猪”等，你就会天才般的给出正确“预测”分类。简单来说，监督学习的工作，就是通过有标签的数据训练，获得一个模型，然后通过构建的模型，给新数据添加上特定的标签。

事实上，整个机器学习的目标，都是使学习得到的模型，能很好地适用于“新样本”，而不是仅仅在训练样本上工作得很好。通过训练得到的模型，适用于新样本的能力，称之为“泛化（generalization)能力”。

分类与回归

诗仙李白在《梦游天姥吟留别》中有一句：
云青青兮欲雨

天气状态，无非是诸如“晴天”、“ 阴天”、雨天或“雪天”等，它们有限的几个离散值，非此即彼，这就是一个典型的分类问题。

《秋浦歌》，里面有句：
白发三千丈，缘愁似个长。

把这类输出状态，看做是连续的。而对输出变量是连续的有监督学习，就属于回归分析问题。

监督学习中的损失函数

衡量实际情况与预测之间的差异——损失函数（loss function），包括但不限于：

无监督学习

在非监督式学习中，数据并不被特别标识，学习模型是为了推断出数据的一些内在结构。常见的应用场景包括关联规则的学习以及聚类等。

与监督学习相反的是，非监督学习所处的学习环境，都是非标签的数据。韩老师接着说，非监督学习，本质上，就是“聚类（cluster）”的近义词

简单来说，给定数据，从数据中学，能学到什么，就看数据本身具备什么特性了（given data, learn about that data）。我们常说的“物以类聚，人以群分”说得就是“非监督学习”。这里的“类”也好，“群”也罢，事先我们是不知道的。一旦我们归纳出“类”或“群”的特征，如果再要来一个新数据，我们就根据它距离哪个“类”或“群”较近，就“预测”它属于哪个“类”或“群”，从而完成新数据的“分类”或“分群”功能。

k均值聚类

K均值聚类（k-means) 是基于样本集合划分的聚类算法。K均值聚类将样本集合划分为k个子集，构成k个类，将n个样本分到k个类中，每个样本到其所属类的中心距离最小，每个样本仅属于一个类，这就是k均值聚类，同时根据一个样本仅属于一个类，也表示了k均值聚类是一种硬聚类算法。

算法过程：

输入：n个样本的集合

输出：样本集合的聚类

过程：

（1）初始化。随机选择k的样本作为初始聚类的中心。

（2）对样本进行聚类。针对初始化时选择的聚类中心，计算所有样本到每个中心的距离，默认欧式距离，将每个样本聚集到与其最近的中心的类中，构成聚类结果。

（3）计算聚类后的类中心，计算每个类的质心，即每个类中样本的均值，作为新的类中心。

（4）然后重新执行步骤（2）（3），直到聚类结果不再发生改变。

K均值聚类算法的时间复杂度是O(nmk),n表示样本个数，m表示样本维数，k表示类别个数。

半监督学习

输入数据部分被标识，部分没有被标识

半监督学习就是以“已知之认知（标签化的分类信息）”，扩大“未知之领域（通过聚类思想将未知事物归类为已知事物）”。但这里隐含了一个基本假设——“聚类假设（cluster assumption）”，其核心要义就是：“相似的样本，拥有相似的输出”。

半监督学习（Semi-supervised Learning）：这类学习方式，既用到了标签数据，又用到了非标签数据。有句骂人的话，说某个人“有妈生，没妈教”，抛开这句话骂人的含义，其实它说的是“无监督学习”。但我们绝大多数人，不仅“有妈生，有妈教”，还“有小学教，有中学教，有大学教”，“有人教”，这就是说，有人告诉我们事物的对与错（即对事物打了标签），然后我们可据此改善自己的性情，慢慢把自己调教得更有“教养”，这自然就属于“监督学习”。

但总有那么一天我们要长大。而长大的标志之一，就是自立。何谓“自立”？就是远离父母、走出校园后，没有人告诉你对与错，一切都要基于自己早期已获取的知识为基础，从社会中学习，扩大并更新自己的认知体系，然后遇到新事物时，我们能“泰然自若”处理，而非茫然“六神无主”。

形式化的定义比较抽象，下面我们列举一个现实生活中的例子，来辅助说明这个概念。假设我们已经学习到：
(1) 马晓云同学（数据1）是个牛逼的人（标签：牛逼的人）
(2) 马晓腾同学（数据2）是个牛逼的人（标签：牛逼的人）
(3) 假设我们并不知道李晓宏同学（数据3）是谁，也不知道他牛逼不牛逼，但考虑他经常和二马同学共同出没于高规格大会，都经常会被达官贵人接见（也就是说他们虽独立，但同分布），我们很容易根据“物以类聚，人以群分”的思想，把李晓宏同学打上标签：他也是一个很牛逼的人！

这样一来，我们的已知领域（标签数据）就扩大了（由两个扩大到三个！），这也就完成了半监督学习。事实上，半监督学习就是以“已知之认知（标签化的分类信息）”，扩大“未知之领域（通过聚类思想将未知事物归类为已知事物）”。但这里隐含了一个基本假设——“聚类假设（cluster assumption）”，其核心要义就是：“相似的样本，拥有相似的输出”。

强化学习

强化学习会在没有任何标签的情况下，通过先尝试做出一些行为得到一个结果，通过这个结果是对还是错的反馈，调整之前的行为，就这样不断的调整，算法能够学习到在什么样的情况下选择什么样的行为可以得到最好的结果。

如果把机器学习比作一个蛋糕的话，那么强化学习就好比蛋糕上的樱桃，好看但不过是点缀之物，监督学习就好比蛋糕上面的那层糖衣，美味但份额太少。而无（自）监督学习才是蛋糕的本体。
在这之中，杨立昆把无监督学习的重要性提到非常高的地位，而且为了让强化学习更加奏效，也离不开无监督学习的支持。而目前还不成气候的半监督学习，甚至都不入杨立昆的法眼。

三大类机器学习算法

监督学习：有标签，有”教师“指导的学习，分类问题

无监督学习：无标签，利用距离的”亲疏远近“来衡量不同分组，聚类问题

半监督学习：有部分标签，利用聚类扩大标签。不好研究。。。存在瓶颈

事实上，我们对半监督学习的现实需求，是非常强烈的。其原因很简单，就是因为人们能收集到的标签数据非常有限，而手工标记数据需要耗费大量的人力物力成本，但非标签数据却大量存在且触手可及，这个现象在互联网数据中更为凸显，因此，“半监督学习”就显得尤为重要性。

人类的知识，其实都是这样，以“半监督”的滚雪球的模式，越扩越大。“半监督学习”既用到了“监督学习”，也吸纳了“非监督学习”的优点，二者兼顾。

如此一来，“半监督学习”就有点类似于我们中华文化的“中庸之道”了。

参考资料

人工智能极简入门–张玉宏 第二章

https://www.zhihu.com/people/yulaiyuhong

(55条消息) K均值聚类_Chloe-Hao的博客-CSDN博客_k均值聚类

(55条消息) 【062】MNIST手写体数字识别_小麦粒的Python-CSDN博客

冰墩墩（英文：Bing Dwen Dwen，汉语拼音：bīng dūn dūn），是2022年北京冬季奥运会的吉祥物。 将熊猫形象与富有超能量的冰晶外壳相结合，头部外壳造型取自冰雪运动头盔，装饰彩色光环，整体形象酷似航天员。

2018年8月8日，北京冬奥会和冬残奥会吉祥物全球征集启动仪式举行。2019年9月17日晚，冰墩墩正式亮相 。

冰墩墩寓意创造非凡、探索未来，体现了追求卓越、引领时代，以及面向未来的无限可能。

python turtle绘图

主要用的是 Python 自带的 turtle库

turtle库的基础命令介绍

（1）画布

画布是绘图区域，可以设置它的大小和初始位置

1
2

turtle.screensize(1000,600,'red')    大小的设置
turtle.setup(width=0.5,height=0.75)  初始位置

（2）画笔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

（1）画笔运动的命令
turtle.forward(a)   向当前画笔方向移动a像素长度
turtle.backward(a)  向当前画笔相反方向移动a像素长度
turtle.right(a)     顺时针移动
aturtle.left(a)     逆时针移动
aturtle.pendown()   移动时绘制图形
turtle.goto(x,y)    将画笔移动到坐标为x,y的位置
turtle.penup()      移动时不绘制图形，提起笔
turtle.speed(a)     画笔绘制的速度范围
turtle.circle()     画图，半径为正，表示圆心在画笔的左边画圈

（2）画笔控制命令
turtle.pensize(width)   绘制图形的宽度
turtle.pencolor()       画笔的颜色
turtle.fillcolor(a)     绘制图形的填充颜色
turtle.color(a1,a2)     同时设置pencolor=a1,fillcolor=a2
turtle.filling()        返回当前是否在填充状态
turtle.begin_fill()     准备开始填充图形
turtle.end_fill()       填充完成
turtle.hideturtle()     隐藏箭头显示
turtle.showturtle()     显示箭头

（3）全局控制命令
turtle.clear()   清空turtle窗口,但是turtle的位置和状态不会改变
turtle.reset()   清空窗口，重置turtle状态为起始位置
turtle.undo()    撤销上一个turtle动作

硬“肝”不断调整曲线

turtle绘图小技巧

通过下面这个语句把你要参考的图先绘制在窗口中，然后再对照着进行绘制调整，就方便许多了。

1

turtle.bgpic('bg.png')

实现效果

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369

import turtle

turtle.title('画个冰墩墩--小马')

turtle.speed(10)  # 速度

# 左手
turtle.penup()
turtle.goto(177, 112)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(80)
turtle.circle(-45, 200)
turtle.circle(-300, 23)
turtle.end_fill()

# 左手内
turtle.penup()
turtle.goto(182, 95)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(95)
turtle.pendown()
turtle.circle(-37, 160)
turtle.circle(-20, 50)
turtle.circle(-200, 30)
turtle.end_fill()
# 轮廓
# 头顶
turtle.penup()
turtle.goto(-73, 230)
turtle.pencolor("lightgray")
turtle.pensize(3)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(20)
turtle.circle(-250, 35)
# 左耳
turtle.setheading(50)
turtle.circle(-42, 180)
# 左侧
turtle.setheading(-50)
turtle.circle(-190, 30)
turtle.circle(-320, 45)
# 左腿
turtle.circle(120, 30)
turtle.circle(200, 12)
turtle.circle(-18, 85)
turtle.circle(-180, 23)
turtle.circle(-20, 110)
turtle.circle(15, 115)
turtle.circle(100, 12)
# 右腿
turtle.circle(15, 120)
turtle.circle(-15, 110)
turtle.circle(-150, 30)
turtle.circle(-15, 70)
turtle.circle(-150, 10)
turtle.circle(200, 35)
turtle.circle(-150, 20)
# 右手
turtle.setheading(-120)
turtle.circle(50, 30)
turtle.circle(-35, 200)
turtle.circle(-300, 23)
# 右侧
turtle.setheading(86)
turtle.circle(-300, 26)
# 右耳
turtle.setheading(122)
turtle.circle(-53, 160)
turtle.end_fill()

# 右耳内
turtle.penup()
turtle.goto(-130, 180)
turtle.pencolor("black")
turtle.pensize(1)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-28, 160)
turtle.setheading(210)
turtle.circle(150, 20)
turtle.end_fill()

# 左耳内
turtle.penup()
turtle.goto(90, 230)
turtle.setheading(40)
turtle.begin_fill()
turtle.pendown()
turtle.circle(-30, 170)
turtle.setheading(125)
turtle.circle(150, 23)
turtle.end_fill()

# 右手内
turtle.penup()
turtle.goto(-180, -55)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.setheading(-120)
turtle.pendown()
turtle.circle(50, 30)
turtle.circle(-27, 200)
turtle.circle(-300, 20)
turtle.setheading(-90)
turtle.circle(300, 14)
turtle.end_fill()

# 左腿内
turtle.penup()
turtle.goto(108, -168)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-115)
turtle.circle(110, 15)
turtle.circle(200, 10)
turtle.circle(-18, 80)
turtle.circle(-180, 13)
turtle.circle(-20, 90)
turtle.circle(15, 60)
turtle.setheading(42)
turtle.circle(-200, 29)
turtle.end_fill()
# 右腿内
turtle.penup()
turtle.goto(-38, -210)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(-155)
turtle.circle(15, 100)
turtle.circle(-10, 110)
turtle.circle(-100, 30)
turtle.circle(-15, 65)
turtle.circle(-100, 10)
turtle.circle(200, 15)
turtle.setheading(-14)
turtle.circle(-200, 27)
turtle.end_fill()

# 右眼
# 眼圈
turtle.penup()
turtle.goto(-64, 120)
turtle.begin_fill()
turtle.pendown()
turtle.setheading(40)
turtle.circle(-35, 152)
turtle.circle(-100, 50)
turtle.circle(-35, 130)
turtle.circle(-100, 50)
turtle.end_fill()
# 眼珠
turtle.penup()
turtle.goto(-47, 55)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(25, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 62)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-45, 68)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(-47, 86)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 左眼
# 眼圈
turtle.penup()
turtle.goto(51, 82)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(120)
turtle.circle(-32, 152)
turtle.circle(-100, 55)
turtle.circle(-25, 120)
turtle.circle(-120, 45)
turtle.end_fill()
# 眼珠
turtle.penup()
turtle.goto(79, 60)
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(24, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 64)
turtle.pencolor("darkslategray")
turtle.fillcolor("darkslategray")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(19, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 70)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(10, 360)
turtle.end_fill()
turtle.penup()
turtle.goto(79, 88)
turtle.pencolor("white")
turtle.fillcolor("white")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(0)
turtle.circle(5, 360)
turtle.end_fill()

# 鼻子
turtle.penup()
turtle.goto(37, 80)
turtle.fillcolor("black")
turtle.begin_fill()
turtle.pendown()
turtle.circle(-8, 130)
turtle.circle(-22, 100)
turtle.circle(-8, 130)
turtle.end_fill()

# 嘴
turtle.penup()
turtle.goto(-15, 48)
turtle.setheading(-36)
turtle.begin_fill()
turtle.pendown()
turtle.circle(60, 70)
turtle.setheading(-132)
turtle.circle(-45, 100)
turtle.end_fill()

# 彩虹圈
turtle.penup()
turtle.goto(-135, 120)
turtle.pensize(5)
turtle.pencolor("cyan")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-165, 150)
turtle.circle(-130, 78)
turtle.circle(-250, 30)
turtle.circle(-138, 105)
turtle.penup()
turtle.goto(-131, 116)
turtle.pencolor("slateblue")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-160, 144)
turtle.circle(-120, 78)
turtle.circle(-242, 30)
turtle.circle(-135, 105)
turtle.penup()
turtle.goto(-127, 112)
turtle.pencolor("orangered")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-155, 136)
turtle.circle(-116, 86)
turtle.circle(-220, 30)
turtle.circle(-134, 103)
turtle.penup()
turtle.goto(-123, 108)
turtle.pencolor("gold")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-150, 136)
turtle.circle(-104, 86)
turtle.circle(-220, 30)
turtle.circle(-126, 102)
turtle.penup()
turtle.goto(-120, 104)
turtle.pencolor("greenyellow")
turtle.pendown()
turtle.setheading(60)
turtle.circle(-145, 136)
turtle.circle(-90, 83)
turtle.circle(-220, 30)
turtle.circle(-120, 100)
turtle.penup()

# 爱心
turtle.penup()
turtle.goto(220, 115)
turtle.pencolor("brown")
turtle.pensize(1)
turtle.fillcolor("brown")
turtle.begin_fill()
turtle.pendown()
turtle.setheading(36)
turtle.circle(-8, 180)
turtle.circle(-60, 24)
turtle.setheading(110)
turtle.circle(-60, 24)
turtle.circle(-8, 180)
turtle.end_fill()

# 五环
turtle.penup()
turtle.goto(-5, -170)
turtle.pendown()
turtle.pencolor("blue")
turtle.circle(6)
turtle.penup()
turtle.goto(10, -170)
turtle.pendown()
turtle.pencolor("black")
turtle.circle(6)
turtle.penup()
turtle.goto(25, -170)
turtle.pendown()
turtle.pencolor("brown")
turtle.circle(6)
turtle.penup()
turtle.goto(2, -175)
turtle.pendown()
turtle.pencolor("lightgoldenrod")
turtle.circle(6)
turtle.penup()
turtle.goto(16, -175)
turtle.pendown()
turtle.pencolor("green")
turtle.circle(6)
turtle.penup()

turtle.pencolor("black")
turtle.goto(-16, -160)
turtle.write("BEIJING 2022", font=('Arial', 10, 'bold italic'))
turtle.hideturtle()

turtle.done()

opencv+turtle自动绘图

先看效果

实现过程

turtle是python的一个很好玩的自动绘图工具。然而，用它来画一幅画需要提供大量的坐标点。有的人为了用它画出一幅好看的画不惜去手工计算图片线稿的描点的位置。心疼一秒。
其实我们完全可以用计算机图像识别来自动获取图片边缘的位置坐标，比如Opencv。
我们先直接上python的opencv一个基本案例。

记得先安装opencv-python库

1
2
3

import cv2
img = cv2.imread("bingdundun.png")#读取一张图片
cv2.imshow("窗口标题",img)#在一个窗口显示图片

cv2.imread()是读取一个图像文件，然后将图像的像素信息转化成一个numpy矩阵，并返回
cv2.imshow()则是读取一个numpy矩阵信息，将其作为像素信息在新窗口中打印出来。
ok，读取图片工作完成了，那我们现在来获取图片的边缘信息

1

point=cv2.Canny(img, 000, 200)

这是边缘检测函数，将img图像的边缘像素信息作为numpy矩阵返回，里面的0和200这个参数是阈值范围参数，可自行调节。
虽然得到了边缘位置的信息，但这个矩阵信息却是显示的图像的矩阵的旋转矩阵。因此我们还需要对所得矩阵进行旋转，否则可能会得到倒过来的图像。

1
2

import numpy
point=numpy.rot90(black,k=3)

numpy.rot90()这个函数是矩阵顺时针旋转90度的函数，k代表旋转的次数，经过我的测试，要旋转3次才矫正(也就是逆时针一次)。
得到绘图点的像素信息后，我们开始用turtle进行绘图

1
2
3
4
5
6
7
8
9

import turtle
for y in range(0,len(point)):
    for x in range(0,len(point[y])):
        if point[y][x]!=0:
            turtle.penup()
            turtle.goto(y,x)
            turtle.pendown()
            turtle.goto(y,x)
            turtle.penup()

这里就是直接判断x，y坐标下绘图点矩阵的像素信息是否为0，因为绘图点矩阵是通过canny边缘识别得到的，故除了边缘意外的位置像素值都为0.这样就能描绘出一张图片的线稿了
此外还有其他参数可以调节，比如缩放图像尺寸,笔的大小，绘图的中心位置，绘图速度等等。

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import cv2
import turtle
import numpy
img = cv2.imread("i.png")
cv2.imshow("biaoti",img)
black=cv2.Canny(img, 000, 200)
height, width=black.shape[:2]
point = cv2.resize(black, (int(width/4), int(height/4)), interpolation=cv2.INTER_CUBIC)
point=numpy.rot90(point,k=3)
turtle.setup(600,600)
x0=int(len(point[0])/2)
y0=int(len(point)/2)
turtle.pensize(3)

turtle.speed(1000)
for y in range(0,len(point),2):
    for x in range(0,len(point[y]),2):
        if point[y][x]!=0:
            print(y,x)
            turtle.penup()
            turtle.goto(y-y0,x-x0)
            turtle.pendown()
            turtle.goto(y-y0,x-x0)
            turtle.penup()
while 1:
    pass

使用opencv找轮廓

实现效果

完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

# -*- coding:utf-8 -*-
# __author__ = "mayuke"

# 导入模块
import turtle
import cv2 as cv
import numpy as np

# 读取图片，并设置相关参数
src = cv.imread("img.jpg")
# print(src.shape)
cv.imshow('s1', src)
width = src.shape[1]
hight = src.shape[0]
print(width, hight)
turtle.setup(width + 15, hight + 15)
turtle.bgcolor(0, 0, 0)
turtle.pencolor(1, 1, 1)

# 用一个函数将图片左上角设置成坐标原点（0,0）
def y(x, y):
    x = x - 1 / 2 * width
    y = -(y - 1 / 2 * hight)
    return x, y

# 将图片转成灰度图并进行二值化
gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
ret, image = cv.threshold(gray, 0, 255, cv.THRESH_OTSU)

# 使用opencv找轮廓
counters, re = cv.findContours(image, cv.RETR_TREE, cv.CHAIN_APPROX_NONE)
print('轮廓个数：', len(counters))

# 遍历轮廓进行画图
for i, con in enumerate(counters):

    area = cv.contourArea(con)

    con = np.reshape(con, (con.shape[0], 2))

    turtle.goto(y(con[0, 0], con[0, 1]))
    turtle.pendown()

    biao_x1 = np.argmin(con[:, 0])
    x1 = con[biao_x1, 0]
    y1 = con[biao_x1, 1]
    # print('x1,y1=',x1,y1)

    biao_x2 = np.argmax(con[:, 0])
    x2 = con[biao_x2, 0]
    y2 = con[biao_x2, 1]
    # print('x2,y2=', x2, y2)

    biao_y3 = np.argmin(con[:, 1])
    x3 = con[biao_y3, 0]
    y3 = con[biao_y3, 1]
    # print('x3,y3=', x3, y3)
    # 下边坐标
    biao_y4 = np.argmin(con[:, 1])
    x4 = con[biao_y4, 0]
    y4 = con[biao_y4, 1]
    # print('x4,y4=', x4, y4)

    x1 = x1
    # right
    x2 = x2
    # up
    y3 = y3
    # bottom
    y4 = y4
    print('x1,y1=', x1, y1)
    print('x2,y2=', x2, y2)
    print('x3,y3=', x3, y3)
    print('x4,y4=', x4, y4)
    if x1 < width and x2 >= 0 and y3 < hight and y4 >= 0:
        a1 = image[y1, x1] / 255

        a2 = image[y2, x2] / 255

        a3 = image[y3, x3] / 255

        a4 = image[y4, x4] / 255
    else:
        a1 = a2 = a3 = a4 = 0

    a = a1 + a2 + a3 + a4

    turtle.begin_fill()

    if a > 5:
        turtle.fillcolor(1, 1, 1)
    elif a <= 5:
        turtle.fillcolor(0, 0, 0)
    # 画图
    for shu, c in enumerate(con):
        turtle.goto(y(c[0], c[1]))
    turtle.goto(y(con[0, 0], con[0, 1]))
    turtle.end_fill()
    turtle.penup()

turtle.mainloop()

参考资料

Python绘制冬奥吉祥物“冰墩墩”_turtle_goto_Crossin (sohu.com)

(55条消息) opencv+turtle自动绘图_林雪飞的博客-CSDN博客_opencv 线稿

(55条消息) python 用turtle自动画图_qq 1735375343的博客-CSDN博客_python自动绘图

在typora中插入图片使用style="zoom:67%;"缩放属性，在typora中仍是居中显示的，但是发布博客之后就没有了居中效果，于是添加样式margin:0 auto; 发现仍然无法居中

<img src="https://s2.loli.net/2022/02/08/zW6XYcisfp5QHTR.png" alt="image-20220208153609189" style="zoom:67%; margin:auto;" />

解决问题

img是一种可替换元素，虽然它可以设置宽高，但其本质上还是一个行内元素，所以在使用margin：0 auto的方式设置其水平居中时、必须先将img设置display:block;再设置margin：0 auto才会生效；于是改成下面的写法

<img src="https://s2.loli.net/2022/02/08/zW6XYcisfp5QHTR.png" alt="image-20220208153609189" style="zoom:67%; display:block; margin:auto;" />

参考链接

(55条消息) 图片的垂直水平居中；vertical-align：middle；margin:0 auto和text-align:center失效的问题_CoderLittleWhite的博客-CSDN博客

了解神经网络工作方式的最佳途径莫过于亲自创建一个神经网络，本文将利用感知机解决异或问题。

神经网络(NN)又称人工神经网络(ANN)，是机器学习领域中基于生物神经网络概念的学习算法的一个子集。

拥有五年以上经验的德国机器学习专家Andrey Bulezyuk声称：“神经网络正在彻底改变机器学习，因为它们能够在广泛的学科和行业中为抽象对象高效建模。”

神经网络的发展历史

追根溯源，神经网络诞生于人类对于人脑和智能的追问。而这个追问经历了旷远蒙昧的精神至上学说，直到 19 世纪 20 年代。

奥地利医生 Franz Joseph Gall （ 1758-1828 ） 推测人类的精神活动是由脑的功能活动而实现的，这才使人们认识到意识和精神活动具有物质基础，从而使人们对精神活动的认识从唯心主义的错误观点转到了唯物主义的正确轨道上来。

意大利细胞学家 Camillo Golgi （ 1843~1926 ）徒手将脑组织切成薄片，用重铬酸钾 - 硝酸银浸染法染色，第一次在显微镜下观察到了神经细胞和神经胶质细胞。这为神经科学的研究提供了最为基本的组织学方法。

西班牙神经组织学家 Santiago Ramón y Cajal （ 1852~1934 ）在掌握了 Golgi 染色法后，又进一步改良了 Golgi 染色法，并发明了独创的银染法——还原硝酸银染色法， 此法可显示神经纤维的微细结构 。他发现神经细胞之间没有原生质的联系，因而提出神经细胞是整个神经活动最基本的单位（故称神经元），从而使复杂的神经系统有了进一步研究的切入口。他对于大脑的微观结构研究是开创性的，被许多人认为是现代神经科学之父。他绘图技能出众，他的关于脑细胞的几百个插图至今用于教学。

为此，Santiago Ramón y Cajal 和 Camillo Golgi 两人共享了 1906 年诺贝尔生理学或医学奖。

此后， Cajal 经过大量精细的实验，创立了 “ 神经元学说 ” ，该学说的创立为神经科学的进一步发展开创了新纪元。

对智能机器的探索和计算机的历史一样古老。尽管中文里“电脑”一开始就拥有了“脑”的头衔，但事实上与真正的智能相去甚远。艾伦图灵在他的文章《COMPUTING MACHINERY AND INTELLIGENCE》中提出了几个标准来评估一台机器是否可以被认为是智能的，从而被称为“图灵测试”。

神经元及其连接里也许藏着智能的隐喻，沿着这条路线前进的人被称为连接主义。

1943年，Warren McCulloch 和 Walter Pitts 发表题为《A Logical Calculus of the Ideas Immanent in Nervous Activity》的论文，首次提出神经元的M-P模型。该模型借鉴了已知的神经细胞生物过程原理，是第一个神经元数学模型，是人类历史上第一次对大脑工作原理描述的尝试。

M-P模型的工作原理是神经元的输入信号加权求和，与阈值比较再决定神经元是否输出。这是从原理上证明了人工神经网络可以计算任何算术和逻辑函数。

20世纪40年代末，Donald Olding Hebb在《The Organization of Behavior》中对神经元之间连接强度的变化进行了分析，首次提出来一种调整权值的方法，称为Hebb学习规则。

Hebb学习规则主要假定机体的行为可以由神经元的行为来解释。Hebb受启发于巴普罗夫的条件反射实验，认为如果两个神经元在同一时刻被激发，则它们之间的联系应该被强化。这就是Hebb提出的生物神经元的学习机制，在这种学习中，由对神经元的重复刺激，使得神经元之间的突触强度增加。

Hebb学习规则隶属于无监督学习算法的范畴，其主要思想是根据两个神经元的激发状态来调整期连接关系，以此实现对简单神经活动的模拟。继Hebb学习规则之后，神经元的有监督Delta学习规则被提出，用于解决在输入输出已知的情况下神经元权值的学习问题。

1958年，就职于Cornell航空实验室的Frank Rosenblatt发明了的一种称为感知器（Perceptron）的人工神经网络。它可以被视为一种最简单形式的前馈神经网络，是一种二元线性分类器（激活函数为sign(x)）。感知机是人工神经网络的第一个实际应用，标志着神经网络进入了新的发展阶段。

这次成功的应用也引起了许多学者对神经网络的研究兴趣。1960年，斯坦福大学教授Bernard Widrow教授和他的研究生Ted Hoff开发了Adaline（Adaptive Linear Neuron 或 Adaptive Linear Element）和最小均方滤波器（LMS）。Adaline网络和感知机的区别就是将感知机的Step函数换为Linear线性函数。同一时期，Steinbuch等还提出了称为学习矩阵的二进制联想网络。

周志华《机器学习》第5章神经网络解释了BP算法实质是LMS算法（Least Mean Square）算法的推广。LMS试图使网络的输出均方差最小化，可用于神经元激活函数可微的感知机学习；将LMS推广到由非线性可微神经元组成的多层前馈神经网络，就得到BP算法，因此BP算法也被称为广义δ规则。

1969年，Marvin Minsky 和 Seymour Papert 发表《Perceptrons: an introduction to computational geometry》一书，从数学的角度证明了单层神经网络具有有限的功能，甚至在面对简单的“异或”逻辑问题时也显得无能为力。此后，神经网络的研究陷入了很长一段时间的低迷期。

1972年，芬兰的KohonenT.教授，提出了自组织神经网络SOM(Self-Organizing feature map)。

1974 年，Paul Werbos在哈佛大学攻读博士学位期间，就在其博士论文中发明了影响深远的著名BP神经网络学习算法。但没有引起重视。

1976年，美国Grossberg教授提出了著名的自适应共振理论ART(Adaptive Resonance Theory)，其学习过程具有自组织和自稳定的特征。

1982年，David Parker重新发现了BP神经网络学习算法。

1982年，John Hopfield提出了连续和离散的Hopfield神经网络模型，并采用全互联型神经网络尝试对非多项式复杂度的旅行商问题进行了求解，促进神经网络的研究再次进入了蓬勃发展的时期。

1983年，Hinton, G. E. 和 Sejnowski, T. J.设计了玻尔兹曼机，首次提出了“隐单元”的概念。在全连接的反馈神经网络中，包含了可见层和一个隐层，这就是玻尔兹曼机。

层数的增加可以为神经网络提供更大的灵活性，但参数的训练算法一直是制约多层神经网络发展的一个重要瓶颈。

一个沉睡十年的伟大算法即将被唤醒。

1986年，David E. Rumelhart, Geoffrey E. Hinton 和 Ronald J. Williams发表文章《Learning representations by back-propagating errors》，重新报道这一方法，BP神经网络学习算法才受到重视。BP算法引入了可微分非线性神经元或者sigmod函数神经元，克服了早期神经元的弱点，为多层神经网络的学习训练与实现提供了一种切实可行的解决途径。

1988年，继BP算法之后，David Broomhead 和 David Lowe 将径向基函数引入到神经网络的设计中，形成了径向基神经网络（RBF）。RBF网络是神经网络真正走向实用化的一个重要标志。

1989年，一系列文章对BP神经网络的非线性函数逼近性能进行了分析，并证明对于具有单隐层，传递函数为sigmod的连续型前馈神经网络可以以任意精度逼近任意复杂的连续映射。这样，BP神经网络凭借能够保证对复杂函数连续映射关系的刻画能力（只要引入隐层神经元的个数足够多），打开了Marvin Minsky 和 Seymour Papert 早已关闭的研究大门。

统计学习理论是一种专门研究小样本情况下机器学习规律的理论。Vapnik, V.N.等人从六、七十年代开始致力于此方面研究。到九十年代中期，随着其理论的不断发展和成熟，也由于神经网络等学习方法在理论上缺乏实质性进展，统计学习理论开始受到越来越广泛的重视。同时, 在这一理论基础上发展了一种新的通用学习方法——支持向量机( SVM )，它已初步表现出很多优于已有方法的性能。

此后的近十年时间，神经网络由于其浅层结构，容易过拟合以及参数训练速度慢等原因，曾经火热的神经网络又慢慢的淡出了人们的视线。值得一提的是，1997年，Sepp Hochreiter和Jurgen Schmidhuber首先提出长短期记忆（LSTM）模型。

直到2006年，计算机处理速度和存储能力大大提高，为深度学习的提出铺平了道路。G. E. Hinton 和他的学生 R. R. Salakhutdinov 在《科学》杂志上发表题为《Reducing the Dimensionality of Data with Neural Networks》的文章，掀起了深度学习在学术界和工业界的研究热潮。文章摘要阐述了两个重要观点：一是多隐层的神经网络可以学习到能刻画数据本质属性的特征，对数据可视化和分类等任务有很大帮助；二是可以借助于无监督的“逐层初始化”策略来有效克服深层神经网络在训练上存在的难度。

这篇文章是一个分水岭，拉开了深度学习大幕，标志着深度学习的诞生。从此，历史这样写就：从感知机提出，到BP算法应用以及2006年以前的历史被称为浅层学习，以后的历史被称为深度学习。

总结起来，典型的浅层学习模型包括：传统隐马尔可夫模型（HMM）、条件随机场（CRFs）、最大熵模型（MaxEnt）、boosting、支持向量机（SVM）、核回归及仅含单隐层的多层感知器（MLP）等。

同年，G. E. Hinton 又提出了深度信念网络(Deep BeliefNetwork, DBN) 。深度信念网络基于受限玻尔兹曼机构建。

限制玻尔兹曼机（RBM）是一种玻尔兹曼机的变体，但限定模型必须为二分图。模型中包含对应输入参数的输入（可见）单元和对应训练结果的隐单元，图中的每条边必须连接一个可见单元和一个隐单元。与此相对，“无限制”玻尔兹曼机(BM)包含隐单元间的边，使之成为递归神经网络。BM 由Geoffrey Hinton 和 Terry Sejnowski 在1985年发明，1986年Paul Smolensky 命名了RBM，但直到Geoffrey Hinton及其合作者在2006年左右发明快速学习算法后，受限玻兹曼机才变得知名。

自动编码器早在1986年就被Rumelhart等人提出（也有资料说第一个自动感应器是福岛神经认知机），2006年之后，G. E. Hinton 等人又对自动编码器进行改造，出现了深度自编码器，稀疏自编码器等。2008年，Pascal Vincent和 Yoshua Bengio 等人在《Extracting and composing robust features with denoising autoencoders》中提出了去噪自编码器，2010年又提出来层叠去噪自编码器。2011年，Richard Socher等人也提出了递归自编码器 (RAE)。

目前，卷积神经网络作为深度学习的一种，已经成为当前图像理解领域研究的热点。早在1989年，Yann Le Cun在贝尔实验室就开始使用卷积神经网络识别手写数字；1998年，Yann Le Cun提出了用于字符识别的卷积神经网络LeNet5，并在小规模手写数字识别中取得了较好的结果。基于这些工作，Yann Le Cun也被称为卷积网络之父。2012年，Alex Krizhevsky等使用采用卷积神经网络的AlexNet在ImageNet竞赛图像分类任务中取得了最好成绩，是卷积神经网络在图像分类中的巨大成功。随后Alex Krizhevsky.，Ilya Sutskever.和 Geoffrey Hinton.发表了文章《ImageNet Classification with Deep Convolutional Neural Networks》 。

2013年，Graves 证明，结合了长短时记忆(long short terms memory, LSTM) 的递归神经网络(recurrent neural network, RNN)比传统的递归神经网络在语音处理方面更有效。2014年至今， 深度学习在很多领域都取得了突破性进展，发展出了包括注意力(attention)，RNN–CNN， 以及深度残差网络等多种模型。

最后，给出一个神经网络发展历史的回顾总结：

人工神经网络基本上由以下组件组成：

• 输入层：接收并传递数据
• 隐藏层（隐含层）
• 输出层
• 各层之间的权重
• 每个隐藏层都有一个激活函数。

我们搭建一个包含隐含层的神经网络来解决”异或“问题，所谓”异或“，就是输入两个值不同，输出为1，输入两个值相同，输出为0.

excel版本实现

如上图所示的神经元（即实心圆）中，其激活函数是阶跃函数（sgn函数，x>=0时f(x)=1,else f(x) = 0 )，假设各个神经元的阈值θ均为0.5

当x1和x2相同（假设均为1时），对于隐含层的神经元1来说，输出可以表述为

f1 = sgn(x1*w1 + x2*w3 - θ) = sgn(1*1 + 1*(-1) - 0.5 ) = sgn(-0.5) = 0

激活函数的作用体现在Excel单元格E2中输入的公式上

1

=IF(C2*D2+C4*D4-D6>0,1,0)

类似地，对于隐含层的神经元2有

f2 = sgn(x1*w2 + x2*w4 - θ) = sgn(1*1 + 1*(-1) - 0.5 ) = sgn(-0.5) = 0

激活函数的作用体现在Excel单元格E4中输入的公式上

1

=IF(C2*D3+C4*D5-D6>0,1,0)

接着对于输出层的输出神经元y而言，隐含层的f1和f2都是它的输入，于是有：

y = f3 = sgn(f1*w5 + f2*w6 - θ) = sgn(0*1 + 0*1 - 0.5) = sgn(-0.5) = 0

对应体现在Excel单元格H3中输入的公式上

1

=IF(E2*F2+E4*F4-G6>0,1,0)

如图我们可以看到其结果为0，满足异或的功能，神经网络搭建完成，剩下的就是更改输入即可，无需更改任何公式，一切都是自动更新计算的，读者可以自行尝试，我们可以感性认识到，网络层次越深，神经网络的表征能力越强。

或许你会疑惑，神经网络的权值和阈值时怎么知道的，在这个案例中我们直接给了出来，而实际上，他们是需要神经网络自己反复“试错”学习而来的，而且能完成“异或”功能的网络权重也不唯一。

python版本实现

MLPClassifier是一个监督学习算法，下图是只有1个隐藏层的MLP模型 ，左侧是输入层，右侧是输出层。

上图的整体结构可以简单的理解为下图所示：

MLP又名多层感知机，也叫人工神经网络（ANN，Artificial Neural Network），除了输入输出层，它中间可以有多个隐藏层，如果没有隐藏层即可解决线性可划分的数据问题。最简单的MLP模型只包含一个隐藏层，即三层的结构，如上图。

从上图可以看到，多层感知机的层与层之间是全连接的（全连接的意思就是：上一层的任何一个神经元与下一层的所有神经元都有连接）。多层感知机最底层是输入层，中间是隐藏层，最后是输出层。

输入层没什么好说，你输入什么就是什么，比如输入是一个n维向量，就有n个神经元。

隐藏层的神经元怎么得来？首先它与输入层是全连接的，假设输入层用向量X表示，则隐藏层的输出就是

f(W1X+b1)，W1是权重（也叫连接系数），b1是偏置，函数f 可以是常用的激活函数如 sigmoid函数或者tanh函数

最后就是输出层，输出层与隐藏层是什么关系？其实隐藏层到输出层可以看成是一个多类别的逻辑回归，也即softmax回归，所以输出层的输出就是softmax(W2X1+b2)，X1表示隐藏层的输出f(W1X+b1)。

因此，MLP所有的参数就是各个层之间的连接权重以及偏置，包括W1、b1、W2、b2。对于一个具体的问题，怎么确定这些参数？求解最佳的参数是一个最优化问题，解决最优化问题，最简单的就是梯度下降法了（sgd）：首先随机初始化所有参数，然后迭代地训练，不断地计算梯度和更新参数，直到满足某个条件为止（比如误差足够小、迭代次数足够多时）。这个过程涉及到代价函数、规则化（Regularization）、学习速率（learning rate）、梯度计算等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import numpy as np
# （1）导入模型
from sklearn.neural_network import MLPClassifier

# （2）方案1：创建多层感知机分类器:注意，此时激活函数使用relu或tanh和solver（默认的adam）匹配
# model = MLPClassifier(hidden_layer_sizes=(4,2,), activation='tanh',
#                     max_iter = 10000)

# 方案2：不同的激活函数，使用不同的solver，需要不断尝试
# default = 'adam' and works well for large data sets.

model = MLPClassifier(activation='logistic', max_iter=1000,
                      hidden_layer_sizes=(3,),
                      solver='lbfgs')

# （3）构造所需训练数据
X = np.array([[1, 1],
              [0, 0],
              [1, 0],
              [0, 1]])
y = np.array([0,
              0,
              1,
              1])

# （4）训练模型
model.fit(X, y)

# （5）模型预测
print('1 xor 1 = %d' % model.predict([[1, 1]]))
print('0 xor 0 = %d' % model.predict([[0, 0]]))
print('1 xor 0 = %d' % model.predict([[1, 0]]))
print('0 xor 1 = %d' % model.predict([[0, 1]]))

输出结果：

1
2
3
4

1 xor 1 = 0
0 xor 0 = 0
1 xor 0 = 1
0 xor 1 = 1

MLPClassifier参数说明：

activation:激活函数

max_iter：int 最大迭代次数默认200

例如hidden_layer_sizes=(50, 50)，表示有两层隐藏层，第一层隐藏层有50个神经元，第二层也有50个神经元。

solver用来优化权重 lbfgs：quasi-Newton方法的优化器

练习题

编程实现：通过如下数据集，预测输入[1, 1, 0]的输出

代码实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# -*- coding: utf-8 -*-

import numpy as np

#（1）导入模型
from sklearn.neural_network import MLPClassifier

#（2）方案1：创建多层感知机分类器:注意，此时激活函数使用relu或tanh和solver（默认的adam）匹配
model = MLPClassifier(hidden_layer_sizes=(4,4), activation='relu', 
                    max_iter = 10000)

#方案2：不同的激活函数，使用不同的solver，需要不断尝试
# default = 'adam' and works well for large data sets.  
# model = MLPClassifier(activation='logistic', max_iter=10000, 
#               hidden_layer_sizes=(4,),
#               solver='lbfgs')

#（3）构造所需训练数据
X = np.array([[0, 0, 1], 
              [0, 1, 1], 
              [1, 0, 1], 
              [0, 1, 0], 
              [1, 0, 0], 
              [1, 1, 1], 
              [0, 0, 0]])
y = np.array([ 0, 
              1, 
              1, 
              1, 
              1, 
              0, 
              0])
#（4）训练模型
model.fit(X, y)

#（4）模型预测
print ('[1，1，0] = %d' % model.predict([[1, 1, 0]]))

#(5)输出结果
'''
[1，1，0] = 0
'''

参考资料

神经网络简史 - 简书 (jianshu.com)

手把手教你用Python创建简单的神经网络（附代码） | 机器之心 (jiqizhixin.com)

人工智能极简入门-张玉宏著(12 封私信 / 80 条消息) 玉来愈宏 - 知乎 (zhihu.com)

sklearn 神经网络 MLPClassifier简单应用与参数说明 - 简书 (jianshu.com)

下载和安装

neo4j 教程_w3cschool

Neo4j windows 桌面版 下载地址：Neo4j Desktop Download | Free Graph Database Download

Cypher语言的关键字不区分大小写，但是属性值，标签，关系类型和变量是区分大小写的。

Neo4j中不存在表的概念，只有**标签(labels),节点(Node),关联(Relation),路径(path)**，标签里存的节点,节点和关联可以简单理解为图里面的点和边,路径是用节点和关联表示的如：(a)-[r]->(b)，表示一条从节点a经关联r到节点b的路径。

在数据查询中，节点一般用**小括号()，关联用中括号[]**。

关于Neo4j和Cypher批量更新和批量插入优化的5个建议

https://blog.csdn.net/hwz2311245/article/details/60963383

Neo4j之Cypher学习总结

https://www.jianshu.com/p/2bb98c81d8ee

常用cypher语句

快速清空数据库

1

match (n) detach delete n

创造一个节点

1

create (n:Person {name:"我", age:21})

创建关系

1

create (p:Person {name:"我", age:"23"})-[:包工程{金额:10000}]->(n:Person {name:"好大哥", age:"35"})

删除节点 注意 删除有连接的节点时 必须先删掉关系

1
2

create (n:Person {name:"XL", age:23})
match (n:Person {name:"XL"}) delete n

删除关系

1

match (p:Person {name:"我", age:"23"})-[f:包工程{金额:10000}]->(n:Person {name:"好大哥", age:"35"}) delete f

加上标签

同个某个节点的id 找到它 然后给其设置一个好人的标签

1

match (t:Person) where id(t)=2 set t:好人 return t

额外增加属性

在好人标签中找一个节点的id为2 然后给其加一个战斗力属性 并设置其值为200

1

match (a:好人) where id(a)=2 set a.战斗力=200 return a

查找

1
2

create (:Person {name:"唐僧", age:"79"})-[:师傅 {s_time:"2020-11-23"}]->(:Person {name:"孙悟空", age:"1w"})
match (a:Person)-[:师傅]->(b:Person) return a,b

显示所有节点关系

1

match (n) return n

删除节点关系

1

MATCH (a:Person) OPTIONAL MATCH (a)-[r1]-() DELETE a, r1

查找人员

1

MATCH (tom {name: "Tom Hanks"}) RETURN tom

1.创建节点

创建Person 标签,刘德华等若干节点,各自有name,birthday ,born,englishname等属性

1
2
3
4
5
6

create (n:Person { name: '朱丽倩', birthday:'1966年4月6日',born: 1966 ,englishname:'Carol'});
create (n:Person { name: '刘向蕙', birthday:'2012年5月9日',born: 2012 ,englishname:'Hanna'});
create (n:Person { name: '任贤齐', birthday:'1966年6月23日',born: 1966 ,englishname:'Richie Jen'});
create (n:Person { name: '金城武', birthday:'1973年10月11日',born: 1973,englishname:'Takeshi Kaneshiro'});
create (n:Person { name: '林志玲', birthday:'1974年11月29日',born: 1974,englishname:'zhilin'});
create (n:Person { name: '刘德华', birthday:'1961年9月27日',born: 1961,englishname:'Andy Lau'});

创建Movie 标签,彩云曲等若干节点,各自有title,released 等属性

1
2
3
4

create (n:Movie { title: '彩云曲',released: 1981});
create (n:Movie { title: '神雕侠侣',released: 1983});
create (n:Movie { title: '暗战',released: 2000});
create (n:Movie { title: '拆弹专家',released: 2017});

2.查询节点

2.1 查询整个图形数据库:

点击节点，查看节点的属性，如图，Neo4j自动为节点设置ID值

1

match(n) return n;

2.2 查询具有指定标签的节点

查询Movie标签下的节点

1

match(n:Movie) return n;  

2.3 where 谓词查询

查询名称为林志玲的节点

1

match (n:Person) where n.name='林志玲' return n

**(查询具有指定属性的节点)**结果相同

1

match(n{name:'林志玲'}) return n;

查询born属性小于1967的节点

1

match(n) where n.born<1967 return n; 

3.创建关系

关系的构成：

1

StartNode - [Variable:RelationshipType{Key1:Value1,Key2:Value2}] -> EndNode

在创建关系时，必须指定关系类型。

3.1 创建没有任何属性的关系

1
2
3
4

MATCH (a:Person),(b:Movie)
WHERE a.name = '刘德华' AND b.title = '暗战'
CREATE (a)-[r:DIRECTED]->(b)
RETURN r;

得到结果：

1
2
3
4
5
6
7
8
9

{
  "identity": 2,
  "start": 9,
  "end": 7,
  "type": "DIRECTED",
  "properties": {

  }
}

3.2 创建关系，并设置关系的属性

1
2
3
4

MATCH (a:Person),(b:Movie)
WHERE a.name = '刘德华' AND b.title = '神雕侠侣'
CREATE (a)-[r:出演 { roles:['杨过'] }]->(b)
RETURN r;

得到结果：

1
2
3
4
5
6
7
8
9
10
11

{
  "identity": 1,
  "start": 9,
  "end": 6,
  "type": "出演",
  "properties": {
"roles": [
      "杨过"
    ]
  }
}

3.3 创建双向关系

刘德华的女是刘向蕙,刘向蕙的父亲是刘德华

1
2
3
4
5

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '刘向蕙'
CREATE (a)-[r:父亲 { nickname:'甜心' }]->(c),
(c)-[d:女儿 { nickname:'爹地' }]->(a)
RETURN r;

关系建错了 删除关系 (见5.2 )

重新创建

1
2
3
4
5

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '刘向蕙'
CREATE (a)-[d:女儿 { nickname:'甜心' }]->(c),
(c)-[r:父亲 { nickname:'爹地' }]->(a)
RETURN r;

1
2
3
4
5

MATCH (a:Person),(c:Movie)
WHERE a.name = '刘德华' AND c.title = '彩云曲'
CREATE (a)-[r:出演 { partner:'张国荣' }]->(c),
(c)-[d:演员 { rolename:'阿华哥' }]->(a)
RETURN r;

1
2
3
4
5

MATCH (a:Person),(c:Movie)
WHERE a.name = '刘德华' AND c.title = '拆弹专家'
CREATE (a)-[r:出演 { partner:'赵薇,高圆圆' }]->(c),
(c)-[d:演员 { rolename:'华仔' }]->(a)
RETURN r;

1
2
3
4
5

MATCH (a:Person),(c:Movie)
WHERE a.name = '刘德华' AND c.title = '神雕侠侣'
CREATE (a)-[r:出演 { partner:'刘亦菲' }]->(c),
(c)-[d:演员 { rolename:'杨过' }]->(a)
RETURN r;

继续新增关系 刘德华和林志玲,金城武,任贤齐

1
2
3
4
5
6
7
8
9

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '任贤齐'
CREATE (a)-[d:朋友 { sex:'男' }]->(c)
RETURN d;

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '金城武'
CREATE (a)-[d:朋友 { sex:'男' }]->(c)
RETURN d;

下面这个没有给关系设置属性sex

1
2
3
4

MATCH (a:Person),(c:Person)
WHERE a.name = '刘德华' AND c.name = '林志玲'
CREATE (a)-[d:朋友]->(c)
RETURN d;          

1
2
3
4

match (a:Person), (b:Person) 
where a.name="刘德华" and b.name="朱丽倩"
create (a)-[c:wife]->(b)
return c;

查询Person表关系

1

MATCH (n:Person) RETURN n

4 查询关系

在Cypher中，关系分为三种：符号“–”，表示有关系，忽略关系的类型和方向；符号“–>”和“<–”，表示有方向的关系；

4.1 查询整个数据图形

1

match (n) return n;

4.2 查询跟指定节点有关系的节点

查询跟Movie标签有关系的所有节点

1

match (n) -- (m:Movie) return n;

4.3 查询有向关系的节点

查询和刘德华有关系的电影

1

MATCH (:Person { name: '刘德华' })-->(movie:Movie) RETURN movie;

4.4 为关系命名

通过[r]为关系定义一个变量名，通过函数type获取关系的类型

1

MATCH (:Person { name: '刘德华' })-[r]->(:Movie) RETURN r,type(r);

4.5 查询特定的关系类型

通过[Variable:RelationshipType{Key:Value}]指定关系的类型和属性

1

MATCH (:Person { name: '刘德华' })-[r:出演{partner:'张国荣'}]->(:Movie) RETURN r,type(r);

查询 刘德华和张国荣合作过的电影

1

MATCH (:Person { name: '刘德华' })-[r:出演{partner:'张国荣'}]->(m:Movie) RETURN m;

查询被刘德华称呼为甜心的女儿

1

MATCH (:Person { name: '刘德华' })-[r:女儿{nickname:'甜心'}]->(m:Person) return m

查询刘德华的老婆是谁

1

Match (n:Person{name: '刘德华'})-[:wife]->(a:Person) return a

刘德华出演过的电影

1

match (:Person{name:'刘德华'})-[r:`出演`]->(a:Movie) return a

5 删除

5.1 删除节点

1

create (n:City { name: '北京'})

1

Match (n:City{name:'北京'}) delete n

5.2 删除关系

1

Match (a:Person{name:'刘德华'})-[r:父亲]->(b:Person{name:'刘向蕙'}) delete  r

1

Match (a:Person{name:'刘向蕙'})-[r:女儿]->(b:Person{name:'刘德华'}) delete  r

5.4 强制删除节点和关系

1

Match  (n:`美国军事基地`) where n.name ='挂载'  detach delete n

6 常用查询关键词

6.1 count

查询Person 一共有多少人

1

Match (n:Person ) return count(n)

查询标签(Person)中born=1966的一共有多少节点（人）：

两种写法：

1

Match (n:Person) where  n.born=1966   return  count(n) 

1

Match (n:Person{born:1966})  return  count(n)  //特别注意类型,如果存的类似是数字类型,使用字符串就查不出来

6.2 Limit 限制查询条数

1

Match (n:Person) return n limit 3

6.3 Distinct

1

Match (n:Person) return  distinct(n.born)![0]

6.4 Order by

默认升序：

1

Match(n:Person) return n order by n.born

升序：

1

Match(n:Person) return n order by n.born asc 

降序：

1

Match(n:Person) return n order by n.born desc

6.5 根据id查找

1

match (n) where id(n)=9 return n

6.6 In的用法

1

Match (n) where ID(n) IN[353,145,547] return n

6.7 Exists

节点存在 name这个属性的记录：

1

Match (n) where exists(n.title) return n

6.8 With

查询name以‘刘’开头的节点：

1

Match (n) where n.name starts with '刘' return n

查询name以‘明’结尾的节点：

1

Match (n) where n.name ends with '齐' return n

6.9 Contains

查询title中含有 ‘侠侣’的节点

1

Match (n:Movie) where n.title Contains '侠侣' return n

6.10 Union all (Union)

求并集，不去重（去重用Union, as 取别名）:

1
2
3

Match(n:Person) where n.born=1966 return n.name as name
Union all
Match(n:Movie) where n.released=1983 return n.title as name

7. 更新

7.1 创建一个完整的Path

1
2

CREATE p =(m:Person{ name:'刘亦菲',title:"演员" })-[:签约]->(neo)<-[:签约]-(n:Person { name: '赵薇',title:"投资人" })
RETURN p

7.2 为节点增加一个属性

通过节点的ID获取节点，Neo4j推荐通过where子句和ID函数来实现。

1
2
3
4

match (n)
where id(n)=11
set n.name = '华谊兄弟'
return n;

为节点移除属性

1

MATCH (n:农业) where id(n)=17816137 remove n.sortcode,n.targettable,n.unit,n.uuid

7.3 为节点增加标签

1
2
3
4

match (n)
where id(n)=11
set n:公司
return n;

7.4 为关系增加属性

1
2
3
4

match (n)-[r]->(m)
where id(n)=10 and id(m)=11
set r.经纪人='程晨'
return n;

此时图谱效果成

接着让刘德华也和华谊兄弟签约

1
2
3
4

MATCH (a:Person),(c:公司)
WHERE a.name = '刘德华' AND c.name = '华谊兄弟'
CREATE (a)-[d:签约 { 经纪人:'刘得得' }]->(c)
RETURN d;

7.5 MERGE

Merge子句的作用有两个：当模式（Pattern）存在时，匹配该模式；当模式不存在时，创建新的模式，功能是match子句和create的组合。在merge子句之后，可以显式指定on creae和on match子句，用于修改绑定的节点或关系的属性。

通过merge子句，你可以指定图形中必须存在一个节点，该节点必须具有特定的标签，属性等，如果不存在，那么merge子句将创建相应的节点。

通过merge子句匹配搜索模式

匹配模式是：一个节点有Person标签，并且具有name属性；如果数据库不存在该模式，那么创建新的节点；如果存在该模式，那么绑定该节点；

1
2

MERGE (m:Person { name: '迈克尔·杰克逊' })
RETURN m;

在merge子句中指定on create子句

如果需要创建节点，那么执行on create子句，修改节点的属性；timestamp()时间戳

1
2
3

MERGE (m:Person { name: '杰森·斯坦森' })
ON CREATE SET m.registertime = timestamp()
RETURN m.name, m.registertime

在merge子句中指定on match子句

如果节点已经存在于数据库中，那么执行on match子句，修改节点的属性；节点属性不存在则新增

1
2
3

MERGE (m:Person)
ON MATCH SET m.registertime = timestamp()
RETURN m.name, m.registertime

在merge子句中同时指定on create 和 on match子句(没有对应属性则不修改，不会新增属性)

1
2
3
4

MERGE (m:Person{ name: '李连杰' })
ON CREATE SET m.registertime = timestamp()
ON MATCH SET m.offtime = timestamp()
RETURN m.name, m.registertime, m.offtime

merge子句用于match或create一个关系

1
2
3

MATCH (m:Person { name: '刘德华' }),(n:Movie { title: '神雕侠侣' })
MERGE (m)-[r:导演]->(n)
RETURN m.name, type(r), n.title

merge子句用于match或create多个关系

赵薇既是神雕侠侣的导演,也是神雕侠侣的演员

1
2
3

MATCH (m:Person { name: '赵薇' }),(n:Movie { title: '神雕侠侣' })
MERGE (m)-[r:导演]->(n)<-[r2:出演]-(m)
RETURN m.name, type(r),type(r2), n.title

merge子句用于子查询

先添加基础数据

创建城市节点

1
2
3

create (n:City { name: '北京',othername:'帝都'});
create (n:City { name: '香港',othername:'HongKong'});
create (n:City { name: '台湾',othername:'湾湾'});

为Person标签的每个节点都增加一个属性 bornin

1
2
3

match (n:Person)
set n.bornin = ''
return n;

1
2
3
4

match (n)
where id(n)=9
set n.bornin = '香港'
return n;

1
2
3
4

match (n)
where n.name='金城武'
set n.bornin = '台湾'
return n;

需求:查找刘德华和金城武的信息和所在地的othername(相当于mysql 连表查询)

1
2
3
4

MATCH (p:Person)
where p.name='刘德华' or p.name='金城武'
MERGE (c:City { name: p.bornin })
RETURN p.name,p.born,p.bornin, c.othername;

创建刘德华出生地是香港这条关系

1
2
3
4

MATCH (a:Person),(c:City)
WHERE a.name = '刘德华' AND c.name = '香港'
CREATE (a)-[r:出生地]->(c)
RETURN r;

需求:给Person中每个节点都创建一个出生地的关系,没有则返回null

1
2
3
4

MATCH (p:Person)
MERGE (c:City { name: p.bornin })
MERGE (p)-[r:出生地]->(c)
RETURN p.name, p.bornin, c.othername;

删除这些关系

1

Match (a:Person)-[r:出生地]->(c:City{name:''}) delete r

1

Match (a:City)-[r:出生地]->(c:Person) delete r

查询Person标签中不存在name属性的节点

1

Match (n:Person) where not exists(n.name) return n

1

Match  (n:Person)  where not  exists(n.name)  delete  n

1
2
3
4

create (n:Prize { name: '金马奖'});
create (n:Prize { name: '奥斯卡金奖'});
create (n:Prize { name: '金鸡奖'});
create (n:Prize { name: '香港电影金像奖'});

7.6 跟实体相关的函数

通过id函数，返回节点或关系的ID

查询Movie标签中和刘德华有关系的电影 id(节点和关系)

1
2

MATCH (:Person { name: '刘德华' })-[r]->(:Movie)
RETURN id(r);

通过type函数，查询关系的类型

查询Person标签中和刘德华相关的关系(以下三种结果相同)

1
2

MATCH (:Person { name: '刘德华' })-[r]->()
RETURN type(r);

通过lables函数，查询节点的标签

查询和刘德华有关系的节点

1
2

MATCH (:Person { name: '刘德华' })-[r]->(p)
RETURN p;

查询和刘德华有关系的标签(去重)

1
2

MATCH (:Person { name: '刘德华' })-[r]->(p)
RETURN distinct(labels(p))

通过keys函数，查看节点或关系的属性键

1
2
3

MATCH (a)
WHERE a.name = '刘德华'
RETURN keys(a)

1

MATCH (:Person { name: '刘德华' })-[r]->(p) RETURN distinct(keys(r))

通过properties()函数，查看节点或关系的属性

1
2
3

MATCH (a)
WHERE a.name = '刘德华'
RETURN properties(a)

1

MATCH (:Person { name: '刘德华' })-[r]->(p) RETURN properties(r)

8.跟索引相关的函数

8.1 创建索引

创建单一属性索引

CREATE INDEX ON :Lable(property)

Query:

1

CREATE INDEX ON :Person(name)

给数据库的:Person标签的name属性创建索引

Result:

1

Added 1 index, completed after 32 ms.

创建复合属性索引

CREATE INDEX ON :Label(prop1,…,propN)

Query:

1

CREATE INDEX ON :Person(age,country)

Result:

1

Added 1 index, completed after 4 ms.

8.2 查询索引

CALL db.Indexes

8.3 删除索引

DROP INDEX ON :LABEL(property）

Query:

1

DROP INDEX ON :Person(firstname)

DROP INDEX ON :LABEL(prop1,…,propN)

Query:

1

DROP INDEX ON :Person(age,country)

8.4 备份与导入

备份/导出

要以管理员身份运行

1

neo4j-admin dump --database=graph.db --to=E:\neo4jdata

导入

1

neo4j-admin load --from=E:\neo4jdata\graph.db.dump --database=graph.db --force

导入csv

1
2
3
4

USING PERIODIC COMMIT 500 LOAD CSV FROM "file:///D:\\test.csv" AS line  MERGE (:`顶顶顶` {name:line[0]})
LOAD CSV WITH HEADERS FROM "file:///C:\\Program Files\\Java\\neo4j-community-3.4.7\\import\\stock_concept.csv"
AS line
return line.n

1
2
3