P
推荐书籍：
1:How To Think Like A Computer Scientist
2:A Byte Of Python 这本书有 中译版
第七章：
异常：
1:Try/execpt/else
2:try/finally
Raise......
内置的：
Python
C扩展：
如果你在写python程序时遇到异常后想进行如下处理的话,一般用try来处理异常，假设有下面的一段程序：
|
1 2 3 4 5 6 7 8 |
try: 语句1 语句2 . . 语句N except .........: do something ....... |
但是你并不知道"语句1至语句N"在执行会出什么样的异常，但你还要做异常处理，且想把出现的异常打印出来，并不停止程序的运行，所以在"except ......"这句应怎样来写呢？
第五章：
函数：
def
return
global
例6.1 使用if语句
#!/usr/bin/python
# Filename: if.py
number = 23
guess = int(raw_input('Enter an integer : '))
if guess == number:
print 'Congratulations, you guessed it.' # New block
starts here
print "(but you do not win any prizes!)" # New block
ends here
elif guess < number:
print 'No, it is a little higher than that' #
Another block
# You can do whatever you want in a block ...
else:
print 'No, it is a little lower than that'
# you must have guess > number to reach here
print 'Done'
# This last statement is always executed, after the if
statement is executed
它如何工作
global语句被用来声明x是全局的——因此，当我们在函数内把值赋给x的时候，这个变化也反映在我们
在主块中使用x的值的时候。
它如何工作
在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类，我们会在后面相应的章节学习它们。文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。 强烈建议 你在你的函数中使用文档字符串时遵循这个惯例。
print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种
特定的格式。定制可以是%s表示字符串或%d表示整数。元组必须按照相同的顺序来对应这些定制。
字典 ：
字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，我们把键（名字）和值（详细情况）联系在一起。注意，键必须是唯一的，就像如果有两个人恰巧同名的话，你无法找到正确的信息。
键值对在字典中以这样的方式标记：d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割，而各个对用逗号分割，所有这些都包括在花括号中。
#!/usr/bin/python
# Filename: using_dict.py
# 'ab' is short for 'a'ddress'b'ook
ab = { 'Swaroop' :'swaroopch@byteofpython.info',
'Larry' : 'larry@wall.org',
'Matsumoto' : 'matz@ruby-lang.org',
'Spammer' : 'spammer@hotmail.com'
}
ab['Guido'] = 'guido@python.org'
序列：
列表、元组和字符串都是序列，但是序列是什么，它们为什么如此特别呢？序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片，即一部分序列。
#!/usr/bin/python
# Filename: seq.py
shoplist = ['apple', 'mango', 'carrot', 'banana']
# Indexing or 'Subscription' operation
print 'Item 0 is', shoplist[0]
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1]
print 'Item -2 is', shoplist[-2]
# Slicing on a list
print 'Item 1 to 3 is', shoplist[1:3]
print 'Item 2 to end is', shoplist[2:]
print 'Item 1 to -1 is', shoplist[1:-1]
print 'Item start to end is', shoplist[:]
# Slicing on a string
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]
它如何工作：
首先，我们来学习如何使用索引来取得序列中的单个项目。这也被称作是下标操作。每当你用方括号中的一个数来指定一个序列的时候，Python会为你抓取序列中对应位置的项目。记住，Python从0开始计数。因此，shoplist[0]抓取第一个项目，shoplist[3]抓取shoplist序列中的第四个元素。
索引同样可以是负数，在那样的情况下，位置是从序列尾开始计算的。因此，shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。
切片操作符是序列名后跟一个方括号，方括号中有一对可选的数字，并用冒号分割。注意这与你使用的索引操作符十分相似。记住数是可选的，而冒号是必须的。
切片操作符中的第一个数（冒号之前）表示切片开始的位置，第二个数（冒号之后）表示切片到哪里结束。如果不指定第一个数，Python就从序列首开始。如果没有指定第二个数，则Python会停止在序列尾。注意，返回的序列从开始位置 开始 ，刚好在 结束 位置之前结束。即开始位置是包含在序列切片中的，而结束位置被排斥在切片外。
这样，shoplist[1:3]返回从位置1开始，包括位置2，但是停止在位置3的一个序列切片，因此返回一个含有两个项目的切片。类似地，shoplist[:]返回整个序列的拷贝。
你可以用负数做切片。负数用在从序列尾开始计算的位置。例如，shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。
delimiter = '_*_'
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)
str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法，它返回一个生成的大字符串。
Brazil_*_Russia_*_India_*_China
第11章 面向对象的编程
类和对象是面向对象编程的两个主要方面。 类创建一个新类型，而对象这个类的 实例 。
num = 10
print 'Guess what I think?'
answer = input() #输入等待
if answer<num:
print 'too small!'
if answer>num:
print 'too big!'
if answer==num:
print 'BINGO!'
模块 :
本章主题
z 什么是模块?
z 模块和文件
z 命名空间
z 导入模块
z 导入模块属性
z 模块内建函数包
z 模块的其他特性
1:这个把其他模块中属性附加到你的模块中的操作叫做导入(import)
那些自我包含并且有组织的代码片断就是模块( module )。
一个名称空间就是一个从名称到对象的关系映射集合
如果我在我自己的模块 mymodule 里创建了一个 atoi() 函数, 那么它的名
字应该是 mymodule.atoi() 。
第11章 面向对象的编程
类与对象的方法
我们已经讨论了类与对象的功能部分，现在我们来看一下它的数据部分。事实上，它们只是与类和对象的名称空间 绑定 的普通变量，即这些名称只在这些类与对象的前提下有效。
有两种类型的 域 ——类的变量和对象的变量，它们根据是类还是对象 拥有 这个变量而区分。
类的变量 由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做
了改动的时候，这个改动会反映到所有其他的实例上。
对象的变量 由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在
同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。通过一个例子会使这个易于
理解。
继承 :
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过 继承 机制。继承完全可以理解成类之间的 类型和子类型 关系 .
Python编程快速上手
—让繁琐工作自动化
第一部分 Python 编程基础
第 1 章 Python 基础
1.2 整型、浮点型和字符串数据类型
第一章：
第二章：
习题12：提示别人
age = raw_input("How old are you? ")
height = raw_input("How tall are you? ")
weight = raw_input("How much do you weigh? ")
print "So, you're %r old, %r tall and %r heavy." % ( age, height, weight)
2017-11-1（习题13---习题15）
第10章-数据结构
在Python中有三种内建的数据结构——列表、元组和字典。我们将会学习如何使用它们，以及它们如何使编程变得简单。
Python 调用shell脚本
http://blog.csdn.net/lindaydk/article/details/6412047
import os
import sys
阶段二、人工智能提升 — Python 高级应用
随着 AI 时代的到来以及其日益蓬勃的发展，Python 作为 AI 时代的头牌语言地位基本确
定，机器学习是着实令人兴奋，但其复杂度及难度较大，通常会涉及组装工作流和管道、设置,数据源及内部和云部署之间的分流而有了 Python 库后，可帮助加快数据管道，且 Python 库也在不断更新发布中，所以本阶段旨在为大家学习后续的机器学习减负。
容器
a. 列表:list
b. 元组:tuple
c. 字典: dict
d. 数组: Array
e. 切片
f.
列表推导式中国 IT 互联网教育领导品牌
g. 浅拷贝和深拷贝
Ø 函数
a. lambda 表达式
b. 递归函数及尾递归优化
c. 常用内置函数/高阶函数
d. 项目案例：约瑟夫环问题
Ø 常用库
a. 时间库
b. 并发库
c. 科学计算库
d. Matplotlib 可视化绘图库
e. 锁和线程
f.
多线程编程
1：斜率与法向量的乘积为-1。
在二维平面坐标中，一条直线的方向向量v=(a,b)，则该直线的斜率为arctan(θ)=b/a,当然a=0时，如果b>0就是90度，b<0就是-90度。
向量替斜率 解题免讨论 江西省永丰中学 331500 刘 忠 （特级教师） （本文发表于《中学数学杂志》2009年第1期）
直线是由一个点和一个方向确定的，而方向又可用它的倾斜角来确定.由于斜率可以直接反映于它的方程中（特别是斜截式），所以通常用斜率来确定一条直线的方向.又由于并不是任何直线都有斜率，所以在对一些与直线斜率有关的问题的解决时就不得不分斜率存在与否进行讨论了.考虑到任何直线的方向都可由它的方向向量来确定， 所以在解决一些与直线斜率有关的问题时用它的方向向量来代替斜率就可以避免繁杂的讨论，而使过程简洁明快.本文介绍利用直线的方向向量和法向量来解决一些与斜率有关的问题的方法，供大家参考.
直线的方向向量与法向量
A与B是向量
L2范数是指向量各元素的平方和然后求平方根
L2范数是指向量各元素的平方和然后开方，用在回归模型中也称为岭回归
fhandle=open("D:/work/pdf/python/demo/1.txt","wb")#以二进制读的形式创建文件文件
=K（s1*s2*s3*s4............sn）
///////////////////////////////////////////////////////////////////////////////////////////////
带你搞懂朴素贝叶斯分类算法
2017-04-14 16:19 20233人阅读 评论(5) 收藏 举报
分类：
NLP（41）
带你搞懂朴素贝叶斯分类算法
带你搞懂朴素贝叶斯分类算
贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。而朴素朴素贝叶斯分类是贝叶斯分类中最简单，也是常见的一种分类方法。这篇文章我尽可能用直白的话语总结一下我们学习会上讲到的朴素贝叶斯分类算法，希望有利于他人理解。
1 分类问题综述
对于分类问题，其实谁都不会陌生，日常生活中我们每天都进行着分类过程。例如，当你看到一个人，你的脑子下意识判断他是学生还是社会上的人；你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱”之类的话，其实这就是一种分类操作。
既然是贝叶斯分类算法，那么分类的数学描述又是什么呢？
从数学角度来说，分类问题可做如下定义：已知集合和，确定映射规则y = f(x)，使得任意有且仅有一个,使得成立。
其中C叫做类别集合，其中每一个元素是一个类别，而I叫做项集合（特征集合），其中每一个元素是一个待分类项，f叫做分类器。分类算法的任务就是构造分类器f。
分类算法的内容是要求给定特征，让我们得出类别，这也是所有分类问题的关键。那么如何由指定特征，得到我们最终的类别，也是我们下面要讲的，每一个不同的分类算法，对应着不同的核心思想。
本篇文章，我会用一个具体实例，对朴素贝叶斯算法几乎所有的重要知识点进行讲解。
2 朴素贝叶斯分类
那么既然是朴素贝叶斯分类算法，它的核心算法又是什么呢？
是下面这个贝叶斯公式：
换个表达形式就会明朗很多，如下：
我们最终求的p(类别|特征)即可！就相当于完成了我们的任务。
3 例题分析
下面我先给出例子问题。
给定数据如下：
现在给我们的问题是，如果一对男女朋友，男生想女生求婚，男生的四个特点分别是不帅，性格不好，身高矮，不上进，请你判断一下女生是嫁还是不嫁？
这是一个典型的分类问题，转为数学问题就是比较p(嫁|(不帅、性格不好、身高矮、不上进))与p(不嫁|(不帅、性格不好、身高矮、不上进))的概率，谁的概率大，我就能给出嫁或者不嫁的答案！
这里我们联系到朴素贝叶斯公式：
我们需要求p(嫁|(不帅、性格不好、身高矮、不上进),这是我们不知道的，但是通过朴素贝叶斯公式可以转化为好求的三个量.
p(不帅、性格不好、身高矮、不上进|嫁)、p（不帅、性格不好、身高矮、不上进)、p(嫁)（至于为什么能求，后面会讲，那么就太好了，将待求的量转化为其它可求的值，这就相当于解决了我们的问题！）
4 朴素贝叶斯算法的朴素一词解释
那么这三个量是如何求得？
是根据已知训练数据统计得来，下面详细给出该例子的求解过程。
回忆一下我们要求的公式如下：
那么我只要求得p(不帅、性格不好、身高矮、不上进|嫁)、p（不帅、性格不好、身高矮、不上进)、p(嫁)即可，好的，下面我分别求出这几个概率，最后一比，就得到最终结果。
p(不帅、性格不好、身高矮、不上进|嫁) = p(不帅|嫁)*p(性格不好|嫁)*p(身高矮|嫁)*p(不上进|嫁)，那么我就要分别统计后面几个概率，也就得到了左边的概率！
等等，为什么这个成立呢？学过概率论的同学可能有感觉了，这个等式成立的条件需要特征之间相互独立吧！
对的！这也就是为什么朴素贝叶斯分类有朴素一词的来源，朴素贝叶斯算法是假设各个特征之间相互独立，那么这个等式就成立了！
但是为什么需要假设特征之间相互独立呢？
1、我们这么想，假如没有这个假设，那么我们对右边这些概率的估计其实是不可做的，这么说，我们这个例子有4个特征，其中帅包括{帅，不帅}，性格包括{不好，好，爆好}，身高包括{高，矮，中}，上进包括{不上进，上进}，那么四个特征的联合概率分布总共是4维空间，总个数为2*3*3*2=36个。
36个，计算机扫描统计还可以，但是现实生活中，往往有非常多的特征，每一个特征的取值也是非常之多，那么通过统计来估计后面概率的值，变得几乎不可做，这也是为什么需要假设特征之间独立的原因。
2、假如我们没有假设特征之间相互独立，那么我们统计的时候，就需要在整个特征空间中去找，比如统计p(不帅、性格不好、身高矮、不上进|嫁),
我们就需要在嫁的条件下，去找四种特征全满足分别是不帅，性格不好，身高矮，不上进的人的个数，这样的话，由于数据的稀疏性，很容易统计到0的情况。 这样是不合适的。
根据上面俩个原因，朴素贝叶斯法对条件概率分布做了条件独立性的假设，由于这是一个较强的假设，朴素贝叶斯也由此得名！这一假设使得朴素贝叶斯法变得简单，但有时会牺牲一定的分类准确率。
好的，上面我解释了为什么可以拆成分开连乘形式。那么下面我们就开始求解！
我们将上面公式整理一下如下：
下面我将一个一个的进行统计计算（在数据量很大的时候，根据中心极限定理，频率是等于概率的，这里只是一个例子，所以我就进行统计即可）。
p(嫁)=？
首先我们整理训练数据中，嫁的样本数如下：
则 p(嫁) = 6/12（总样本数） = 1/2
p(不帅|嫁)=？统计满足样本数如下：
则p(不帅|嫁) = 3/6 = 1/2 在嫁的条件下，看不帅有多少
p(性格不好|嫁)= ？统计满足样本数如下：
则p(性格不好|嫁)= 1/6
p（矮|嫁） = ?统计满足样本数如下：
则p(矮|嫁) = 1/6
p(不上进|嫁) = ?统计满足样本数如下：
则p(不上进|嫁) = 1/6
下面开始求分母，p(不帅)，p（性格不好），p（矮），p（不上进）
统计样本如下：
不帅统计如上红色所示，占4个，那么p（不帅） = 4/12 = 1/3
性格不好统计如上红色所示，占4个，那么p（性格不好） = 4/12 = 1/3
身高矮统计如上红色所示，占7个，那么p（身高矮） = 7/12
不上进统计如上红色所示，占4个，那么p（不上进） = 4/12 = 1/3
到这里，要求p(不帅、性格不好、身高矮、不上进|嫁)的所需项全部求出来了，下面我带入进去即可，
= (1/2*1/6*1/6*1/6*1/2)/(1/3*1/3*7/12*1/3)
下面我们根据同样的方法来求p(不嫁|不帅，性格不好，身高矮，不上进)，完全一样的做法，为了方便理解，我这里也走一遍帮助理解。首先公式如下：
下面我也一个一个来进行统计计算，这里与上面公式中，分母是一样的，于是我们分母不需要重新统计计算！
p（不嫁）=？根据统计计算如下（红色为满足条件）：
则p(不嫁)=6/12 = 1/2
p(不帅|不嫁) = ？统计满足条件的样本如下（红色为满足条件）：
则p（不帅|不嫁） = 1/6
p（性格不好|不嫁） = ？据统计计算如下（红色为满足条件）：
则p（性格不好|不嫁） =3/6 = 1/2
p（矮|不嫁） = ？据统计计算如下（红色为满足条件）：
则p（矮|不嫁） = 6/6 = 1
p（不上进|不嫁） = ？据统计计算如下（红色为满足条件）：
则p（不上进|不嫁） = 3/6 = 1/2
那么根据公式：
p (不嫁|不帅、性格不好、身高矮、不上进) = ((1/6*1/2*1*1/2)*1/2)/(1/3*1/3*7/12*1/3)
很显然(1/6*1/2*1*1/2) > (1/2*1/6*1/6*1/6*1/2)
于是有p (不嫁|不帅、性格不好、身高矮、不上进)>p (嫁|不帅、性格不好、身高矮、不上进)
所以我们根据朴素贝叶斯算法可以给这个女生答案，是不嫁！！！！
5 朴素贝叶斯分类的优缺点
优点：
（1） 算法逻辑简单,易于实现（算法思路很简单，只要使用贝叶斯公式转化医学即可！）
（2）分类过程中时空开销小（假设特征相互独立，只会涉及到二维存储）
缺点：
理论上，朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此，这是因为朴素贝叶斯模型假设属性之间相互独立，这个假设在实际应用中往往是不成立的，在属性个数比较多或者属性之间相关性较大时，分类效果不好。
而在属性相关性较小时，朴素贝叶斯性能最为良好。对于这一点，有半朴素贝叶斯之类的算法通过考虑部分关联性适度改进。
整个例子详细的讲解了朴素贝叶斯算法的分类过程，希望对大家的理解有帮助~
参考：李航博士《统计学习方法》
算法杂货铺--分类算法之朴素贝叶斯分类(Naive Bayesian classification)
致谢：德川，皓宇，继豪，施琦
/////////////////////////////////////////////////////////////////////////////////////////////
全概率的笔记：
贝叶斯的极大似然估算：
对于：(N为15，K为2分类)
(N为9，K为3分类<1-2-3>)
决策树与随机森林:
ID3算法用的是信息增益，C4.5算法用信息增益率；CART算法使用基尼系数。
香农引入了信息熵，将其定义为离散随机事件出现的概率，一个系统越是有序，信息熵就越低，反之一个系统越是混乱，它的信息熵就越高。所以信息熵可以被认为是系统有序化程度的一个度量。
信息增益就是决策树在进行属性选择划分前和划分后信息的差值
预备知识：信息熵
熵是无序性（或不确定性）的度量指标。假如事件A的全概率划分是（A1,A2,...,An），每部分发生的概率是(p1,p2,...,pn)，那信息熵定义为：
通常以2为底数，所以信息熵的单位是bit。
补充两个对数去处公式：
4 例子
下面通过例子来解释一下：
假如我们有上面数据：
设随机变量Y={嫁，不嫁}
我们可以统计出，嫁的个数为6/12 = 1/2
不嫁的个数为6/12 = 1/2
那么Y的熵，根据熵的公式来算，可以得到H（Y） = -1/2log1/2 -1/2log1/2
为了引出条件熵，我们现在还有一个变量X，代表长相是帅还是帅，当长相是不帅的时候，统计如下红色所示：
可以得出，当已知不帅的条件下，满足条件的只有4个数据了，这四个数据中，不嫁的个数为1个，占1/4
嫁的个数为3个，占3/4
那么此时的H（Y|X = 不帅） = -1/4log1/4-3/4log3/4
p(X = 不帅) = 4/12 = 1/3
同理我们可以得到：
当已知帅的条件下，满足条件的有8个数据了，这八个数据中，不嫁的个数为5个，占5/8
嫁的个数为3个，占3/8
那么此时的H（Y|X = 帅） = -5/8log5/8-3/8log3/8
p(X = 帅) = 8/12 = 2/3
5 计算结果
有了上面的铺垫之后，我们终于可以计算我们的条件熵了，我们现在需要求：
H（Y|X = 长相）
也就是说，我们想要求出当已知长相的条件下的条件熵。
根据公式我们可以知道，长相可以取帅与不帅俩种
条件熵是另一个变量Y熵对X（条件）的期望。
公式为：
H（Y|X=长相） = p(X =帅)*H（Y|X=帅）+p(X =不帅)*H（Y|X=不帅）
ID3算法
构造树的基本想法是随着树深度的增加，节点的熵迅速地降低。熵降低的速度越快越好，这样我们有望得到一棵高度最矮的决策树。
1：熵越大，不确定性越大，系统越无序
熵越大，随机变量(见与不见)的不确定性越大。
母亲需要获得尽可能多的信息，减少不确定性。
信息的如何度量？——熵
母亲得到信息越多，女儿的态度越明确，与男方见与不见的不确定性越低。因此，信息量与不确定性相对应。使用熵来表示不确定性的度量。
1.3 条件熵(局部，现象发生的前提下的熵)
条件熵H(Y|X)表示在已知随机变量X的条件下随机变量Y的不确定性。例如，知道男生年龄的前提条件下，根据女儿见与不见的不确定性。
熵与条件熵中概率由数据估计得到时，所对应的熵和条件熵称为经验熵和经验条件熵。若概率为0，令0log0=0
信息增益表示得知特征X(年龄)的信息使得类Y(见与不见)的信息的不确定性减少程度。
1.4 信息增益
信息增益表示得知特征X(年龄)的信息使得类Y(见与不见)的信息的不确定性减少程度。
特征A对训练数据集D的信息增益g(D,A)，定义为集合D的经验熵H(D)与特征A给定条件下的经验条件熵H(D|A)之差
熵H(Y)与条件熵H(Y|X)之差称为互信息，即g(D,A)。
信息增益大表明信息增多，信息增多，则不确定性就越小，母亲应该选择使得信息增益增大的条件询问女儿。
剪枝：
支持向量机：
1：
Ax+By+C=0 => y=-A/Bx-C/B的方向向量 （1，k）=(1,-A/B)
因为法向量与方向向量垂直，所以n*m=0;所以：n=（A,B）
若直线方程为AX+BY+C=0 方向向量就等于 (1 , k ) = (1 , -A/B)=(B ，-A）因为法向量与方向向量垂直 ，所以 法向量等于（A ，B）斜率K=-A/B角度不是特殊角不好求 ，用计算器算截距等于直线与坐标轴上的交点坐标 如直接在X轴上的截距等于将Y=0带入方程 求X 截距有正负
首先要知道形如直线方程Ax + By + C = 0
它的直线方向向量可表示为(B,-A) (这个可从向量(1,k),而推得) 其中,k表示斜率.
则与它垂直的向量 (法向量)可表示为(A,B)
原因可用数量积来解释:
因为(B,-A) • (A,B) = BA - AB = 0,所以证明了两向量是互相垂直的.
法向量是不是和直线垂直的向量 (是的)
举例:如直线方程2x - 3y + 1 = 0
则直线的法向量可表示为(2,-3).
模式识别（神经网络设计）：
Hopfield神经网络：
神经元的标号识别：
平方误差：
公式：
卷积神经网络：
图像处理四层：
http://blog.csdn.net/loving_forever_/article/details/52389862
左边数据在变化，每次滤波器都是针对某一局部的数据窗口进行卷积，这就是所谓的CNN中的局部感知机制。
马尔可夫联合概率分布：
同理，N步转移概率矩阵
P(n) = P(n-1)P(1) = P(n-2)P(1)P(1) = ..... = P(1)^n
比如现在分类正确是Y=+1 但是此时W与X的夹角却大于90，导致结果小于0，修正方法是：是把W的向量尽量靠近X,缩小W与X的夹角.
浙公网安备 33010602011771号