ravencrown / aiworld Goto Github PK

View Code? Open in Web Editor NEW

1.0 1.0 0.0 29.03 MB

机器学习、深度学习、模式识别、自然语言处理处理等相关知识

aiworld's People

Contributors

Stargazers

Watchers

aiworld's Issues

函数式编程

不是纯的函数式编程：允许有变量
支持高阶函数：函数也可以作为变量传入
支持闭包：有了闭包就能返回函数
有限度地支持匿名函数

高阶函数

变量可以指向函数
接受函数作为参数的函数

python 中的函数

map(f, list): 不改变原有list，返回一个新的list
reduce(f, list)
filter
sorted
自定义排序函数
返回值是函数
闭包：在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问，像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
匿名函数
偏函数 functools.partial

装饰器 decorator

运行时添加动态功能
内置@语法就是为了简化装饰器调用
极大的简化代码，避免每个函数编写重复性代码
*args/**kw
带参数/不带参数

模块和包的概念

代码拆分放入多个 py 文件：变量无污染
模块名就是py文件名
引用方式：import packageName，
调用：packageName.fn
包下有一个 init.py，每一层都需要有这个名字

导入模块

// 引入完整模块
import math, logging
// 引入某几个函数
from math import pow, sin, log

// 区分同名
from math import log
from logging import log as logger # logging的log现在变成了logger

print log(10)   # 调用的是math的log
logger(10, 'import from logging')   # 调用的是logging的log

动态导入

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO

future

Python的新版本会引入新的功能，但是，实际上这些功能在上一个老版本中就已经存在了。要“试用”某一新的特性，就可以通过导入__future__模块的某些功能来实现。

当新版本的一个特性与旧版本不兼容时，该特性将会在旧版本中添加到__future__中，以便旧的代码能在旧版本中测试新特性。

from __future__ import unicode_literals

s = 'am I an unicode?'
print isinstance(s, unicode)

// or
from __future__ import division

安装第三方模块

python 的包管理工具，类似 Node 的 npm

easy install
pip (推荐)

面向对象编程

面向对象的概念、属性、方法、继承、多态等

class Person(object):
    pass

初始实例

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，init()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

init() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。

class Person(object):
    def __init__(self, name, gender, birth, **kw):
        self.name = name
        self.gender = gender
        self.birth = birth
        for k, v in kw.iteritems():
            setattr(self, k, v)

访问限制

Python对属性权限的控制是通过属性名来实现的，如果一个属性由双下划线开头(__)，该属性就无法被外部访问。看例子：

class Person(object):
    def __init__(self, name):
        self.name = name
        self._title = 'Mr'
        self.__job = 'Student'
p = Person('Bob')
print p.name
# => Bob
print p._title
# => Mr
print p.__job
# => Error
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute '__job'

可见，只有以双下划线开头的"__job"不能直接被外部访问。

但是，如果一个属性以"xxx"的形式定义，那它又可以被外部访问了，以"xxx"定义的属性在Python的类中被称为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"xxx"定义。

以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。

创建类属性

绑定在一个实例上的属性不会影响其他实例，但是，类本身也是一个对象，如果在类上绑定一个属性，则所有实例都可以访问类的属性，并且，所有实例访问的类属性都是同一个！也就是说，实例属性每个实例各自拥有，互相独立，而类属性有且只有一份。

class Person(object):
    count = 0
    def __init__(self, name):
        Person.count = Person.count + 1
        self.name = name
p1 = Person('Bob')
print Person.count
# => 1
p2 = Person('Alice')
print Person.count
# => 2
p3 = Person('Tim')
print Person.count
# => 3

实例方法

get_name(self) 就是一个实例方法，它的第一个参数是self。init(self, name)其实也可看做是一个特殊的实例方法。

方法也是属性， types.MethodType() 可以把一个函数变为一个方法

class Person(object):

    def __init__(self, name):
        self.__name = name

    def get_name(self):
        return self.__name

类方法

在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。

通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。

因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。

class Person(object):
    count = 0
    @classmethod
    def how_many(cls):
        return cls.count
    def __init__(self, name):
        self.name = name
        Person.count = Person.count + 1

print Person.how_many()
p1 = Person('Bob')
print Person.how_many()

类的继承

如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承：

// 父类
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

// 子类
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score

class Teacher(Person):

    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course

上面例子函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。

判断类型 isinstance()

p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')

>>> isinstance(p, Person)
True    # p是Person类型
>>> isinstance(p, Student)
False   # p不是Student类型
>>> isinstance(p, Teacher)
False   # p不是Teacher类型

>>> isinstance(s, Person)
True    # s是Person类型
>>> isinstance(s, Student)
True    # s是Student类型
>>> isinstance(s, Teacher)
False   # s不是Teacher类型

多重继承

多重继承的目的是从两种继承树中分别选择并继承出子类，以便组合功能使用。

class A(object):
    def __init__(self, a):
        print 'init A...'
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print 'init B...'

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print 'init C...'

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print 'init D...'

像这样，D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次：

举个例子，Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有多进程ForkingMixin 和多线程ThreadingMixin两种。

获取对象信息

首先可以用 type() 函数获取变量的类型，它返回一个 Type 对象：

>>> type(123)
<type 'int'>
>>> s = Student('Bob', 'Male', 88)
>>> type(s)
<class '__main__.Student'>

其次，可以用 dir() 函数获取变量的所有属性：

>>> dir(123)   # 整数也有很多属性...
['__abs__', '__add__', '__and__', '__class__', '__cmp__', ...]

>>> dir(s)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'gender', 'name', 'score', 'whoAmI']

对于实例变量，dir()返回所有实例属性，包括__class__这类有特殊意义的属性。

dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr( )函数了：

>>> getattr(s, 'name')  # 获取name属性
'Bob'

>>> setattr(s, 'name', 'Adam')  # 设置新的name属性

>>> s.name
'Adam'

>>> getattr(s, 'age')  # 获取age属性，但是属性不存在，报错：
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'

>>> getattr(s, 'age', 20)  # 获取age属性，如果属性不存在，就返回默认值20：
20

Python 特殊方法

str :
repr
cmp
len
数学运算
类型转换
@Property
__slots
call

str

如果要把一个类的实例变成 str，就需要实现特殊方法__str__()：

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return '(Person: %s, %s)' % (self.name, self.gender)

// 现在，在交互式命令行下用 print 试试：
>>> p = Person('Bob', 'male')
>>> print p
(Person: Bob, male)

// 但是，如果直接敲变量 p：
>>> p
<main.Person object at 0x10c941890>

机器学习的动机与应用

本节主要介绍

监督学习 (supervised learning)
学习理论 (learning throry)
无监督学习 (unsupervised learning)
强化学习

机器学习的定义（Machine Learning definition）

Arthur Samuel（1959）的观点：Field of study that gives computers the ability to learn without being explicitly programmed（在不直接针对问题进行编程的情况下，赋予计算机学习能力的一个研究领域）

Tom Mitchell的观点：A computer program is said to learn from experience E with respect to some task T and some performance measure P，if its performance on T，as measured by P，improves with experience E.（对于一个计算机程序来说，给它一个任务T和一个性能测量方法P，如果在经验E的影响下，P对T的测量结果得到了改进，那么就说该程序从E中学习）

监督学习

回归问题

简单的例子就是房子的大小和价格的问题，这一类问题被称为”回归问题“，回归这个词某种程度上暗示了：我们需要预测的变量是连续的。

分类问题

在分类问题中，要处理的变量是离散的，而不是连续的

下面是一组乳腺癌肿瘤的数据。下面只考虑肿瘤大小和肿瘤是恶性 (1) 还是良性 (0)

但实际情况中，会考虑多余输入变量和多个特征。下面这组数据考虑年龄和肿瘤大小来决定是良性还是恶性

其他变量特征还可能用到肿瘤的其他属性，例如肿块厚度、细胞大小的一致性、细胞形状的一致性，此外还可能用到许多医疗方面的属性

问：如果你的数据实际上存在于无限维的空间中，该怎么办？

解决：支持向量机的算法，可以把数据映射到无限维空间中

问：如何把一个无限维的向量映射到计算机内存

学习理论（learning theory）

老师没讲啥，一堆废话balabla，告诉你learning theory多么重要balabala，不学习learning theory 会导致比别人浪费很多时间，并且研究的深度无法跟学了learning theory的人相比。

无监督学习 (unsupervised learning)

本小结主要讲无监督学习，在无监督学习中，大致来说，就是给你一组数据，然后不告诉你关于数据的任何正确答案，然后问：你能在这组数据中寻找一些有趣的结构吗？

聚类问题

如下图，给一组数据，有个算法会寻找这样的结构：它将里面的数据聚成两类，

无监督学习能够应用在很多问题当中，例如基因分组。

例如使用聚类算法来进行图像处理。对于以下的一张图片，使用特定的无监督学习算法，它会学习对这些像素进行聚类。这个例子可以看出聚类算法或者无监督学习，可以对像素进行分组，它们对于计算机视觉和图像处理都很有用

再看下面这张图，

Andrew 的学生研究的问题是：是否能用这些聚类的结果，去创建这个世界的3D模型（COOL），They did it!

再看下面这张图，它们结合了监督学习和无监督学习的算法，同样也是去创建3D模型。（视频上播放的是视频）

总结：无监督学习和聚类算法可以被用在很多不同的问题上，例如计算机集群组织，社会网络分析、市场划分、航天数据分析。

鸡尾酒会问题（Cocktail party problen）

假如我们在参加一个鸡尾酒会，有很多人参加，有很多人在讲话。问：在这么多人说话的情况下，你能不能把你感兴趣的那个人的声音单独从嘈杂的背景音中提取出来？

要解决这个问题，实际上只需要一行代码

强化学习

强化学习可以用在你不需要进行一次决策的情形中。例如：利用监督学习中预测癌症的例子，对癌症的预测只有两种结果，要么恶性要么良性。

在强化学习问题中，你通常需要在一段时间内做出一系列的决策。例如：给你一台自动直升机，能否写一个程序让他飞起来。你会意识到，如果你做出了一个坏的飞行决策，飞机可能不会马上摔下来，实际上，只有当你连续做出很多坏的决策时，飞机才会摔下来。相反的，主要连续地做出一系列的总体上还不错的决策，就可以让飞机飞起来。

在强化学习的背后，基本概念是一个称为回报函数的概念。

强化学习还可以应用在机器人领域的很多问题上，可以用来网页爬取等等

如何自学人工智能

本人码农，目前在京东任职前端工程师，硕士方向为云计算，本科物理学。从昨天（2019.02.16）开始正式接触人工智能，接触机器学习，这两天看了一些相关文章，主要都是看知乎上的人工智能话题下的精华文章。今天看了吴恩达老师CS229课程的第一节课，有了点懵懵懂懂的初始。现在先把入门的自学路程撸好。

人工智能这个方式如此让人激动人心，以至于我去联系了清华的博导，希望可以跟他们读博，当然，人家都没理我

数学

先看看线性代数就好，不要试图补足数学知识再开始学习机器学习，不然需要很多时间，容易半途而废，其他的就当做选修知识

麻省理工公开课 - 线性代数
麻省理工公开课 - 线性代数参考笔记来自子实
书籍《统计学习导论》？《统计学习基础》？李航 —《统计学习方法》？
线性代数：矩阵/张量乘法、求逆，奇异值分解/特征值分解，行列式，范数等
统计与概率：概率分布，独立性与贝叶斯，最大似然(MLE)和最大后验估计(MAP)等
优化：线性优化，非线性优化(凸优化/非凸优化)以及其衍生的求解方法如梯度下降、牛顿法、基因算法和模拟退火等
微积分：偏微分，链式法则，矩阵求导等
信息论、数值理论等

机器学习入门课

机器学习入门先看吴恩达老师的就好，cs229和coursera上的，

工具

MATLAB
Python

python 引用数据类型

dict: for-in
set: add/remove
list: append/insert/pop/for-in/切片
tuple

函数

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
默认参数
可变参数
递归

切片

list/tuple/字符串等切片
倒序切片

迭代Iteration

for 循环
集合：是指包含一组元素的数据结构
enumerate
dict 的 values, itervalues, items, iteritems

list和tuple: 顺序的集合
Dict和set: 根据key访问的集合类型

有序集合：list，tuple，str和unicode；
无序集合：set
无序集合并且具有 key-value 对：dict

列表生成

range()

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

// 条件过滤
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]