快乐学习
前程无忧、中华英才非你莫属!

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.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
# 将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种哺乳动物的身体和大脑的平均重量。
# 让我们把它读入熊猫,并快速浏览一下:
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
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:[过度拟合的直觉解释是什么?]
# **因此,训练准确性不是对样本外精确度的一个很好的估计。**
# ![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
打赏

未经允许不得转载:同乐学堂 » Python数据分析实战2

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

特别的技术,给特别的你!

联系QQ:1071235258QQ群:226134712
error: Sorry,暂时内容不可复制!