Python数据分析实战2

第一课：从电影网站的API获取数据

# 将IMDb数据读入DataFrame中：我们需要一年的专栏！
import pandas as pd
import requests
from time import sleep
from bs4 import BeautifulSoup

movies = pd.read_csv('imdb_1000.csv')
movies.head()

# 使用请求库来与URL进行交互
r = requests.get('http://www.omdbapi.com/?apikey=19a14323&t=the shawshank redemption&r=json&type=movie')

# 检查状态：200表示成功，4xx表示错误
r.status_code

# 查看原始响应文本
r.text

# 查看原始响应文本
r.json()

# 从字典中提取年
r.json()['Year']

# 如果电影名称不被识别会怎么样？?
r = requests.get('http://www.omdbapi.com/?apikey=19a14323&t=blahblahblah&r=json&type=movie';;)
r.status_code
r.json()

# 定义一个返回年份的函数
def get_movie_year(title):
    r = requests.get('http://www.omdbapi.com/?apikey=19a14323&t=';; + title + '&r=json&type=movie')
    info = r.json()
    if info['Response'] == 'True':
        return int(info['Year'])
    else:
        return None

# 测试功能
get_movie_year('The Shawshank Redemption')
get_movie_year('blahblahblah')

# 创建一个较小的DataFrame进行测试
top_movies = movies.head().copy()

# 写一个for循环来建立一个年份列表
years = []
for title in top_movies.title:
    years.append(get_movie_year(title))
    sleep(1)

# 检查DataFrame和年份列表的长度是否相同
assert(len(top_movies) == len(years))

# 将该列表保存为新列
top_movies['year'] = years

'''
Bonus 更新DataFrame作为循环的一部分
'''

# 枚举允许您在迭代时访问项目位置
letters = ['a', 'b', 'c']
for index, letter in enumerate(letters):
    print index, letter

#DataFrames的iterrows方法是类似的
for index, row in top_movies.iterrows():
    print index, row.title

# 创建一个新的列并设置一个默认值
movies['year'] = -1

# loc方法允许您通过'label'访问DataFrame元素
movies.loc[0, 'year'] = 1994

#写一个for循环来更新前三部电影的年份
for index, row in movies.iterrows():
    if index < 3:
        movies.loc[index, 'year'] = get_movie_year(row.title)
        sleep(1)
    else:
        break

第二课、从网站上爬取网页，并解析存入pandas

# 阅读网页的HTML代码并保存为字符串
with open('example.html', 'rU') as f:
    html = f.read()

# 将HTML转换为结构化的Soup对象

b = BeautifulSoup(html)

# 打印出对象
print b
print b.prettify()

    # 'find'方法返回第一个匹配的标签（以及其中的所有内容）
b.find(name='body')
b.find(name='h1')

# 标签允许您访问“内部文本”
b.find(name='h1').text

# 标签还允许您访问其属性
b.find(name='h1')['id']

# “find_all”方法对于查找所有匹配的标签非常有用
b.find(name='p')        # 返回一个标签
b.find_all(name='p')    # 返回一个ResultSet（就像一个标签列表）

# ResultSets可以像列表一样切片
len(b.find_all(name='p'))
b.find_all(name='p')[0]
b.find_all(name='p')[0].text
b.find_all(name='p')[0]['id']

#迭代ResultSet
results = b.find_all(name='p')
for tag in results:
    print tag.text

# 限制标签属性的搜索
b.find(name='p', attrs={'id':'scraping'})
b.find_all(name='p', attrs={'class':'topic'})
b.find_all(attrs={'class':'topic'})

#限制搜索到特定的部分
b.find_all(name='li')
b.find(name='ul', attrs={'id':'scraping'}).find_all(name='li')

'''
练习一
'''

# 找到'h2'标签然后打印它的文本
b.find(name='h2').text

# 找到“feedback”的“id”值的“p”标签，然后打印其文本
b.find(name='p', attrs={'id':'feedback'}).text

# 找到第一个“p”标签，然后打印“id”属性的值
b.find(name='p')['id']

# 打印所有四个资源的文本
results = b.find_all(name='li')
for tag in results:
    print tag.text

# 只打印API资源的文本
results = b.find(name='ul', attrs={'id':'api'}).find_all(name='li')
for tag in results:
    print tag.text

# 从Shawshank Redemption页面获取HTML

r = requests.get('http://www.imdb.com/title/tt0111161/')

# 将HTML转换成soup
b = BeautifulSoup(r.text)
print b

# 如果您有编码错误，请运行此代码
import sys
reload(sys)
sys.setdefaultencoding('utf8')

b.find_all(name='span', attrs={'class':'itemprop', 'itemprop':'name'})    #结果太多了
b.find(name='span', attrs={'class':'itemprop', 'itemprop':'name'}).text   # 获得导演

b.find(name='div',attrs={'class':'title_wrapper'}).find(name='h1').text# 得到标题

# 将星级（作为一个浮点数）

float(b.find(name='span', attrs={'itemprop':'ratingValue'}).text)

'''
练习二
'''

# 得到描述
b.find(name='div', attrs={'itemprop':'description'}).text.strip()

# 获得内容评级
b.find(name='meta', attrs={'itemprop':'contentRating'})['content']

#获得分钟的持续时间（作为一个整数）
str(b.find(name='time', attrs={'itemprop':'duration'})['datetime'][2:-1])

'''
定义一个接受IMDb ID并返回一个字典的函数
电影信息：标题，星级，说明，content_rating，持续时间
'''

# 定义一个接受IMDb ID并返回电影信息字典的函数
def get_movie_info(imdb_id):
    r = requests.get('http://www.imdb.com/title/';; + imdb_id + '/')
    b = BeautifulSoup(r.text)
    info = {}
    info['title'] = b.find(name='div',attrs={'class':'title_wrapper'}).find(name='h1').text
    info['star_rating'] = float(b.find(name='span', attrs={'itemprop':'ratingValue'}).text)
    info['description'] = b.find(name='div', attrs={'itemprop':'description'}).text.strip()
    info['content_rating'] = b.find(name='meta', attrs={'itemprop':'contentRating'})['content']
    info['duration'] = str(b.find(name='time', attrs={'itemprop':'duration'})['datetime'][2:-1])
    return info

# 测试方法
get_movie_info('tt0109830')

# 打开ID文件（每行一个ID），并将ID存储在一个列表中
imdb_ids = []
with open('imdb_ids.txt', 'rU') as f:
    imdb_ids = [row.strip() for row in f]

imdb_ids

# 获取每部电影的信息，并将结果存储在列表中
from time import sleep
movies = []
for imdb_id in imdb_ids:
    movies.append(get_movie_info(imdb_id))
    sleep(1)

movies

# 检查ID列表和电影列表长度是否相同
assert(len(imdb_ids) == len(movies))

# 将电影列表转换为DataFrame
import pandas as pd

pd.DataFrame(movies, index=imdb_ids)

第三课、探索偏差 - 方差权衡

import pandas as pd
import numpy as np
import seaborn as sns

# ## 大脑和体重

# 这是一个[数据集]（http://people.sc.fsu.edu/~jburkardt/datasets/regression/x01.txt）62种哺乳动物的身体和大脑的平均重量。
# 让我们把它读入熊猫，并快速浏览一下：

url = 'http://people.sc.fsu.edu/~jburkardt/datasets/regression/x01.txt';;
col_names = ['id', 'brain', 'body']
mammals = pd.read_table(url, sep='\s+', skiprows=33, names=col_names, index_col='id') #skiprowss 跳过33行
mammals.head()

mammals.describe() #统计信息

# 我们将重点关注体重小于200的一个较小的子集：

# 只保留体重小于200的排
mammals = mammals[mammals.body < 200]
mammals.shape

# 我们现在假装现在只有51种哺乳动物。 换句话说，我们假装这是每个已知哺乳动物物种**的整个脑和体重数据集。
# 让我们创建一个散点图
sns.lmplot(x='body', y='brain', data=mammals, ci=None, fit_reg=False)

# 哺乳动物的脑和体重之间似乎有一定的关系。

# ## 做一个预测

# 现在让我们假装发现了一种新的哺乳动物物种**。
#  我们测量我们可以找到的这个物种的每个成员的体重，并计算**的平均体重。
# 我们要**预测这个物种的平均脑重**（而不是直接测量）。 我们如何做到这一点？
sns.lmplot(x='body', y='brain', data=mammals, ci=None)

#我们画了一条直线，似乎最能捕捉到大脑和体重之间的关系。因此，我们可以预测，我们的新物种的脑重约45，因为这是x = 100时的近似y值。

#这被称为“线性模型”或“线性回归模型”，我们将在未来的课堂上学习。
##从样本中进行预测
# 早些时候，我说这个数据集包含了每一个已知的哺乳动物物种。这很方便，但是在现实世界中，你所拥有的仅仅是一个数据样本**。
# 一个更现实的情况是只有大脑和体重（比方说）51个已知哺乳动物的一半。
# 当发现新的哺乳动物（体重为100）时，我们仍然要对脑重做出准确的预测，但是这个任务可能会更困难，因为我们没有所有的数据理想喜欢有。
# 让我们模拟这种情况，将51个观测值分别分配给** 1或者2个宇宙**：

# 设置一个随机的种子重现性
np.random.seed(12345)

# 随机分配每个观察宇宙1或宇宙2
mammals['universe'] = np.random.randint(1, 3, len(mammals))
mammals.head()

# ＃**重要：**我们只住在两个宇宙中的一个。
# 这两个宇宙都有51种已知的哺乳动物物种，但是每个宇宙都知道不同物种的大脑和体重。
# ＃我们现在可以告诉Seaborn创建两个图，其中左边的图仅使用来自** universe 1 **的数据，右边的图只使用来自** universe 2 **的数据：

# col ='universe'按宇宙对数据进行分组，并创建两个独立的图
sns.lmplot(x='body', y='brain', data=mammals, ci=None, col='universe')

#这两条曲线看起来非常相似，尽管他们使用了单独的数据样本。 在这两种情况下，我们都可以预测脑重约45。

#通过将它们放在同一个图上，可以更容易地看到相似程度：

#hue ='universe'根据宇宙对数据进行子集并创建一个图
sns.lmplot(x='body', y='brain', data=mammals, ci=None, hue='universe')

# 这个练习的重点是什么？ 这是一个高偏见，低方差模型的视觉演示：
# 这是**高偏见**，因为它不适合数据特别好。
# 这是**低的方差**，因为它不会有太大的变化，取决于在那个宇宙中哪些观察结果是可用的。
# 让我们尝试一些完全不同的东西
# 低偏差，高方差**模型会是什么样子？ 让我们用一个八阶多项式来尝试多项式回归：

sns.lmplot(x='body', y='brain', data=mammals, ci=None, col='universe', order=8)

# ＃ - 这是**低偏见**因为模型匹配数据相当好！
# ＃ - 它是**高方差**，因为这些模型根据宇宙中哪些观察结果可用而有很大的不同。
# （对于100的体重，脑重预测将在一个宇宙中为40，在另一个宇宙中为0）
# ＃##我们能找到一个中间地带吗？
#
# ＃也许我们可以创建一个比**线性模型**偏差小的模型，**比八次多项式**更少**。
# ＃
# ＃我们来尝试一个二阶多项式：
sns.lmplot(x='body', y='brain', data=mammals, ci=None, col='universe', order=2)

第四课、K-最近的邻居和scikit-learn

# 将 iris data读入DataFrame
import pandas as pd
url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data';;
col_names = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']
iris = pd.read_csv(url, header=None, names=col_names)

iris.head()

import matplotlib.pyplot as plt

# 增加默认图形和字体大小以便于查看
plt.rcParams['figure.figsize'] = (6, 4)
plt.rcParams['font.size'] = 14

# 创建一个自定义颜色映射
from matplotlib.colors import ListedColormap
cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])

# 将每个鸢尾花物种映射到一个数字
iris['species_num'] = iris.species.map({'Iris-setosa':0, 'Iris-versicolor':1, 'Iris-virginica':2})

# 根据物种创建花瓣长度与花瓣宽度和颜色的散点图
iris.plot(kind='scatter', x='petal_length', y='petal_width',
          c='species_num', colormap=cmap_bold)

# 创建一个萼片长度与萼片宽度和各种颜色的散点图
iris.plot(kind='scatter', x='sepal_length', y='sepal_width',
          c='species_num', colormap=cmap_bold)
iris.head()

# 将特征矩阵存储在“X”
feature_cols = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
X = iris[feature_cols]

# 替代方法来创建“X”
X = iris.drop(['species', 'species_num'], axis=1)
X = iris.loc[:, 'sepal_length':'petal_width']
X = iris.iloc[:, 0:4]

# store response vector in "y"
y = iris.species_num

# 检查X的类型
print type(X)
print type(X.values)

# 检查y的类型
print type(y)
print type(y.values)

# 检查X的形状（n =观察数量，p =特征数量）
print X.shape

# 检查y的形状（长度为n的单维）
print y.shape

# ## scikit-learn的4步建模模式

# **Step 1:** 导入你打算使用的类

from sklearn.neighbors import KNeighborsClassifier

# **步骤2：**“实例化”“估计器”
# - “Estimator”是scikit-learn的术语“模型”
# - “实例化”是指“创建一个实例”
# ＃制作一个KNeighborsClassifier对象的实例

knn = KNeighborsClassifier(n_neighbors=1)
type(knn)

# - 创建一个“知道”如何做K最近邻分类的对象，只是在等待数据
# - 对象的名称不重要
# - 在此步骤中可以指定调整参数（又名“超参数”）
# - 未指定的所有参数都设置为其默认值

print knn

#**步骤3：**将模型与数据（也称为“模型训练”）相匹配
# - 模型是在我们的“训练数据”中“学习”X和y之间的关系，
# - 学习发生的过程因型号而异
# - 发生在原地
knn.fit(X, y)

# 一旦模型适合数据，就称为“拟合模型”
#
# **步骤4：**预测新观测的响应
#  - 新的观察被称为“样本外”数据
#  - 使用模型训练过程中学到的信息

#- 返回一个NumPy数组，我们跟踪数字“意味着什么”
#- 可以一次预测多个观测值

X_new = [[3, 5, 4, 2], [5, 4, 3, 2]]
knn.predict(X_new)

###调整一个KNN模型

#实例化模型（使用值K = 5）

knn = KNeighborsClassifier(n_neighbors=5)

# 用数据拟合模型
knn.fit(X, y)

# 预测新观察的响应
knn.predict(X_new)

knn.predict_proba(X_new)

##比较KNN和其他算法模型
# ** KNN的优势：**
# - 简单理解和解释
# - 模特训练很快
# - 可以用于分类和回归

# ** KNN的缺点：**
#  - 必须存储所有的训练数据
#  当n很大时，预测阶段会变慢
# - 敏感的不相关的功能
#  - 对数据的规模敏感
#  - 准确性（一般）不与最好的监督学习方法竞争

第五课、KNN算法分析NBA球员数据

# # KNN运动与NBA球员数据

# **进球：**使用助攻，抢断，盖帽，失误和个人犯规来预测球员的位置
# 步骤1：将数据读入Pandas
# 将数据读入DataFrame

import pandas as pd

nba = pd.read_csv('NBA_players_2015.csv',index_col=0)

# 检查列
nba.columns

# 检查位置
nba.pos.value_counts()

# 步骤2：创建X和y
# ＃使用以下功能：助攻，抢断，盖帽，失误，个人犯规
#
# ＃将位置映射到数字
nba['pos_num'] = nba.pos.map({'C':0, 'F':1, 'G':2})

#创建特征矩阵（X）
feature_cols = ['ast', 'stl', 'blk', 'tov', 'pf']
X = nba[feature_cols]

# 替代方法来创建X
X = nba.loc[:, 'ast':'pf']

# 创建响应向量（y）
y = nba.pos_num

# ## 第三步：训练一个KNN模型（K = 5）

# import class
from sklearn.neighbors import KNeighborsClassifier

# 用K = 5来实例化
knn = KNeighborsClassifier(n_neighbors=5)

# 符合数据
knn.fit(X, y)

#步骤4：预测玩家位置并计算每个位置的预测概率
# 预测这些统计数据：1次助攻，1次抢断，0次封盖，1次失误，2次犯规

# 创建一个列表来表示一个玩家
player = [[1, 1, 0, 1, 2]]

# 做一个预测
knn.predict(player)

# 计算预测概率
knn.predict_proba(player)

##步骤5：使用K = 50重复步骤3和4

# 重复K = 50
knn = KNeighborsClassifier(n_neighbors=50)
knn.fit(X, y)
knn.predict(player)

# 计算预测概率
knn.predict_proba(player)  #测试数据X的返回概率估计。

##奖金：探索功能，以决定哪些是预测性的

# 允许重复出现在笔记本中
import matplotlib.pyplot as plt

# 增加默认图形和字体大小以便于查看
plt.rcParams['figure.figsize'] = (6, 4)
plt.rcParams['font.size'] = 14

# 按位置分组的助攻说明
nba.groupby('pos').ast.describe().unstack()

# 按位置分组的助攻盒图
nba.boxplot(column='ast', by='pos')

# 按位置分组的助攻直方图
nba.hist(column='ast', by='pos', sharex=True)

第六课、模型评估

#**解决方案：**创建一个程序**估计**模型可能对样本外数据执行的可能性以及如何在模型之间进行选择。
#**注意：**这些程序可以与**任何机器学习模式**一起使用，不仅仅是KNN。
##评估程序＃1：训练和测试整个数据集
# ＃1.在整个数据集**上训练模型。
# ＃2.在相同数据集**上测试模型，并通过比较**预测**响应值和**真实**响应值来评估我们做得如何。

import pandas as pd
nba = pd.read_csv('NBA_players_2015.csv',index_col=0)

#将位置映射到数字
nba['pos_num'] = nba.pos.map({'C': 0, 'F': 1, 'G': 2})

# 创建特征矩阵（X）
feature_cols = ['ast', 'stl', 'blk', 'tov', 'pf']
X = nba[feature_cols]

# 创建响应向量（y）
y = nba.pos_num

### KNN (K=50)

from sklearn.neighbors import KNeighborsClassifier

# 实例化模型
knn = KNeighborsClassifier(n_neighbors=50)

# 在整个数据集上训练模型
knn.fit(X, y)

# 预测X中观测值的响应值（“测试模型”）
knn.predict(X)

# 存储预测的响应值
y_pred_class = knn.predict(X)

# 要评估一个模型，我们还需要一个**评估指标：**
#  - 用于量化模型性能的数字计算
#  - 适当的指标取决于你的问题的**目标**
# 分类问题最常见的选择：
#  **分类准确度**：正确预测的百分比（“奖励函数”，因为越高越好）
#  **分类错误**：错误预测的百分比（“损失函数”，因为越低越好）
# 在这种情况下，我们将使用分类准确性。

#计算分类准确度

from sklearn import metrics

print metrics.accuracy_score(y, y_pred_class)

#这被称为**训练准确性**，因为我们正在用我们用来训练模型的相同数据来评估模型。

# ### KNN (K=1)

knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(X, y)
y_pred_class = knn.predict(X)
print metrics.accuracy_score(y, y_pred_class)

#在相同的数据上进行培训和测试的问题
#- 目标是估计**样本外的数据的可能性能**
#- 但是，最大限度地提高训练准确性奖励**过于复杂的模型**不一定一概而论
#- 不必要的复杂模型** overfit **训练数据：
#- 使用样本内数据进行测试时效果会很好
#- 对样本外的数据可能做得不好
#- 学习数据中的“噪音”，而不是“信号”
#- 来自Quora：[过度拟合的直觉解释是什么？]
# （http://www.quora.com/What-is-an-intuitive-explanation-of-overfitting/answer/Jessica-Su）
# **因此，训练准确性不是对样本外精确度的一个很好的估计。**
# ！[1NN分类图]（images / iris_01nn_map.png）
###评估程序＃2：培训/测试拆分
# ＃1.将数据集分成两部分：一个**训练集**和一个**测试集**。
# ＃2.在**训练集**上训练模型。
# ＃3.在**测试集**上测试模型，并评估我们做得如何。

# 这完成了什么？
# 模型可以在**不同的数据**上进行训练和测试（我们将测试数据视为超出样本数据）。
#  - 测试集的响应值是已知的，因此可以评估**预测。
# 这被称为**测试准确性**，因为我们正在模型训练中未使用的独立“测试集”上评估模型。

# **测试精度是训练精度比样本外性能更好的估计。**

def min_max(nums):
    smallest = min(nums)
    largest = max(nums)
    return [smallest, largest]

min_and_max = min_max([1, 2, 3])
print min_and_max
print type(min_and_max)

the_min, the_max = min_max([1, 2, 3])
print the_min
print type(the_min)
print the_max
print type(the_max)

# ### 了解`train_test_split`函数

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y)

# 在分裂之前
print X.shape

# 分裂后
print X_train.shape
print X_test.shape

#在分裂之前
print y.shape

# 分裂后
print y_train.shape
print y_test.shape

# ### 了解`random_state`参数

# 没有一个random_state参数
X_train, X_test, y_train, y_test = train_test_split(X, y)

#打印每个对象的第一个元素
print X_train.head(1)
print X_test.head(1)
print y_train.head(1)
print y_test.head(1)

#用一个random_state参数
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=99)

# 打印每个对象的第一个元素
print X_train.head(1)
print X_test.head(1)
print y_train.head(1)
print y_test.head(1)

# ###使用train/test 拆分程序（K = 1）

# 步骤1：将X和y分成训练和测试集（使用random_state进行再现）
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=99)

# 步骤2：在训练集上训练模型（使用K = 1）
knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(X_train, y_train)

# 步骤3：在测试装置上测试模型，并检查准确性
y_pred_class = knn.predict(X_test)
print metrics.accuracy_score(y_test, y_pred_class)

# ### 重复K = 50

knn = KNeighborsClassifier(n_neighbors=50)
knn.fit(X_train, y_train)
y_pred_class = knn.predict(X_test)
print metrics.accuracy_score(y_test, y_pred_class)

# ！[偏差方差折衷]（images / bias_variance.png）
####比较测试精度和零精度
# 空值准确度是通过**始终预测最频繁的班级**所能达到的准确度。 这是您可能想要测量您的分类模型的基准。
#检查class分布
y_test.value_counts()

#计算null精度
y_test.value_counts().head(1) / len(y_test)

# ### 寻找K的“最佳”值

# 计算K = 1到100的TRAINING ERROR和TESTING ERROR

k_range = range(1, 101)
training_error = []
testing_error = []

for k in k_range:
    # 用当前K值实例化模型
    knn = KNeighborsClassifier(n_neighbors=k)

    # 计算训练错误
    knn.fit(X, y)
    y_pred_class = knn.predict(X)
    training_accuracy = metrics.accuracy_score(y, y_pred_class)
    training_error.append(1 - training_accuracy)

    # 计算测试错误
    knn.fit(X_train, y_train)
    y_pred_class = knn.predict(X_test)
    testing_accuracy = metrics.accuracy_score(y_test, y_pred_class)
    testing_error.append(1 - testing_accuracy)

# 让情节出现在笔记本中
import matplotlib.pyplot as plt

plt.style.use('fivethirtyeight')

# 创建K的DataFrame，训练错误和测试错误
column_dict = {'K': k_range, 'training error': training_error, 'testing error': testing_error}
df = pd.DataFrame(column_dict).set_index('K').sort_index(ascending=False)
df.head()

#绘制K（HIGH TO LOW）和TESTING ERROR之间的关系
df.plot(y='testing error')
plt.xlabel('Value of K for KNN')
plt.ylabel('Error (lower is better)')

# 找到最小的测试误差和相关的K值
df.sort_values('testing error').head()

# 替代方法
min(zip(testing_error, k_range))

#我们可以得出什么结论？
#在使用这些特征的数据集上使用KNN时，K **的**最佳值可能在14左右。
#给定**未知玩家**的统计数据，我们估计我们能够在74％的时间内正确地预测他的位置。
###训练错误与测试错误
#绘制K（高到低）和TRAINING ERROR和TESTING ERROR之间的关系
df.plot()
plt.xlabel('Value of K for KNN')
plt.ylabel('Error (lower is better)')

# **培训错误**随着模型复杂度的增加而降低（K值越低）
# **测试错误**在最佳模型复杂度下最小化
# [偏差方差折衷]（images / training_testing_error.png）
###对超出样本的数据进行预测
#根据一个（真正）未知的球员的统计数据，我们如何预测他的位置？
#用已知最好的参数实例化模型

knn = KNeighborsClassifier(n_neighbors=14)

# 为什么重新训练模型用X和Y（不是X_train和y_train）？
knn.fit(X, y)

# 对样本外观察进行预测
knn.predict([[1, 1, 0, 1, 2]])

###traning/test拆分的缺点？
#如果`train_test_split`函数以不同的方式分割数据会发生什么？ 我们会得到和以前一样的确切结果吗？
#为random_state尝试不同的值

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=98)
knn = KNeighborsClassifier(n_neighbors=50)
knn.fit(X_train, y_train)
y_pred_class = knn.predict(X_test) 
print metrics.accuracy_score(y_test, y_pred_class)

#测试准确性是样本外精度的**高方差估计**
# ** K倍交叉验证**克服了这个限制，并提供了更可靠的估计
# - 但是，train/test 拆分仍然是有用的，因为它**的灵活性和速度*

教程来源：https://github.com/justmarkham/DAT8 作者：Kevin Markham

打赏

微信扫一扫，打赏作者吧～