利用Python练习数据挖掘实例
主要内容有（嘿嘿，手动严肃）：
导入和可视化数据；数据分类；使用回归分析和相关测量法发现数据之间的关系；数据降维以压缩和可视化数据带来的信息
文章中的代码基于四个主要的Python数据分析和处理的类库：numpy，matplotlib，sklearn和networkx。
数据导入和可视化
# 从网上下载数据并保存
import urllib2
url = 'http://aima.cs.berkeley.edu/data/iris.csv'
u = urllib2.urlopen(url)
localFile = open('iris.csv','w')
localFile.write(u.read())
localFile.close()
数据集以CSV(逗号分割值）的格式存储。CSV文件可以很方便的转化并把其中的信息存储为适合的数据结构。此数据集有5列，前4列包含着特征值，最后一列代表着样本类型。CSV文件很容易被numpy类库的genfromtxt方法解析：
# 创建了一个包含特征值的矩阵以及一个包含样本类型的向量。
from numpy import genfromtxt, zeros
# read the first 4 columns
data = genfromtxt('iris.csv',delimiter=',',usecols=(0,1,2,3))
# read the fifth column
target = genfromtxt('iris.csv',delimiter=',',usecols=(4),dtype=str)
在上面的例子中我们创建了一个包含特征值的矩阵以及一个包含样本类型的向量。我们可以通过查看我们加载的数据结构的shape值来确认数据集的大小：
# 通过查看我们加载的数据结构的shape值来确认数据集的大小：
print data.dtype
print data.shape
print target.shape
# 查看我们有多少种样本类型以及它们的名字：
print set(target) # build a collection of unique elements
set(['setosa', 'versicolor', 'virginica'])
当我们处理新数据的时候，一项很重要的任务是尝试去理解数据包含的信息以及它的组织结构。可视化可以灵活生动的展示数据，帮助我们深入理解数据。
使用pylab类库（matplotlib的接口）的plotting方法可以建一个二维散点图让我们在两个维度上分析数据集的两个特征值：
# 建立一个二维散点图让我们在两个维度上分析数据集的两个特征值：
from pylab import plot, show
% matplotlib inline
plot(data[target=='setosa',0],data[target=='setosa',2],'bo')
plot(data[target=='versicolor',0],data[target=='versicolor',2],'ro')
plot(data[target=='virginica',0],data[target=='virginica',2],'go')
在上图中有150个点，不同的颜色代表不同的类型；蓝色点代表山鸢尾，红色点代表变色鸢尾，绿色点代表维吉尼亚鸢尾。
另一种常用的查看数据的方法是分特性绘制直方图。在本例中，既然数据被分为三类，我们就可以比较每一类的分布特征。下面这个代码可以绘制数据中每一类型的第一个特性（花萼的长度）：
from pylab import figure, subplot, hist, xlim, show
xmin = min(data[:,0])
xmax = max(data[:,0])
subplot(411) # distribution of the setosa class (1st, on the top)
hist(data[target=='setosa',0],color='b',alpha=.7)
xlim(xmin,xmax)
subplot(412) # distribution of the versicolor class (2nd)
hist(data[target=='versicolor',0],color='r',alpha=.7)
xlim(xmin,xmax)
subplot(413) # distribution of the virginica class (3rd)
hist(data[target=='virginica',0],color='g',alpha=.7)
xlim(xmin,xmax)
subplot(414) # global histogram (4th, on the bottom)
hist(data[:,0],color='y',alpha=.7)
xlim(xmin,xmax)
sklearn类库包含很多分类器的实现，我们将会用高斯朴素贝叶斯来分析我们在第一章载入的鸢尾花数据，包含山鸢尾、变色鸢尾和维吉尼亚鸢尾。
# 把字符串数组转型成整型数据：
t = zeros(len(target))
t[target == 'setosa'] = 1
t[target == 'versicolor'] = 2
t[target == 'virginica'] = 3
## 分类器实例化和训练分类器的准备了：
from sklearn.naive_bayes import GaussianNB
classifier = GaussianNB()
classifier.fit(data,t) # training on the iris dataset
GaussianNB()
很简单的检测：
# 很简单的检测：
# 分类器可以由predict方法完成，并且只要输出一个样例就可以很简单的检测：
print classifier.predict(data[0])
print t[0]
/Users/wente/anaconda/lib/python2.7/site-packages/sklearn/utils/validation.py:386: DeprecationWarning: Passing 1d arrays as data is deprecated in 0.17 and willraise ValueError in 0.19. Reshape your data either using X.reshape(-1, 1) if your data has a single feature or X.reshape(1, -1) if it contains a single sample.
DeprecationWarning)
拆分训练集和测试集
上面的测试使用了训练集的数据，但是在广泛的样本上评估分类器并且使用非训练环节的数据测试是很重要的。最终我们通过从源数据集中随机抽取样本把数据分为训练集和测试集。我们将会使用训练集的数据来训练分类器，并使用测试集的数据来测试分类器。train_test_split方法正是实现此功能的：
# 从样本中随机的按比例选取train data和test data。
from sklearn import cross_validation
train, test, t_train, t_test = cross_validation.train_test_split(data, t, test_size=0.4, random_state=0)
数据集被分一分为二，测试集被指定为源数据的40%（命名为test_size），random_state是随机数的种子。不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
下面就是利用其反复训练我们的分类器并输出精确度
classifier.fit(train,t_train) # train
GaussianNB()
评价：精确度
print classifier.score(test,t_test) # test
上面得出精确度为93%。一个分类器的精确度是通过正确分类样本的数量除以总样本的数量得出的。也就是说，它意味着我们正确预测的比例。
评价：混淆矩阵
另一个估计分类器表现的工具叫做混淆矩阵。在此矩阵中每列代表一个预测类的实例，每行代表一个实际类的实例。
from sklearn.metrics import confusion_matrix
print confusion_matrix(classifier.predict(test),t_test)
混淆矩阵的评价：所有正确的预测都在表格的对角线上，的错误就即对角线以外的非零值。
在这个混淆矩阵中我们可以看到所有山鸢尾和维吉尼亚鸢尾都被正确的分类了，但是实际上应该是26个的变色鸢尾，系统却预测其中4个是维吉尼亚鸢尾。如果
评价：分类器性能报告
from sklearn.metrics import classification_report
print classification_report(classifier.predict(test), t_test, target_names=['setosa', 'versicolor', 'virginica'])
versicolor
avg / total
以下是该报告使用到的方法总结：
Precision：正确预测的比例
Recall（或者叫真阳性率）：正确识别的比例
F1-Score：precision和recall的调和平均数
评价：交叉验证
思想：多次将数据分为不同的训练集和测试集，最终分类器评估选取多次预测的平均值。方法：
from sklearn.cross_validation import cross_val_score
# cross validation with 6 iterations
scores = cross_val_score(classifier, data, t, cv=6)
print scores
输出是每次模型迭代产生的精确度的数组。我们可以很容易计算出平均精确度：
from numpy import mean
print mean(scores)
是一种无监督数据分析，下面就是最著名的聚类工具k-means算法
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=3, init='random') # initialization
kmeans.fit(data) # actual execution
KMeans(copy_x=True, init='random', max_iter=300, n_clusters=3, n_init=10,
n_jobs=1, precompute_distances='auto', random_state=None, tol=0.0001,
verbose=0)
上面运行k-measn算法并把数据分为三个群集（参数n_clusters所指定的）。下面使用模型把每一个样本分配到三个群集中：
c = kmeans.predict(data)
评估：完整性得分、同质性得分
估计群集的结果，与使用完整性得分和同质性得分计算而得的标签作比较：
大部分数据点属于一个给定的类并且属于同一个群集，那么完整性得分就趋向于1。
当所有群集都几乎只包含某个单一类的数据点时同质性得分就趋向于1.
from sklearn.metrics import completeness_score, homogeneity_score
print completeness_score(t,c)
print homogeneity_score(t,c)
评估：结果可视化
subplot(211) # top figure with the real classes
plot(data[t==1,0],data[t==1,2],'bo')
plot(data[t==2,0],data[t==2,2],'ro')
plot(data[t==3,0],data[t==3,2],'go')
subplot(212) # bottom figure with classes assigned automatically
plot(data[c==2,0],data[c==2,2],'bo',alpha=.7)
plot(data[c==1,0],data[c==1,2],'go',alpha=.7)
plot(data[c==0,0],data[c==0,2],'mo',alpha=.7)
观察此图我们可以看到，底部左侧的群集可以被k-means完全识别，然而顶部的两个群集有部分识别错误。
回归是一个用于预测变量之间函数关系调查的方法。例如，我们有两个变量，一个被认为是解释，一个被认为是依赖。我们希望使用模型描述两者的关系。当这种关系是一条线的时候就称为线性回归。
# 构建数据集
from numpy.random import rand
x = rand(40,1) # explanatory variable
y = x*x*x+rand(40,1)/5 # depentend variable
from sklearn.linear_model import LinearRegression
linreg = LinearRegression()
linreg.fit(x,y)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)
评估：结果可视化
把拟合线和实际数据点画在同一幅图上来评估结果：
from numpy import linspace, matrix
xx = linspace(0,1,40) # 产生0-1之间40个数，步长相等
plot(x,y,'go')
plot(xx,linreg.predict(matrix(xx).T),'--r')
评估：均方误差
使用均方误差来量化模型和原始数据的拟合度：
该指标度量了预期的拟合线和真实数据之间的距离平方。当拟合线很完美时该值为0。
from sklearn.metrics import mean_squared_error
print mean_squared_error(linreg.predict(x),y)
最著名的降维技术之一就是主成分分析（PCA）。该技术把数据变量转换为等量或更少的不相关变量，称为主成分（PCs）。
下面我们实例化了一个PCA对象，用于计算前两个主成分。
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
转换计算如下：
将原来的四维数据转换为两维
pcad = pca.fit_transform(data)
结果可视化
## 原来的数据
subplot(121)
plot(data[target=='setosa',0],data[target=='setosa',2],'bo')
plot(data[target=='versicolor',0],data[target=='versicolor',2],'ro')
plot(data[target=='virginica',0],data[target=='virginica',2],'go')
## 降维后的数据
subplot(122)
plot(pcad[target=='setosa',0],pcad[target=='setosa',1],'bo')
plot(pcad[target=='versicolor',0],pcad[target=='versicolor',1],'ro')
plot(pcad[target=='virginica',0],pcad[target=='virginica',1],'go')
两个图有些相似，降维后，变色鸢尾（红色的）和维吉尼亚鸢尾（绿色的）的间隔更清晰了。
信息量判断
#方差比判断PCs包含的信息量：
print pca.explained_variance_ratio_
# 输出在转化过程中丢失的信息量
print 1-sum(pca.explained_variance_ratio_)
# 通过改变主成分的数值来计算我们能够覆盖多少信息量
for i in range(1,5):
pca = PCA(n_components=i)
pca.fit(data)
print sum(pca.explained_variance_ratio_) * 100,'%'
可以发现PCs用得越多，信息覆盖就越全，
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。阅读(...) 评论()有哪些适合新手练手的Python项目？
我的图书馆
有哪些适合新手练手的Python项目？
学习编程专栏连载编程新手练手项目系列之python项目篇，同样也欢迎热爱学习、对Java感兴趣的朋友学习翻阅上两篇内容。（连载系列的项目整理以后会在每个月进行一次重新整理，也欢迎大家进行项目的投稿，投稿请私信我。）Python毫无疑问是一门很伟大的语言，最近几年，很多人都在Python的世界里转悠。也有很多对编程有着浓厚的兴趣但是不是相关专业的朋友开始学习Python，这固然是好事情。但是很多时候，你只是看到了一棵树，你以为你看到的是整个森林，尤其对于非专业的朋友来说。因此，做一些练手的项目就显得尤为重要。一来让你知道你所学习的Python真的只是皮毛，二来巩固一下你所学习的基础知识。首先推荐两个回答，以下两个回答的练手项目很多，你可以选择一一练习：众所周知Python擅长很多方面，一篇文章中也无法面面俱到，于是今天关于Python的项目答题分为以下几方面：Python Web开发、Python 做小游戏、Python爬虫实例一：满分推荐，非常值得练习实例二：一步一步的做web app，解释以及源码实例三：web机器人，源码下载实例四：web网站开发实战，源码下载 实例五：在线问答系统，源码解读下载实例六： 博客系统，源码解读下载 实例七：论坛系统，视频课程观看练习实例八：成绩管理系统，源码下载实例九：新闻系统，源码解读下载实例一：2048小游戏，源码解读下载 实例二：街机小游戏，源码解读下载实例三：贪吃蛇小游戏，源码解读下载 实例四：扫雷小游戏，源码解读下载实例五：数独游戏，源码解读下载实例六：五子棋游戏，源码下载实例七：24点游戏，源码解读下载实例一：那啥，源码解读下载实例二：抓取淘宝照片，源码解读下载实例三：抓取淘宝订单，源码解读下载 实例四：微信开发，源码解读下载实例五：爬取知乎，源码解读下载实例六：模拟登录一些主流网站，源码下载 实例六：多个实例源码，更多请访问主页实例七：豆瓣爬取实例，源码下载1、以下专栏的很多文章都值得大家练习使用（不一一举例，大家可以自行查找阅读练习）2、其它一些（待更新） 是一个高质量的技术社区，从 Swift 到 React Native，性能优化到开源类库，让你不错过互联网开发的每一个技术干货。当然你可以选择下载他们的app：点击或者各大应用市场搜索「掘金」，技术干货尽在掌握中。赶紧去看看吧。
TA的推荐TA的最新馆藏
喜欢该文的人也喜欢教程| 如何从TensorFlow转入PyTorch
教程| 如何从TensorFlow转入PyTorch
选自Medium作者：Illarion Khlestov机器之心编译参与：李泽南、黄小天当我第一次尝试学习 PyTorch 时，没几天就放弃了。和 TensorFlow 相比，我很难弄清 PyTorch 的核心要领。但是随后不久，PyTorch 发布了一个新版本，我决定重新来过。在第二次的学习中，我开始了解这个框架的易用性。在本文中，我会简要解释 PyTorch 的核心概念，为你转入这个框架提供一些必要的动力。其中包含了一些基础概念，以及先进的功能如学习速率调整、自定义层等等。PyTorch 的易用性如何？Andrej Karpathy 是这样评价的资源首先要知道的是：PyTorch 的主目录和教程是分开的。而且因为开发和版本更新的速度过快，有时候两者之间并不匹配。所以你需要不时查看源代码：http://pytorch.org/tutorials/。当然，目前网络上已有了一些 PyTorch 论坛，你可以在其中询问相关的问题，并很快得到回复：https://discuss.pytorch.org/。把 PyTorch 当做 NumPy 用让我们先看看 PyTorch 本身，其主要构件是张量——这和 NumPy 看起来差不多。这种性质使得 PyTorch 可支持大量相同的 API，所以有时候你可以把它用作是 NumPy 的替代品。PyTorch 的开发者们这么做的原因是希望这种框架可以完全获得 GPU 加速带来的便利，以便你可以快速进行数据预处理，或其他任何机器学习任务。将张量从 NumPy 转换至 PyTorch 非常容易，反之亦然。让我们看看如下代码：import
torchimport
npnumpy_tensor
)# convert numpy array to pytorch arraypytorch_tensor
numpy_tensor
)# or another waypytorch_tensor
from_numpy
numpy_tensor
)# convert torch tensor to numpy representationpytorch_tensor
()# if we want to use tensor on GPU provide another typedtype
FloatTensorgpu_tensor
)# or just call `cuda()` methodgpu_tensor
pytorch_tensor
()# call back to the CPUcpu_tensor
gpu_tensor
()# define pytorch tensorsx
)# `@` mean matrix multiplication from python3.5, PEP-0465res
y# get the shaperes
# torch.Size([10, 5])从张量到变量张量是 PyTorch 的一个完美组件，但是要想构建神经网络这还远远不够。反向传播怎么办？当然，我们可以手动实现它，但是真的需要这样做吗？幸好还有自动微分。为了支持这个功能，PyTorch 提供了变量，它是张量之上的封装。如此，我们可以构建自己的计算图，并自动计算梯度。每个变量实例都有两个属性：包含初始张量本身的.data，以及包含相应张量梯度的.gradfrom
Variable# define an inputsx_tensor
requires_grad
requires_grad
)# define some weightsw
requires_grad
)# get variable tensorprint
# torch.FloatTensor# get variable gradientprint
# Noneloss
)# calculate the gradientsloss
# some gradients# manually apply gradientsw
data# manually zero gradients after updatew
()你也许注意到我们手动计算了自己的梯度，这样看起来很麻烦，我们能使用优化器吗？当然。import
functional
requires_grad
requires_grad
requires_grad
requires_grad
)learning_rate
0.1loss_fn
()optimizer
learning_rate
)# manually zero all previous gradientsoptimizer
()# calculate new gradients# apply new gradientsoptimizer
()并不是所有的变量都可以自动更新。但是你应该可以从最后一段代码中看到重点：我们仍然需要在计算新梯度之前将它手动归零。这是 PyTorch 的核心理念之一。有时我们会不太明白为什么要这么做，但另一方面，这样可以让我们充分控制自己的梯度。静态图 vs 动态图PyTorch 和 TensorFlow 的另一个主要区别在于其不同的计算图表现形式。TensorFlow 使用静态图，这意味着我们是先定义，然后不断使用它。在 PyTorch 中，每次正向传播都会定义一个新计算图。在开始阶段，两者之间或许差别不是很大，但动态图会在你希望调试代码，或定义一些条件语句时显现出自己的优势。就像你可以使用自己最喜欢的 debugger 一样！你可以比较一下 while 循环语句的下两种定义——第一个是 TensorFlow 中，第二个是 PyTorch 中：import
tensorflow
tffirst_counter
)second_counter
)some_value
)# condition should handle all args:def
first_counter
second_counter
first_counter
second_counterdef
first_counter
second_counter
some_value
):first_counter
first_counter
)second_counter
second_counter
first_counter
second_counter
some_valuec1
while_loop
first_counter
second_counter
some_value
global_variables_initializer
())counter_1_res
counter_2_res
])first_counter
])second_counter
])some_value
first_counter
second_counter
]:first_counter
2second_counter
1看起来第二种方法比第一个简单多了，你觉得呢？模型定义现在我们看到，想在 PyTorch 中创建 if/else/while 复杂语句非常容易。不过让我们先回到常见模型中，PyTorch 提供了非常类似于 Keras 的、即开即用的层构造函数：神经网络包（nn）定义了一系列的模块，它可以粗略地等价于神经网络的层。模块接收输入变量并计算输出变量，但也可以保存内部状态，例如包含可学习参数的变量。nn 包还定义了一组在训练神经网络时常用的损失函数。from
collections
OrderedDictimport
nn# Example of using Sequentialmodel
Sequential
())# Example of using Sequential with OrderedDictmodel
Sequential
OrderedDict
'conv1'
'relu1'
'conv2'
'relu2'
())]))output
some_input
)如果你想要构建复杂的模型，我们可以将 nn.Module 类子类化。当然，这两种方式也可以互相结合。from
feature_extractor
Sequential
kernel_size
kernel_size
second_extractor
kernel_size
feature_extractor
second_extractor
)# note that we may call same layer twice or modereturn
x在__init__方法中，我们需要定义之后需要使用的所有层。在正向方法中，我们需要提出如何使用已经定义的层的步骤。而在反向传播上，和往常一样，计算是自动进行的。自定义层如果我们想要定义一些非标准反向传播模型要怎么办？这里有一个例子——XNOR 网络：在这里我们不会深入细节，如果你对它感兴趣，可以参考一下原始论文：https://arxiv.org/abs/与我们问题相关的是反向传播需要权重必须介于-1 到 1 之间。在 PyTorch 中，这可以很容易实现：class
MyFunction
):@staticmethoddef
save_for_backward
grad_output
):# saved tensors - tuple of tensors, so we need get firstinput
saved_variablesgrad_output
0grad_output
grad_output# usagey
MyFunction
)# ormy_func
MyFunction
)# and if we want to use inside nn.Moduleclass
MyFunctionModule
MyFunction
)正如你所见，我们应该只定义两种方法：一个为正向传播，一个为反向传播。如果我们需要从正向通道访问一些变量，我们可以将它们存储在 ctx 变量中。注意：在此前的 API 正向/反向传播不是静态的，我们存储变量需要以 self.save_for_backward(input) 的形式，并以 input, _ = self.saved_tensors 的方式接入。在 CUDA 上训练模型我们曾经讨论过传递一个张量到 CUDA 上。但如果希望传递整个模型，我们可以通过调用.cuda() 来完成，并将每个输入变量传递到.cuda() 中。在所有计算后，我们需要用返回.cpu() 的方法来获得结果。同时，PyTorch 也支持在源代码中直接分配设备：### tensor examplex_cpu
)# direct transfer to the GPUx_gpu
()result_gpu
w_gpu# get back from GPU to CPUresult_cpu
result_gpu
()### model examplemodel
()# train stepinputs
())outputs
()因为有些时候我们想在 CPU 和 GPU 中运行相同的模型，而无需改动代码，我们会需要一种封装：class
use_cudaself
gpu_idxself
)权重初始化在 TesnorFlow 中权重初始化主要是在张量声明中进行的。PyTorch 则提供了另一种方法：首先声明张量，随后在下一步里改变张量的权重。权重可以用调用 torch.nn.init 包中的多种方法初始化为直接访问张量的属性。这个决定或许并不直接了当，但当你希望初始化具有某些相同初始化类型的层时，它就会变得有用。# new way with `init` modulew
)# work for Variables alsow2
)# old styled direct access to tensors data attributew2
()# example for some moduledef
weights_init
):classname
__name__if
'Conv'
'BatchNorm'
)# for loop approach with direct accessclass
isinstance
kernel_size
kernel_size
out_channelsm
isinstance
BatchNorm2d
isinstance
):反向排除子图有时，当你希望保留模型中的某些层或者为生产环境做准备的时候，禁用某些层的自动梯度机制非常有用。在这种思路下，PyTorch 设计了两个 flag：requires_grad 和 volatile。第一个可以禁用当前层的梯度，但子节点仍然可以计算。第二个可以禁用自动梯度，同时效果沿用至所有子节点。# requires grad# If there’s a single input to an operation that requires gradient,# its output will also require gradient.x
requires_grad
requires_grad
requires_grad
# True# Volatile differs from requires_grad in how the flag propagates.# If there’s even a single volatile input to an operation,# its output is also going to be volatile.x
requires_grad
)训练过程当然，PyTorch 还有一些其他卖点。例如你可以设定学习速率，让它以特定规则进行变化。或者你可以通过简单的训练标记允许/禁止批规范层和 dropout。如果你想要做的话，让 CPU 和 GPU 的随机算子不同也是可以的。# scheduler examplefrom
lr_scheduleroptimizer
parameters
)scheduler
lr_scheduler
):scheduler
()validate
()# Train flag can be updated with boolean# to disable dropout and batch norm learningmodel
)# execute train stepmodel
)# run inference step# CPU seedtorch
manual_seed
)# GPU seedtorch
manual_seed_all
)同时，你也可以添加模型信息，或存储/加载一小段代码。如果你的模型是由 OrderedDict 或基于类的模型字符串，它的表示会包含层名。print
)# Sequential (# (conv1): Conv2d(1, 20, kernel_size=(5, 5), stride=(1, 1))# (relu1): ReLU ()# (conv2): Conv2d(20, 64, kernel_size=(5, 5), stride=(1, 1))# (relu2): ReLU ()# )# save/load only the model parameters(prefered solution)torch
state_dict
load_state_dict
))# save whole modeltorch
)根据 PyTorch 文档，用 state_dict() 的方式存储文档更好。记录训练过程的记录是一个非常重要的部分。不幸的是，PyTorch 目前还没有像 Tensorboard 这样的东西。所以你只能使用普通文本记录 Python 了，你也可以试试一些第三方库：logger：/oval-group/loggerCrayon：/torrvision/crayontensorboard_logger：/TeamHG-Memex/tensorboard_loggertensorboard-pytorch：/lanpa/tensorboard-pytorchVisdom：/facebookresearch/visdom掌控数据你可能会记得 TensorFlow 中的数据加载器，甚至想要实现它的一些功能。对于我来说，我花了四个小时来掌握其中所有管道的执行原理。首先，我想在这里添加一些代码，但我认为上图足以解释它的基础理念了。PyTorch 开发者不希望重新发明轮子，他们只是想要借鉴多重处理。为了构建自己的数据加载器，你可以从 torch.utils.data.Dataset 继承类，并更改一些方法：import
torchvision
ImagesDataset
default_loader
transformself
__getitem__
'class_'
'path'
shapereturn
n# what transformations should be done with our imagesdata_transforms
transforms
transforms
RandomCrop
transforms
RandomHorizontalFlip
transforms
(),])train_df
'path/to/some.csv'
)# initialize our dataset at firsttrain_dataset
ImagesDataset
,transform
data_transforms# initialize data loader with required number of workers and other paramstrain_loader
DataLoader
train_dataset
,batch_size
,num_workers
)# fetch the batch(call to `__getitem__` method)for
train_loader
:pass有两件事你需要事先知道：1. PyTorch 的图维度和 TensorFlow 的不同。前者的是 [Batch_size × channels × height × width] 的形式。但如果你没有通过预处理步骤 torchvision.transforms.ToTensor() 进行交互，则可以进行转换。在 transforms 包中还有很多有用小工具。2. 你很可能会使用固定内存的 GPU，对此，你只需要对 cuda() 调用额外的标志 async = True，并从标记为 pin_memory = True 的 DataLoader 中获取固定批次。最终架构现在我们了解了模型、优化器和很多其他细节。是时候来个总结了：这里有一段用于解读的伪代码：class
()criterion
ImagesDataset
path_to_images
)data_loader
DataLoader
batch_size
:lr_scheduler
data_loader
:save_best_model
epoch_validation_accuracy
)结论希望本文可以让你了解 PyTorch 的如下特点：它可以用来代替 Numpy它的原型设计非常快调试和使用条件流非常简单有很多方便且开箱即用的工具PyTorch 是一个正在快速发展的框架，背靠一个富有活力的社区。现在是尝试 PyTorch 的好时机。本文为机器之心编译，
转载请联系本公众号获得授权。------------------------------------------------加入机器之心（全职记者/实习生）：投稿或寻求报道：广告&商务合作：
本文仅代表作者观点，不代表百度立场。系作者授权百家号发表，未经许可不得转载。
百家号 最近更新：
简介: 专业的人工智能媒体和产业服务平台
作者最新文章}