数据分析系列之Python数据分析简介

Python是一门简单易学且功能强大的编程语言,使其在许多领域成为编写脚本或开发应用程序理想语言 .Python被称作"胶水语言",是由于其运行效率的问题,将程序核心部分由C++等高效率语言编写,然后各个部分由它粘合.
我们在开发中如果是新手可以先选择Windows平台,后期可以迁移至Linux平台,Linux平台自带Python,而且更容易解决第三方库依赖问题.至于语言版本我推荐使用3.x版本.

1.Windows平台环境安装

1.1安装Python

打开下载Windows x86-64 executable installer 64位安装程序,并安装完毕.

1.2安装Anaconda

Anaconda是一个方便的python包管理和环境管理软件，一般用来配置不同的项目环境,科学计算所需要的第三方模块都可以在其中获得。前往Anaconda即可下载安装，国内用户可以到下载最新版本.
TUNA 还提供了 Anaconda 仓库的镜像,菜单打开Anaconda3文件夹,打开Anaconda Prompt,运行以下命令:

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --set show_channel_urls yes

conda常用命令:

conda info --envs 获得当前环境
conda create -n your_env_name 创建新的环境,默认最新版本Python
conda create -n your_env_name python=3.5 创建指定3.5版本的Python环境
conda create -n your_env_name python=3.5 numpy pandas 创建3.5环境并且安装两个包
conda update --all 更新包信息
conda env list 查看环境列表
activate 环境名 切换环境
deactivate 退出环境
conda create -n your_env_name --clone oldname 创建一个新环境想克隆一部分旧的环境
conda remove -n your_env_name --all 删除某个环境
conda env export > environment.yml 导出环境配置（非常有用，比如你想帮朋友安装和你一模一样的环境，你可以直接导出一个配置文件给他，就能免除很多人力安装)  
conda env create -f environment.yml 当前目录生成一个environment.yml,你把它交给小伙伴或拷到另一台机器，小伙伴只需要对这个文件执行命令,就可以生成和你原来一模一样的环境啦
conda list 列举当前环境下的所有包
conda list -n packagename 列举某个特定名称包
conda install packagename 为当前环境安装某包
conda install -n envname packagename 为某环境安装某包
conda search packagename 搜索某包
conda update packagename 更新当前环境某包
conda update -n envname packagename 更新某特定环境某包
conda remove packagename 删除当前环境某包
conda remove -n envname packagename 删除某环境环境某包

2.Python使用入门

运行Python程序有两种方式,一种是直接在命令行中输入Python,直接启动程序,然后输入相关命令,exit()即可退出,第二种是通过运行py文件来执行Python程序.本文通过第二种,命令是python xxx.py,具体用法如下例:

#!/usr/bin/env python3 为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释
# -*- coding: utf-8 -*- 位于头部,表示文件中带有中文,需要使用UTF8编码,同时注意保存UTF-8格式.
# python hello.py 单行注释,以#开头
''' 多行注释,3个英文单引号'
nihaonihao
wqwqeqwewq
'''
a = 10 #整数赋值
f = 1.5 #浮点数赋值
c = "字符串" #字符串赋值
d = "I\'m ok" #字符转义
e = r'\\\\t\\\\' #不进行转义
#'''表示多行打印输出
f = True #布尔值
f and False #布尔与运算
not True #非运算
None #空值
PI = 3.14159265359 #规定常量格式
10 // 3 #地板除,只取整数部分
10 % 3 #取余数
ord('A') #获取字符整数表示
chr(66) #把编码转换为对应的字符
x = b'ABC' #bytes类型的数据用带b前缀的单引号或双引号表示
'ABC'.encode('ascii') #str通过encode()方法可以编码为指定的bytes,bytes中，无法显示为ASCII字符的字节，用\x##显示
b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8') #把bytes变为str，就需要用decode()方法
len('ABC') #计算str包含多少个字符
len(b'ABC') #len()函数就计算字节数
'Hi, %s, you have $%d.' % ('Michael', 1000000) #格式化字符串
'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)  #格式化函数
print ('hhhhh红') #控制台打印输出
classmates = ['Michael', 'Bob', 'Tracy'] #list是一种有序的集合，可以随时添加和删除其中的元素。
classmates[-1] #-1做索引，直接获取最后一个元素
classmates.append('Adam') #往list中追加元素到末尾
classmates.insert(1, 'Jack') #把元素插入到指定的位置
classmates.pop() #删除list末尾的元素
classmates.pop(1) #删除指定位置的元素
classmates[1] = 'Sarah' #把某个元素替换成别的元素，可以直接赋值给对应的索引位置
s = ['python', 'java', ['asp', 'php'], 'scheme'] #list元素也可以是另一个list
classmates = ('Michael', 'Bob', 'Tracy') #tuple一旦初始化就不能修改
t = (1,) #只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
age = 3        #条件判断
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')
s = input('birth: ') #获得输入框,输入字符串
birth = int(s)       #字符串变为数字
if birth < 2000:     #判断数字大小
    print('00前')
else:
    print('00后')
list(range(5)) #range()函数，可以生成一个整数序列，再通过list()函数可以转换为list
sum = 0 #for x in ...循环就是把每个元素代入变量x，然后执行缩进块的语句
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
print(sum)
n = 1 #只要条件满足，就不断循环，条件不满足时退出循环
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')
n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} #类似Go的map，使用键-值（key-value）存储
d['Tracy'] = 88 #修改key对应的值
'Thomas' in d #通过in判断key是否存在
d.get('Thomas', -1) #get()方法，如果key不存在，可以返回None，或者自己指定的value
d.pop('Bob') #pop(key)方法，对应的key,value也会从dict中删除
s = set([1, 1, 2, 2, 3, 3]) #一组key的集合，但不存储value,key不能重复，所以，在set中，没有重复的key.自动过滤重复key
s.add(4) #add(key)方法可以添加元素到set中
s.remove(4) #remove(key)方法可以删除元素
int('123') #内置的常用函数还包括数据类型转换函数
abs(-20) #绝对值函数
max(2, 3, 1, -5) #接收任意多个参数，并返回最大的那个
#函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
from abstest import my_abs #my_abs()的函数定义保存为abstest.py文件
def my_abs(x):
    if not isinstance(x, (int, float)): #内置函数isinstance(),参数类型做检查，只允许整数和浮点数类型的参数
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x
def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny #同时返回多个值，但其实就是一个tuple
def map(): #map函数声明,无参数
    pass   #pass 不做任何事情，一般用做占位语句。
map() #调用map函数
#把年龄和城市设为默认参数,大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数
def enroll(name, gender, age=6, city='Beijing'): 
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
def add_end(L=None): #不变对象一旦创建，对象内部的数据就不能修改
    if L is None:
        L = []
    L.append('END')
    return L
def calc(*numbers): #参数前面加*号。参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum
calc(1, 2)
calc()
nums = [1, 2, 3]
calc(*nums) #*nums表示把nums这个list的所有元素作为可变参数传进去
#函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数
def person(name, age, **kw): 
    print('name:', name, 'age:', age, 'other:', kw)
person('Adam', 45, gender='M', job='Engineer')
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)#**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra
def person(name, age, **kw): #检查是否有city和job参数
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)
def person(name, age, *, city, job): #限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数
    print(name, age, city, job)# *后面的参数被视为命名关键字参数
person('Jack', 24, city='Beijing', job='Engineer') #命名关键字参数必须传入参数名
def person(name, age, *, city='Beijing', job): #命名关键字参数city具有默认值，调用时，可不传入city参数
    print(name, age, city, job)
def person(name, age, *args, city, job): #有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*
    print(name, age, args, city, job)
#参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
#*args是可变参数，args接收的是一个tuple,**kw是关键字参数，kw接收的是一个dict。
#命名的关键字参数是为了限制调用者可以传入的参数名，同时可以提供默认值。定义命名的关键字参数在没有可变参数的情况下不要忘了写分隔符*，否则定义的将是位置参数
def fact(n): #函数在内部调用自身本身，这个函数就是递归函数
    if n==1:
        return 1
    return n * fact(n - 1)
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3]  #从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素
d = {'a': 1, 'b': 2, 'c': 3}
for key in d: #迭代key
for value in d.values(): #迭代value
for k, v in d.items(): #同时迭代key和value
from collections import Iterable # str是否可迭代
isinstance('abc', Iterable)
for i, value in enumerate(['A', 'B', 'C']): #内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身
     print(i, value)
[x * x for x in range(1, 11)] #生成列表,遍历[1,...,10]每一个,执行x*x,获得列表[1,...,100]
[x * x for x in range(1, 11) if x % 2 == 0] #[4, 16, 36, 64, 100]
[s.lower() for s in L] #把一个list中所有的字符串变成小写
g = (x * x for x in range(10)) #一边循环一边计算的机制，称为生成器
next(g) #next()函数获得generator的下一个返回值
for n in g: #获得g的每一个值
   print(n)
def odd(): #调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
from collections import Iterable #直接作用于for循环的对象统称为可迭代对象,使用isinstance()判断一个对象是否是Iterable对象,
isinstance([], Iterable)
from collections import Iterator #next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
isinstance((x for x in range(10)), Iterator) #isinstance()判断一个对象是否是Iterator对象
def add(x, y, f): #函数即变量,一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
    return f(x) + f(y)
print(add(-5, 6, abs))
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) #map()函数接收两个参数，函数，Iterable，map将传入的函数依次作用到序列的每个元素,通过list()函数让它把整个序列都计算出来并返回一个list
from functools import reduce
def add(x, y): #reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算
     return x + y
reduce(add, [1, 3, 5, 7, 9])#25
def is_odd(n): #filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素
    return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # 结果: [1, 5, 9, 15]
sorted([36, 5, -12, 9, -21], key=abs) #sorted()函数是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序
def lazy_sum(*args): #不返回求和的结果，而是返回求和的函数
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9) #f为返回的函数
f() #调用得到结果25
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) #关键字lambda表示匿名函数，冒号前面的x表示函数参数
def log(func): #在函数调用前后自动打印日志，但又不希望修改函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
    def wrapper(*args, **kw): #
        print('call %s():' % func.__name__) #函数对象有一个__name__属性，可以拿到函数的名字
        return func(*args, **kw)
    return wrapper
@log #decorator置于函数的定义处,不仅会运行now()函数本身，还会在运行now()函数前打印一行日志
def now():
    print('2015-3-25')
import functools
int2 = functools.partial(int, base=2) #functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单
# mycompany 顶层包名mycompany,维护多个包,避免模块名冲突
#├─ __init__.py #__init__.py本身就是一个模块，而它的模块名就是mycompany
#├─ abc.py   #abc.py模块的名字就变成了mycompany.abc
#└─ xyz.py   #一个.py文件就称之为一个模块（Module）
#类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等
if __name__=='__main__': #在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试
    test()
class Student(object): #class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
    pass
bart = Student() #Student类创建出Student的实例，创建实例是通过类名+()实现的
bart.name = 'Bart Simpson' #给实例bart绑定一个name属性
#类初始化方法,特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self): #类的方法
            if self.score >= 90:
                return 'A'
            else:
                return 'C'
bart = Student('Bart Simpson', 59) #必须传入初始化参数
bart.get_grade() #调用方法
class Student(object):
    def __init__(self, name, score): #属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
        self.__name = name
        self.__score = score
class Animal(object): #父类
    def run(self):
        print('Animal is running...')
class Dog(Animal): #子类,直接从Animal类继承就自动拥有了run()方法
    def eat(self): #可增加方法
            print('Eating meat...')
     def run(self): #可覆盖方法
             print('Dog is running...')
isinstance(Dog, Animal) #判断是否是一类
def set_score(self, score): #给所有实例都绑定方法，可以给class绑定方法
  self.score = score #动态绑定允许我们在程序运行的过程中动态给class加上功能
Student.set_score = set_score
class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称,只允许绑定以下属性
 class Student(object):
     @property #只读修饰器,不会暴露
     def birth(self):
         return self._birth
     @birth.setter #只写修饰器,可通过属性调用,s.bitrh = 1234
     def birth(self, value):
         self._birth = value
     @property
     def age(self):
         return 2015 - self._birth
class Dog(Mammal, Runnable): #多重继承，一个子类就可以同时获得多个父类的所有功能
    pass
 try:  #某些代码可能会出错时，就可以用try来运行这段代码，如果执行出错，则后续代码不会继续执行，而是直接跳转至错误处理代码，即except语句块，执行完except后，如果有finally语句块，则执行finally语句块
     r = 10 / 0
     print('result:', r)
 except ZeroDivisionError as e:
     print('except:', e)
 finally:
     print('finally...')
 print('END')
 #python mydict_test.py 以_test结尾 单元测试
 class TestStudent(unittest.TestCase):
     def test_80_to_100(self):
         s1 = Student('Bart', 80)
         s2 = Student('Lisa', 100)
         self.assertEqual(s1.get_grade(), 'A')
         self.assertEqual(s2.get_grade(), 'A')
 if __name__ == '__main__':
     unittest.main()

写的有点简单,但数据分析掌握这些就足够了,想要了解更多可以查看相关文档.

3.Python数据分析工具

Python本身数据分析能力并不强,所以需要借助一些第三方库来增强能力,下面介绍用Python数据挖掘用到的相关扩展库.

扩展库	简介
Numpy	提供数组支持
Scipy	提供矩阵支持
Matplotlib	数据可视化工具,作图库
Pandas	数据分析和探索工具
StatsModels	统计建模和计量经济学
Scikit-Learn	支持回归分类聚类分析的机器学习库
Keras	深度学习库
Gensim	文本主题的数据挖掘库

3.1 Numpy

Python并没有提供数组这一功能,而列表处理大量数据会速度比较慢,而Numpy处理速度是C语言级别,因此,许多其他库依赖numpy. 我使用conda安装numpy:

conda create -n Python3.7 python=3.7
conda info --envs
activate Python3.7
conda install numpy

如果没有安装conda可以直接

pip install numpy

3.2 Scipy

Numpy至多提供多维数组,而不能提供矩阵以及涉及矩阵的一系列运算,Scipy提供大量涉及矩阵的最优化,线性代数,积分,插值,拟合,快速傅里叶变换等多种计算公式,这些功能都是挖掘与计算必备的.安装它之前必须安装Numpy,以下包类似,安装方法类似numpy.

conda install scipy

以上两个模块具体测试代码为:

import numpy as nm  #以np作为numpy包的别名
from scipy import integrate #从scipy包导入integrate积分函数
def g(x): #定义被积的函数
    return (1-x**2)**0.5 
pi_2,err = integrate.quad(g,-1,1) #获得-1到1之间函数的积分结果和误差
print(pi_2*2) #结果为圆周率pi一半
a = nm.array([1,2,8,4,5]) #创建数组a[1,2,8,4,5]
print(a) #输出数组
print(a[:2] #获得前两个,切片
)
print(a.min()) #输出最小值
print(a.sort()) #数组从小到大排序
print(a)

3.3 Matplotlib

使用Matplotlib可以快速的将数据可视化,同时输出高质量的各种格式的图片.测试代码:

import numpy as np  
import matplotlib.pyplot as plt #导入绘图pyplot 
x = np.linspace(0,10,1000)  #自变量x
y = np.sin(x)+1 #因变量y
z = np.cos(x**2)+1 #因变量z
plt.rcParams['font.sans-serif']=['SimHei'] #中文黑体
plt.figure(figsize=(8,4)) #设置图像大小
plt.plot(x,y,label = '$\sin x+1$',color = 'red',linewidth = 2) #作图,设置标签,线条颜色,线条大小
plt.plot(x,z,'b--',label = '$\cos x^2+1$') #作图,设置标签,线条类型
plt.xlabel('Time(s)') #x轴名称
plt.ylabel('Volt') #y轴名称
plt.title('A Simple Example') #标题
plt.ylim(0,2.2) #显示y轴范围
plt.legend() #显示图例
plt.show() #显示作图结果

3.4 Pandas

Pandas可以说是Python最为强大的数据分析和数据探索的工具了,支持类似SQL的数据的增删改查,并且带有丰富的数据处理函数,支持处理时间序列分析功能,灵活处理缺失数据等.安装:

conda install pandas
conda install xlrd #默认pandas不支持读Excel功能
conda install xlwt #为Python加入写Excel功能

Pandas基本数据结构为Series和DataFrame,Series是一种带有索引的序列对象,DataFrame类似与数据库table有行列的数据对象,它的每一列都是Series对象.为了定位Series对象,每一个Series都存在一个Index,用来标记不同的Series元素,类似SQL的主键.DataFrame的索引对应着每一行.示例程序:

import  pandas as pd 
s = pd.Series([1,2,3],index=['a','b','c']) #创建一个序s,值123,索引abc
d = pd.DataFrame([[1,2,3],[4,5,6]],columns = ['a','b','c']) #创建一个table,表头abc,每一行123,456,索引默认0,1
d2 = pd.DataFrame(s) #用序列s生成table
d.head() #预览前5行数据
d.describe() #数据统计量 
pd.read_excel('data.xls') #读取文件,且文件存储路径不能有中文
#pd.read_csv('data.csv',encoding='utf-8')

3.5 StatsModels

Pandas着力于数据读取,处理和探索,而StatsModels更注重于数据的统计建模分析,StatsModels支持与Pandas进行数据交互,成为Python下最为强大的数据挖掘组合.

import statsmodels.api as sm    #调用statsmodels里面的api，通过api调用相当于调用了statsmodels.regression.linear_model，可以使用linear_model文件里的函数
spector_data = sm.datasets.spector.load()  #读取样例的数据集,数据集可以在文件statsmodels\datasets\spector里面找到spector.csv
spector_data.exog = sm.add_constant(spector_data.exog, prepend=False) #将spector_data里面exog增加一列常量 
# Fit and summarize OLS model
mod = sm.OLS(spector_data.endog, spector_data.exog) #使用函数OLS读入需要分析的数据，其中spector_data.endog是被拟合的数据Y， spector_data.exog是需要拟合的自变量X
res = mod.fit() #进行拟合。返回的是statsmodels.regression.linear_model.RegressionResults类型赋值给变量res
print(res.summary()) #打印变量res的结果

3.6 Scikit-Learn

Scikit-Learn是Python下强大的机器学习相关的库,提供完整的机器学习工具箱,包括数据预处理,分类,回归,聚类,预测和模型分析等.创建一个机器学习的模型比较简单:

from sklearn.linear_model import LinearRegression #导入线性回归模型
model = LinearRegression() #建立线性回归模型
print(model) 

所有模型提供的接口有:
model.fit(): 训练模型,对于监督模型来说是fit(X,y),对于非监督模型是fit(X)
监督模型提供的接口有:
model.predict(X_new):预测新样品
model.predict_proba(X_new):预测概率,仅对某些模型有用(比如LR)
model.score(): 得分越高,fit越好
非监督模型提供接口有:
model.transform():从数据中学到新的基空间
model.fit_transform():从数据中学到新的基并且将数据按照这组基进行转换

3.7 Kears

SciKit不包括人工神经网络,所以不能进行深度学习,Keras是一个用Python编写的高级神经网络API，它能够以TensorFlow,CNTK,或者Theano作为后端运行。Keras的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果，是做好研究的关键.
安装Kears:

conda install tensorflow-gpu #安装gpu加速
conda install tensorflow #安装谷歌深度学习库
conda install kears #安装kears

示例程序:

import numpy as np
np.random.seed(1337)  
from keras.models import Sequential 
from keras.layers import Dense
import matplotlib.pyplot as plt

# 创建数据集
X = np.linspace(-1, 1, 200)
np.random.shuffle(X)    # 将数据集随机化
Y = 0.5 * X + 2 + np.random.normal(0, 0.05, (200, )) # 假设我们真实模型为：Y=0.5X+2
# 绘制数据集plt.scatter(X, Y)
plt.show()

X_train, Y_train = X[:160], Y[:160]     # 把前160个数据放到训练集
X_test, Y_test = X[160:], Y[160:]       # 把后40个点放到测试集

# 定义一个model，
model = Sequential () # Keras有两种类型的模型，序贯模型（Sequential）和函数式模型
                      # 比较常用的是Sequential，它是单输入单输出的
model.add(Dense(output_dim=1, input_dim=1)) # 通过add()方法一层层添加模型
                                            # Dense是全连接层，第一层需要定义输入，
                                            # 第二层无需指定输入，一般第二层把第一层的输出作为输入

# 定义完模型就需要训练了，不过训练之前我们需要指定一些训练参数
# 通过compile()方法选择损失函数和优化器
# 这里我们用均方误差作为损失函数，随机梯度下降作为优化方法
model.compile(loss='mse', optimizer='sgd')

# 开始训练
print('Training -----------')
for step in range(301):
    cost = model.train_on_batch(X_train, Y_train) # Keras有很多开始训练的函数，这里用train_on_batch（）
    if step % 100 == 0:
        print('train cost: ', cost)

# 测试训练好的模型
print('\nTesting ------------')
cost = model.evaluate(X_test, Y_test, batch_size=40)
print('test cost:', cost)
W, b = model.layers[0].get_weights()    # 查看训练出的网络参数
                                        # 由于我们网络只有一层，且每次训练的输入只有一个，输出只有一个
                                        # 因此第一层训练出Y=WX+B这个模型，其中W,b为训练出的参数
print('Weights=', W, '\nbiases=', b)
# plotting the prediction
Y_pred = model.predict(X_test)
plt.scatter(X_test, Y_test)
plt.plot(X_test, Y_pred)
plt.show()

最后示意图为:

3.8 Gensim

Gensim负责处理语言方面的任务,例如文本相似度计算,LDA,Word2Vec等,具体使用请搜索官网.