Anaconda-数据科学实用指南-三-

布客飞龙
143 阅读54分钟

Anaconda 数据科学实用指南（三）

原文：annas-archive.org/md5/4e3e4df5f45a6d9e9d6bdf565d4b2bf9

译者：飞龙

协议：CC BY-NC-SA 4.0

第十章：预测性数据分析 – 建模与验证

我们进行各种数据分析的首要目标是试图找到模式，以预测未来可能发生的事情。对于股市来说，研究人员和专业人士正在进行各种测试，以理解市场机制。在这种情况下，可能会提出许多问题。未来五年市场指数将会怎样？IBM 的股价区间明年会是怎样？市场的波动性会增加还是减少？如果政府改变税收政策，可能会产生什么影响？如果一个国家与另一个国家发动贸易战，可能的盈亏是什么？通过分析一些相关变量，我们如何预测消费者的行为？我们能否预测一名本科生顺利毕业的概率？我们能否找到某些特定行为与某一特定疾病之间的关联？

本章将涵盖以下主题：

  • 理解预测性数据分析

  • 有用的数据集

  • 预测未来事件

  • 模型选择

  • 格兰杰因果关系检验

理解预测性数据分析

关于未来事件，人们可能会有很多问题。对于投资者来说，如果他/她能够预测股票价格的未来走势，便能获得更多利润。对于公司来说，如果他们能够预测产品的趋势，就能提升股价和产品的市场份额。对于政府来说，如果他们能够预测人口老龄化对社会和经济的影响，就能更有动力设计出更好的政策，涉及政府预算和其他相关的战略决策。

对于大学来说，如果他们能够很好地掌握毕业生的质量和技能需求，就能设计出更好的课程，或推出新课程以满足未来劳动力市场的需求。

为了更好的预测或预报，研究人员必须考虑许多问题。例如，样本是否太小？我们如何处理缺失变量？数据集在数据收集过程中是否存在偏差？我们如何处理极端值或离群值？季节性是什么，我们如何应对？我们应该应用什么样的模型？本章将涉及其中的一些问题。我们从有用的数据集开始。

有用的数据集

最佳的数据来源之一是UCI 机器学习库。当我们访问网页archive.ics.uci.edu/ml/datasets.html时，我们会看到以下列表：

例如，如果我们点击第一个数据集（Abalone），我们会看到以下内容。为了节省空间，仅显示顶部部分：

用户可以从网页上下载数据集，并找到变量定义，甚至是引用。以下代码可以用来下载相关的 R 数据集：

dataSet<-"UCIdatasets" 
path<-"http://canisius.edu/~yany/RData/" 
con<-paste(path,dataSet,".RData",sep='') 
load(url(con)) 
dim(.UCIdatasets) 
head(.UCIdatasets)

相关输出如下所示：

从上面的输出中，我们知道该数据集有 427 个观测值（数据集）。对于每个数据集，我们有 7 个相关特征，如 Name、Data_Types、Default_Task、Attribute_Types、N_Instances（实例数）、N_Attributes（属性数）和 Year。名为 Default_Task 的变量可以解释为每个数据集的基本用途。例如，第一个数据集 Abalone 可以用于 分类 问题。可以使用 unique() 函数来查找所有可能的 Default_Task，如下所示：

应用预测建模 R 包

该包包含了许多有用的数据集，可以用于本章节及其他章节。查找这些数据集最简单的方法是使用 help() 函数，如下所示：

>library(AppliedPredictiveModeling) 
>help(package=AppliedPredictiveModeling)

以下表格展示了该包中包含的数据集：

数据（名称）数据集名称说明
abaloneabalone鲍鱼数据
biobio肝损伤数据
bookThemebookTheme格子主题
cars2010,cars2011, 和 cars2012cars2010,cars2011, cars2012燃油经济性数据
chemchem肝损伤数据
ChemicalManufacturingProcessChemicalManufacturingProcess化学制造过程数据
classesclasses两类示例数据
concreteconcrete混凝土抗压强度
diagnosisdiagnosis阿尔茨海默病脑脊液数据
easyBoundaryFunceasyBoundaryFunc用于模拟数据的函数
fingerprintsfingerprints渗透性数据
getPackagesgetPackages安装每个章节的包
injuryinjury肝损伤数据
logisticCreditPredictionslogisticCreditPredictions信用数据
mixturesmixtures混凝土抗压强度
permeabilitypermeability渗透性数据
permuteReliefpermuteRelief缓解算法的置换统计数据
predictorspredictors阿尔茨海默病脑脊液数据
quadBoundaryFuncquadBoundaryFunc用于模拟数据的函数
schedulingDataschedulingDataHPC 作业调度数据
scriptLocationscriptLocation查找章节脚本文件
segmentationOriginalsegmentationOriginal细胞体分割
solubilitysolTestX,solTestXtrans,solTestY,solTrainX,solTrainXtrans,solTrainY, 和 trainX溶解度数据
transparentThemetransparentTheme格子主题
twoClassDatatwoClassData两类示例数据

表 10.1 数据集，嵌入在 R 包应用预测建模中

这里，我们展示了如何加载这些数据集的一些示例。要加载一组数据，我们使用 data() 函数。对于第一个数据集，名为 abalone，我们有以下代码：

> library(AppliedPredictiveModeling) 
> data(abalone) 
> dim(abalone) 
> head(abalone)

输出如下：

对于某些人来说，大数据集包括一些子数据集：

> library(AppliedPredictiveModeling) 
> data(solubility) 
> ls(pattern="sol") 
[1] "solTestX"       "solTestXtrans"  "solTestY"
[4] "solTrainX"      "solTrainXtrans" "solTrainY"

要加载每个数据集，我们可以使用dim()、head()、tail()和summary()函数。

时间序列分析

时间序列可以定义为在连续的时间点上获得的一组值，通常它们之间有相等的间隔。时间序列有不同的频率，如年度、季度、月度、周度和日度。对于 GDP（国内生产总值）时间序列，我们通常会有季度或年度数据。对于股票数据，我们通常有年度、月度和日度数据。使用以下代码，我们可以上传美国 GDP 的季度和年度数据：

> path<-"http://canisius.edu/~yany/RData/" 
> dataSet<-"usGDPannual" 
> con<-paste(path,dataSet,".RData",sep='') 
> load(url(con)) 
> head(.usGDPannual) 
 YEAR  GDP 
1 1930 92.2 
2 1931 77.4 
3 1932 59.5 
4 1933 57.2 
5 1934 66.8 
6 1935 74.3 
> dataSet<-"usGDPquarterly" 
> con<-paste(path,dataSet,".RData",sep='') 
> load(url(con)) 
> head(.usGDPquarterly) 
 DATE GDP_CURRENT GDP2009DOLLAR 
1 1947Q1       243.1        1934.5 
2 1947Q2       246.3        1932.3 
3 1947Q3       250.1        1930.3 
4 1947Q4       260.3        1960.7 
5 1948Q1       266.2        1989.5 
6 1948Q2       272.9        2021.9

然而，在时间序列分析中我们会遇到许多问题。例如，从宏观经济学的角度来看，我们有商业或经济周期，可以观察到经济扩张和衰退的阶段。行业或公司可能存在季节性波动。以农业行业为例，农民在春季和秋季的支出会更多，而在冬季则较少。对于零售行业来说，年末假期季节会有大量现金流入。

要操作时间序列，我们可以使用 R 包timeSeries中包含的许多有用函数。在以下程序中，我们将按周频率对日数据进行平均：

> library(timeSeries)
> data(MSFT)
> x <- MSFT
> by <- timeSequence(from = start(x), to = end(x), by = "week")
> y<-aggregate(x,by,mean)

我们还可以使用head()函数查看一些观察值：

> head(x)
GMT
 Open High Low Close Volume
2000-09-27 63.4375 63.5625 59.8125 60.6250 53077800
2000-09-28 60.8125 61.8750 60.6250 61.3125 26180200
2000-09-29 61.0000 61.3125 58.6250 60.3125 37026800
2000-10-02 60.5000 60.8125 58.2500 59.1250 29281200
2000-10-03 59.5625 59.8125 56.5000 56.5625 42687000
2000-10-04 56.3750 56.5625 54.5000 55.4375 68226700
> head(y)
GMT
 Open High Low Close Volume
2000-09-27 63.4375 63.5625 59.8125 60.6250 53077800
2000-10-04 59.6500 60.0750 57.7000 58.5500 40680380
2000-10-11 54.9750 56.4500 54.1625 55.0875 36448900
2000-10-18 53.0375 54.2500 50.8375 52.1375 50631280
2000-10-25 61.7875 64.1875 60.0875 62.3875 86457340
2000-11-01 66.1375 68.7875 65.8500 67.9375 53496000

预测未来事件

在预测未来时，我们可以使用许多技术，如移动平均（MA）、回归、自回归等。首先，让我们从最简单的移动平均开始：

movingAverageFunction<- function(data,n=10){
  out= data
  for(i in n:length(data)){
    out[i] = mean(data[(i-n+1):i])
  }
  return(out)
}

在前面的程序中，周期数的默认值为10。我们可以使用名为MSFT的数据集，该数据集包含在 R 包timeSeries中（请参见以下代码）：

> library(timeSeries)
> data(MSFT)
> p<-MSFT$Close
> #
> ma<-movingAverageFunction(p,3)
> head(p)
[1] 60.6250 61.3125 60.3125 59.1250 56.5625 55.4375
> head(ma)
[1] 60.62500 61.31250 60.75000 60.25000 58.66667 57.04167
> mean(p[1:3])
[1] 60.75
> mean(p[2:4])
[1] 60.25

手动计算时，我们发现* x 的前三个值的平均值与 y *的第三个值相同。从某种意义上讲，我们可以使用移动平均来预测未来。

在下一个示例中，我们将展示如何估计明年市场的预期回报。在这里，我们使用标准普尔 500 指数和历史年均值作为我们的预期值。首先，我们可以去 Yahoo!Finance 下载数据。标准普尔 500 指数的符号是^GSPC：

library(plyr)
year<-c(2000,2000,2001,2001,2004)
values<-c(2, 3, 3, 5, 6)
df <- data.frame(DATE=year,B =values )
dfsum <- ddply(df, c("DATE"),summarize,B=sum(B))

输出如下所示：

> df
 DATE B
1 2000 2
2 2000 3
3 2001 3
4 2001 5
5 2004 6
> dfsum
 DATE B
1 2000 5
2 2001 8
3 2004 6

现在，我们从 Yahoo!Finance 下载标准普尔 500 指数的历史月度价格数据。或者，我们可以使用以下代码下载 R 数据集。前几条命令用于下载相关的数据集.sp500monthly。程序的目标是估计年均值及其 90%的置信区间：

> library(data.table)
> path<-'http://canisius.edu/~yany/RData/'
> dataSet<-'sp500monthly.RData'
> link<-paste(path,dataSet,sep='')
> load(url(link))
> #head(.sp500monthly,2)
> p<-.sp500monthly$ADJ.CLOSE
> n<-length(p)
> logRet<-log(p[2:n]/p[1:(n-1)])
> years<-format(.sp500monthly$DATE[2:n],"%Y")
> y<-data.frame(.sp500monthly$DATE[2:n],years,logRet)
> colnames(y)<-c("DATE","YEAR","LOGRET")
> y2<- data.table(y)
> z<-y2[,sum(LOGRET),by=YEAR]
> z2<-na.omit(z)
> annualRet<-data.frame(z2$YEAR,exp(z2[,2])-1)
> n<-nrow(annualRet)
> std<-sd(annualRet[,2])
> stdErr<-std/sqrt(n)
> ourMean<-mean(annualRet[,2])
> min2<-ourMean-2*stdErr
> max2<-ourMean+2*stdErr
> cat("[min mean max ]\n")
[min mean max ]
> cat(min2,ourMean,max2,"\n")
0.05032956 0.09022369 0.1301178

从结果来看，标准普尔 500 的历史年均回报率为 9%。如果我们宣称明年的指数回报率也为 9%，那么它可能在 5%到 13%之间波动，这是一个可能的巨大波动。

季节性

在下一个例子中，我们将展示自相关。首先，我们上传一个名为astsa的 R 包，它代表应用统计时间序列分析。然后，我们上传美国 GDP 的季度频率数据：

library(astsa)
path<-"http://canisius.edu/~yany/RData/"
dataSet<-"usGDPquarterly"
con<-paste(path,dataSet,".RData",sep='')
load(url(con))
x<-.usGDPquarterly$DATE
y<-.usGDPquarterly$GDP_CURRENT
plot(x,y)
diff4 = diff(y,4)
acf2(diff4,24)

在前面的程序中，diff()函数计算差值，例如当前值减去前一个值。第二个输入值表示滞后期。acf2()函数用于绘制和打印时间序列的 ACF 和 PACF。ACF 代表自协方差函数，PACF 代表偏自相关函数。相关的图表如下所示：

可视化组件

如果我们能够使用图表，理解这些概念和数据集会更加清晰。第一个例子展示了过去五十年美国 GDP 的波动：

> path<-"http://canisius.edu/~yany/RData/"
> dataSet<-"usGDPannual"
> con<-paste(path,dataSet,".RData",sep='')
> load(url(con))
> title<-"US GDP"
> xTitle<-"Year"
> yTitle<-"US annual GDP"
> x<-.usGDPannual$YEAR
> y<-.usGDPannual$GDP
> plot(x,y,main=title,xlab=xTitle,ylab=yTitle)

相关的图表如下所示：

如果我们使用对数尺度来表示 GDP，那么我们将会得到以下的代码和图表：

> yTitle<-"Log US annual GDP" 
> plot(x,log(y),main=title,xlab=xTitle,ylab=yTitle)

以下图表接近一条直线：

R 包 – LiblineaR

这个包是基于LIBLINEAR C/C++库的线性预测模型。这里是一个使用iris数据集的例子。程序通过使用训练数据来预测植物属于哪个类别：

library(LiblineaR)
data(iris)
attach(iris)
x=iris[,1:4]
y=factor(iris[,5])
train=sample(1:dim(iris)[1],100)
xTrain=x[train,];xTest=x[-train,]
yTrain=y[train]; yTest=y[-train]
s=scale(xTrain,center=TRUE,scale=TRUE)
#
tryTypes=c(0:7)
tryCosts=c(1000,1,0.001)
bestCost=NA
bestAcc=0
bestType=NA
#
for(ty in tryTypes){
   for(co in tryCosts){
     acc=LiblineaR(data=s,target=yTrain,type=ty,cost=co,bias=1,cross=5,verbose=FALSE)
     cat("Results for C=",co,": ",acc," accuracy.\n",sep="")
     if(acc>bestAcc){
         bestCost=co
         bestAcc=acc
         bestType=ty
     }
   }
}
cat("Best model type is:",bestType,"\n")
cat("Best cost is:",bestCost,"\n")
cat("Best accuracy is:",bestAcc,"\n")
# Re-train best model with best cost value.
m=LiblineaR(data=s,target=yTrain,type=bestType,cost=bestCost,bias=1,verbose=FALSE)
# Scale the test data
s2=scale(xTest,attr(s,"scaled:center"),attr(s,"scaled:scale"))
pr=FALSE; # Make prediction
if(bestType==0 || bestType==7) pr=TRUE
p=predict(m,s2,proba=pr,decisionValues=TRUE)
res=table(p$predictions,yTest) # Display confusion matrix
print(res)
# Compute Balanced Classification Rate
BCR=mean(c(res[1,1]/sum(res[,1]),res[2,2]/sum(res[,2]),res[3,3]/sum(res[,3])))
print(BCR)

输出如下。BCR是平衡分类率。对于这个率，越高越好：

> cat("Best model type is:",bestType,"\n")
Best model type is: 4 
> cat("Best cost is:",bestCost,"\n")
Best cost is: 1 
> cat("Best accuracy is:",bestAcc,"\n")
Best accuracy is: 0.98 
> print(res)
            yTest
 setosa versicolor virginica
 setosa 16 0 0
 versicolor 0 17 0
 virginica 0 3 14
> print(BCR)
[1] 0.95

R 包 – datarobot

DataRobot 这个名字指代三件事：一家位于波士顿的软件公司，DataRobot 公司开发的大规模并行建模引擎，以及一个开源的 R 包，允许交互式 R 用户连接到这个建模引擎。本文档简要介绍了datarobot R 包，重点介绍其使用的以下关键细节：

  • 从交互式 R 会话连接到 DataRobot 建模引擎

  • 在 DataRobot 建模引擎中创建一个新的建模项目

  • 从 DataRobot 建模项目中检索结果

  • 从任何 DataRobot 模型生成预测

要启动该包，我们使用library()函数：

> library(datarobot)

在之前的代码执行后，新用户很有可能会收到类似以下的错误消息：

> library(datarobot)
Did not connect to DataRobot on package startup. Use `ConnectToDataRobot`.
To connect by default on startup, you can put a config file at: C:\Users\yany\Documents/.config/datarobot/drconfig.yaml

这意味着我们必须先在公司注册，以获得一个验证过的令牌密钥。最终的令牌格式如下所示：

loc<- "YOUR-ENDPOINT-HERE"
myToken<-"YOUR-API_TOKEN-HERE"
ConnectToDataRobot(endpoint=loc,token=myToken)

我们也可以使用help()函数来查找包的用户：

> help(package=datarobot)

R 包 – eclust

这个包是基于环境的可解释预测模型聚类方法，用于高维数据。首先，让我们看一个名为simdata的数据集，它包含了该包的模拟数据：

> library(eclust)
> data("simdata")
> dim(simdata)
[1] 100 502
> simdata[1:5, 1:6]
 Y E Gene1 Gene2 Gene3 Gene4
[1,] -94.131497 0 -0.4821629 0.1298527 0.4228393 0.36643188
[2,] 7.134990 0 -1.5216289 -0.3304428 -0.4384459 1.57602830
[3,] 1.974194 0 0.7590055 -0.3600983 1.9006443 -1.47250061
[4,] -44.855010 0 0.6833635 1.8051352 0.1527713 -0.06442029
[5,] 23.547378 0 0.4587626 -0.3996984 -0.5727255 -1.75716775
> table(simdata[,"E"])
 0 1 
50 50 
>

上述输出显示数据的维度为 100 乘以 502。Y 是一个连续响应向量，E 是用于 ECLUST 方法的二元环境变量。E = 0 表示未暴露 (n=50)，E = 1 表示已暴露 (n=50)。以下的 R 程序估计了相关性的 Fisher z 转换。Fisher 的 Z 转换的定义如下代码所示：

> library(eclust)
> data("simdata")
> X = simdata[,c(-1,-2)]
> firstCorr<-cor(X[1:50,])
> secondCorr<-cor(X[51:100,])
> score<-u_fisherZ(n0=100,cor0=firstCorr,n1=100,cor1=secondCorr)
> dim(score)
[1] 500 500
> score[1:5,1:5]
 Gene1 Gene2 Gene3 Gene4 Gene5
Gene1 1.000000 -8.062020 6.260050 -8.133437 -7.825391
Gene2 -8.062020 1.000000 9.162208 -7.431822 -7.814067
Gene3 6.260050 9.162208 1.000000 8.072412 6.529433
Gene4 -8.133437 -7.431822 8.072412 1.000000 -5.099261
Gene5 -7.825391 -7.814067 6.529433 -5.099261 1.000000
>

Fisher 的 Z 转换在这里定义。假设我们有一组 n 对的 x[i] 和 y[i]，我们可以通过应用以下公式来估计它们的相关性：

在这里，ρ 是两个变量之间的相关性，而 和 是 x 和 y 的均值。Fisher 的 z 值定义为 :

在这是自然对数函数，arctanh() 是反双曲正切函数。

模型选择

当寻找一个好的模型时，有时我们会面对欠拟合和过拟合。第一个例子是借用的；您可以在scikit-learn.org/stable/auto_examples/model_selection/plot_underfitting_overfitting.html#sphx-glr-auto-examples-model-selection-plot-underfitting-overfitting-py下载程序。它演示了欠拟合和过拟合的问题，以及如何使用具有多项式特征的线性回归来逼近非线性函数。真实函数如下所示：

在以下程序中，我们尝试使用线性和多项式模型来逼近方程。稍作修改的代码如下所示。该程序试图展示不同模型在欠拟合和过拟合方面的影响：

import sklearn
import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures 
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score 
#
np.random.seed(123)
n= 30 # number of samples 
degrees = [1, 4, 15]
def true_fun(x):
    return np.cos(1.5*np.pi*x)
x = np.sort(np.random.rand(n))
y = true_fun(x) + np.random.randn(n) * 0.1
plt.figure(figsize=(14, 5))
title="Degree {}\nMSE = {:.2e}(+/- {:.2e})"
name1="polynomial_features"
name2="linear_regression"
name3="neg_mean_squared_error"
#
for i in range(len(degrees)):
    ax=plt.subplot(1,len(degrees),i+1)
    plt.setp(ax, xticks=(), yticks=())
    pFeatures=PolynomialFeatures(degree=degrees[i],include_bias=False)
    linear_regression = LinearRegression()
    pipeline=Pipeline([(name1,pFeatures),(name2,linear_regression)])
    pipeline.fit(x[:,np.newaxis],y)
    scores=cross_val_score(pipeline,x[:,np.newaxis],y,scoring=name3,cv=10)
    xTest = np.linspace(0, 1, 100)
    plt.plot(xTest,pipeline.predict(xTest[:,np.newaxis]),label="Model")
    plt.plot(xTest,true_fun(xTest),label="True function")
    plt.scatter(x,y,edgecolor='b',s=20,label="Samples")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.xlim((0,1))
    plt.ylim((-2,2))
    plt.legend(loc="best")
    plt.title(title.format(degrees[i],-scores.mean(),scores.std()))
plt.show()

相关图表显示如下：

请注意，每个图表的顶部，MSE 代表 均方误差。对于左侧的图表，该程序试图使用一条线来拟合基于输入数据集的真实模型。由于它是线性的，Degree 是 1。与具有 Degree 为 4 的第二模型相比，这个学习模型的 MSE 更大，分别为 0.54 和 0.0879。这表明线性模型可能会欠拟合模型，而第二模型可能会过拟合模型。

Python 包 - model-catwalk

一个示例可以在pypi.python.org/pypi/model-catwalk/0.2.1找到。其前几行代码如下所示：

import datetime
import pandas
from sqlalchemy import create_engine
from metta import metta_io as metta
from catwalk.storage import FSModelStorageEngine, CSVMatrixStore
from catwalk.model_trainers import ModelTrainer
from catwalk.predictors import Predictor
from catwalk.evaluation import ModelEvaluator
from catwalk.utils import save_experiment_and_get_hash
help(FSModelStorageEngine)

相关输出显示如下。为节省空间，仅呈现顶部部分：

 Help on class FSModelStorageEngine in module catwalk.storage:

class FSModelStorageEngine(ModelStorageEngine)
 | Method resolution order:
 | FSModelStorageEngine
 | ModelStorageEngine
 | builtins.object
 | 
 | Methods defined here:
 | 
 | __init__(self, *args, **kwargs)
 | Initialize self. See help(type(self)) for accurate signature.
 | 
 | get_store(self, model_hash)
 | 
 | ----------------------------------------------------------------------
 | Data descriptors inherited from ModelStorageEngine:
 | 
 | __dict__
 | dictionary for instance variables (if defined)
 | 
 | __weakref__
 | list of weak references to the object (if defined)

Python 包 - sklearn

由于 Python 的sklearn是一个非常有用的包，因此值得向您展示更多使用该包的示例。此处引用的示例是如何使用该包通过词袋模型按主题对文档进行分类。

这个示例使用了一个scipy.sparse矩阵来存储特征，并展示了几种能够高效处理稀疏矩阵的分类器。该示例使用的数据集是 20 个新闻组数据集。它将自动下载并缓存。该 ZIP 文件包含输入文件，可以在people.csail.mit.edu/jrennie/20Newsgroups/20news-bydate.tar.gz下载。文件大小约为 14 MB。代码可以通过以下网页链接访问：scikit-learn.org/stable/auto_examples/text/document_classification_20newsgroups.html#sphx-glr-auto-examples-text-document-classification-20newsgroups-py。为了节省空间，这里仅显示前几行：

import logging
import numpy as np
from optparse import OptionParser
import sys
from time import time
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.feature_extraction.text import HashingVectorizer
from sklearn.feature_selection import SelectFromModel

相关的输出显示如下：

对于每种方法，有三个衡量指标：得分、训练时间和测试时间。例如，对于RandomForestClassifier方法，它在训练和测试中消耗了大量时间；请参见最长的三根条形图。这个现象是可以理解的，因为该方法需要进行大量的模拟。

Julia 包 – QuantEcon

对于预测未来可能发生的事件，其中一个工具是蒙特卡洛模拟。为此，我们可以使用一个名为QuantEcon的 Julia 包。这个包是使用 Julia 进行定量经济学。第一个示例是马尔可夫模拟：

using QuantEcon
P = [0.4 0.6; 0.2 0.8];
mc = MarkovChain(P)
x = simulate(mc, 100000);
mean(x .== 1)
#
mc2 = MarkovChain(P, ["employed", "unemployed"])
simulate(mc2, 4)

程序的第一部分模拟了 100,000 次的 P 矩阵，而第二部分模拟了两种状态：employed和unemployed。请看以下输出：

下一个示例也来自手册。目标是查看一个经济状态的人如何在未来转变为另一个经济状态。首先，让我们看看以下图表：

让我们看一下最左边的椭圆，其中写着贫穷。这意味着对于一个贫穷的人，他/她有 90%的机会保持贫穷，10%的机会转到中产阶级。它可以通过以下矩阵表示，矩阵中没有节点之间的边则填充为零：

两个状态，x和y，如果存在正整数j和k，则称它们可以互相通信，例如：

如果所有状态都能互相通信，则称随机矩阵 P 是不可约的；也就是说，如果对于每一对（x，y），x和y是可达的。从图中可以看出，这个随机矩阵是不可约的：我们最终可以从任何状态到达任何其他状态。以下代码将确认这一点：

using QuantEcon
P = [0.9 0.1 0.0; 0.4 0.4 0.2; 0.1 0.1 0.8];
mc = MarkovChain(P)
is_irreducible(mc)

以下图形将表示一个极端的不可约案例，因为一个贫穷的人未来将 100%是贫穷的：

以下代码也将确认这一点，因为结果将是false：

using QuantEcon
P2 = [1.0 0.0 0.0; 0.1 0.8 0.1; 0.0 0.2 0.8];
mc2 = MarkovChain(P2)
is_irreducible(mc2)

Octave 包 – ltfat

ltfat包代表大时间/频率分析工具箱，是一个用于处理时间频率分析、小波和信号处理的 Matlab/Octave 工具箱。它既是一个教育工具，也是一个计算工具。该工具箱提供了大量的线性变换，包括 Gabor 和小波变换，以及用于构建窗（滤波原型）和操作系数的例程。以下示例取自他们的手册，手册可以在ltfat.github.io/doc/ltfat.pdf找到。以下示例展示了franalasso()函数如何生成测试信号greasy的稀疏表示：

pkg load ltfat
f = greasy;
name1="sparsified coefficients"
name2="dual system coefficients"
F = frame('dgtreal','gauss',64,512);
lambda = 0.1;
% Solve the basis pursuit problem
[c,~,~,frec,cd] = franalasso(F,f,lambda);
figure(1); % Plot sparse coefficients
plotframe(F,c,’dynrange’,50);
figure(2); % Plot coefficients 
plotframe(F,cd,’dynrange’,50);
norm(f-frec)
figure(3);
semilogx([sort(abs(c),'descend')/max(abs(c)),...
sort(abs(cd),’descend’)/max(abs(cd))]);
legend({name1,name2});

程序输出了三张图，最后一张如下所示：

Granger 因果检验

当说 A 引起 B 时，这意味着 A 是 B 发生的原因。这是因果关系的常见定义：即哪个因素引起了下一个因素。Granger 因果检验用于确定一个时间序列是否是因素，并在预测第二个时间序列时提供有用信息。在以下代码中，使用了一个名为ChickEgg的数据集作为示例。该数据集有两列，分别是小鸡的数量和蛋的数量，并带有时间戳：

> library(lmtest)
> data(ChickEgg)
> dim(ChickEgg)
[1] 54 2
> ChickEgg[1:5,]
 chicken egg
[1,] 468491 3581
[2,] 449743 3532
[3,] 436815 3327
[4,] 444523 3255
[5,] 433937 3156

问题是：我们能否利用今年的蛋的数量来预测明年的鸡的数量？如果这是正确的，我们的说法将是小鸡的数量 Granger 引起蛋的数量。如果不正确，我们说小鸡的数量不会 Granger 引起蛋的数量。下面是相关的代码：

> library(lmtest)
> data(ChickEgg)
> grangertest(chicken~egg, order = 3, data = ChickEgg)
Granger causality test
Model 1: chicken ~ Lags(chicken, 1:3) + Lags(egg, 1:3)
Model 2: chicken ~ Lags(chicken, 1:3)
 Res.Df Df F Pr(>F) 
1 44 
2 47 -3 5.405 0.002966 **
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

在模型 1 中，我们尝试使用鸡的滞后加上蛋的滞后滞后来解释鸡的数量。由于 P 值相当小，在0.01水平上具有显著性。因此，我们说蛋 Granger 引起鸡。以下测试表明，鸡不能用来预测下一期的误差：

> grangertest(egg~chicken, order = 3, data = ChickEgg)
Granger causality test

Model 1: egg ~ Lags(egg, 1:3) + Lags(chicken, 1:3)
Model 2: egg ~ Lags(egg, 1:3)
 Res.Df Df F Pr(>F)
1 44 
2 47 -3 0.5916 0.6238

在下一个示例中，我们测试哪一个（IBM 的回报或 S&P500 的回报）可以 Granger 引起另一个。首先，我们定义一个回报函数：

ret_f<-function(x,ticker=""){
     n<-nrow(x)
     p<-x[,6]
     ret<-p[2:n]/p[1:(n-1)]-1
     output<-data.frame(x[2:n,1],ret)
     name<-paste("RET_",toupper(ticker),sep='')
     colnames(output)<-c("DATE",name)
     return(output)
}

注意，我们使用返回值加上股票代码作为列名：

> x<-read.csv("http://canisius.edu/~yany/data/ibmDaily.csv",header=T)
> ibmRet<-ret_f(x,"ibm")
> x<-read.csv("http://canisius.edu/~yany/data/^gspcDaily.csv",header=T)
> mktRet<-ret_f(x,"mkt")
> final<-merge(ibmRet,mktRet)
> head(final)
 DATE RET_IBM RET_MKT
1 1962-01-03 0.008742545 0.0023956877
2 1962-01-04 -0.009965497 -0.0068887673
3 1962-01-05 -0.019694350 -0.0138730891
4 1962-01-08 -0.018750380 -0.0077519519
5 1962-01-09 0.011829467 0.0004340133
6 1962-01-10 0.001798526 -0.0027476933

现在，函数可以用输入值调用。程序的目的是测试我们是否可以使用滞后的市场回报来解释 IBM 的回报。类似地，我们测试滞后的 IBM 回报是否可以解释市场回报：

> library(lmtest)
> grangertest(RET_IBM ~ RET_MKT, order = 1, data =final)
Granger causality test
Model 1: RET_IBM ~ Lags(RET_IBM, 1:1) + Lags(RET_MKT, 1:1)
Model 2: RET_IBM ~ Lags(RET_IBM, 1:1)
 Res.Df Df F Pr(>F) 
1 14149 
2 14150 -1 24.002 9.729e-07 ***
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

上述结果表明，S&P500 指数可以用来解释 IBM 下一期的回报，因为它在 0.1%的显著性水平下是统计上显著的。接下来的行将测试 IBM 的回报滞后是否能够解释 S&P500 指数回报：

> grangertest(RET_MKT ~ RET_IBM, order = 1, data =final)
Granger causality test
Model 1: RET_MKT ~ Lags(RET_MKT, 1:1) + Lags(RET_IBM, 1:1)
Model 2: RET_MKT ~ Lags(RET_MKT, 1:1)
 Res.Df Df F Pr(>F) 
1 14149 
2 14150 -1 7.5378 0.006049 **
---
Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1
>

结果表明，在这个期间，IMB 的回报也可以用来解释 S&P500 指数下一期的回报。

总结

本章我们讨论了预测数据分析、建模与验证、一些有用的数据集、时间序列分析、如何预测未来事件、季节性，以及如何可视化我们的数据。对于 Python 包，我们提到了prsklearn和catwalk。对于 R 包，我们讨论了datarobot、LiblineaR、andeclust。对于 Julia 包，我们解释了EQuantEcon。对于 Octave，我们介绍了ltfat。

在下一章中，我们将讨论 Anaconda Cloud。一些主题包括深入介绍 Jupyter Notebook，Jupyter Notebooks 的不同格式，如何与伙伴共享笔记本，如何跨平台共享不同项目，如何共享工作环境，以及如何在本地复制他人的环境。

复习问题与练习

  1. 为什么我们关心预测未来？

  2. 季节性是什么意思？它如何影响我们的预测？

  3. 如何衡量季节性的影响？

  4. 编写一个 R 程序，使用过去五年的移动平均来预测下一年的预期回报。数据来源为fiannce.yahoo.com。你可以测试一些股票，如 IBM、C 和 WMT。此外，应用相同的方法预测 S&P500 指数。你的结论是什么？

  5. 假设我们有以下真实模型：

编写 Python 程序，使用线性和多项式模型来逼近前述函数并展示相关图表。

  1. 下载一个市场指数的月度数据，并估算其下一年的年回报。可以使用 S&P500 作为指数，数据来源可以参考 Yahoo!Finance，网址为finance.yahoo.com。数据来源：finance.yahoo.com

  2. 下载几个国家的指数数据，如美国、加拿大、香港和中国。估算收益。进行 Granger 因果关系检验，查看哪个国家的股市指数是主导因素。

  3. 从法国教授数据库中下载 Fama-French 三因子时间序列。估算明年的小盘股减大盘股（SMB）因子和高市值减低市值（HML）因子。网页链接为mba.tuck.dartmouth.edu/pages/faculty/ken.french/data_library.html。另外，也可以在canisius.edu/~yany/python/data/ffMonthly.pkl下载 Python 数据集。以下是几行 Python 代码：

import pandas as pd
ff=pd.read_pickle("c:/temp/ffMonthly.pkl")
print(ff.head())

相关输出如下所示：

print(ff.head())
            MKT_RF SMB HML Rf
1926-07-01 0.0296 -0.0230 -0.0287 0.0022
1926-08-01 0.0264 -0.0140 0.0419 0.0025
1926-09-01 0.0036 -0.0132 0.0001 0.0023
1926-10-01 -0.0324 0.0004 0.0051 0.0032
1926-11-01 0.0253 -0.0020 -0.0035 0.003

  1. IBM 下一年度预计的年回报率是多少？

  2. 未来三年 S&P500 指数的水平是多少？

  3. 我们能否将商业周期添加到我们的回归模型中？数据集可以通过以下 R 代码下载：

> path<-"http://canisius.edu/~yany/RData/"
> dataSet<-"businesscycle"
> link<-paste(path,dataSet,".RData",sep='')
> load(url(link))
> head(.businessCycle)
      DATE CYCLE
1 19261001 1.000
2 19261101 0.846
3 19261201 0.692
4 19270101 0.538
5 19270201 0.385
6 19270301 0.231

峰值定义为 1，谷值定义为 -1。任何位于峰值或谷值之间，或者位于谷值和峰值之间的月份，都会进行线性插值。

请注意，以下四个问题基于 Octave 机器学习示例。数据集和 Octave 示例程序可以在github.com/partharamanujam/octave-ml.下载。

  1. 运行名为linear_gd.m的示例 Octave 机器学习程序，该数据集包含关于水位变化的历史记录。

  2. 运行名为svm.m的示例 Octave 机器学习程序。该程序将spam-vocab列表读取到结构体words中，该列表包含至少在垃圾邮件语料库中出现 100 次的单词。三个输入文件分别是spam-vocab.txt、spamTrain.mat和spamTest.mat。

  3. 运行名为logistic_gd.m的示例 Octave 机器学习程序。

  4. 运行名为pca.m的示例 Octave 机器学习程序。

  5. 安装名为EmpiricalRisks的 Julia 包，并通过使用该包展示几个示例。

第十一章：Anaconda Cloud

现如今，计算机领域的一个流行词是云。最简单的例子是，对于许多用户来说，Google Drive 就是一种云，用户可以在其中保存文件、照片和程序，并与同事、家人或其他人分享。另一个例子是所谓的云计算。根据美国国家标准与技术研究院的定义，云计算是一种模型，使得用户能够便捷、按需地通过网络访问共享的可配置计算资源池（例如，网络、服务器、存储、应用程序和服务），这些资源能够快速配置和释放，且对管理和服务提供者的交互要求最小。古英语中，岩石、山丘与云有关。比喻意义上的雨云，蒸发水的聚集体大约在 1200 年左右就有了，这源于积云和岩石块的相似性。古英语中表示云的常用词是weolcan。在中古英语中，skie最初也表示云。在本章中，将涉及以下主题：

  • Anaconda Cloud 介绍

  • 深入了解 Jupyter Notebook

  • 本地复制他人的环境

  • 从 Anaconda 下载一个包

Anaconda Cloud 介绍

现如今，我们已经使用过或至少听说过“云”这个词。通常，它意味着我们可以将数据保存在其他人的服务器上。对于 Anaconda Cloud，用户可以利用这个平台保存和分享包、笔记本、项目和环境。该过程、平台以及方法使得包管理和协作更加便捷，包括共享他们的包和项目。公开项目和笔记本是免费的。目前，私人计划的起价为每月 7 美元。Anaconda Cloud 允许用户创建或分发软件包。

对于 Windows 版本的 Anaconda，点击“所有程序”|“Anaconda”，然后选择 Anaconda Cloud。

双击 Cloud 后，欢迎屏幕将会出现。

根据欢迎屏幕提供的信息，我们知道在使用 Anaconda 之前需要一个账户。登录后，我们将看到以下界面：

例如，如果你双击“安装你的第一个包”，你将获得更多关于Anaconda Cloud的信息。我们无需登录，甚至不需要云账户，就可以搜索、下载和安装公共包。只有在没有令牌的情况下访问私有包或分享包时，我们才需要一个账户。

深入了解 Jupyter Notebook

在本节中，许多例子来自以下网页：github.com/ipython/ipython-in-depth。如果你有兴趣，可以访问该网页并下载 ZIP 文件。以下截图展示了示例内容：

启动 Jupyter Notebook 后，我们可以搜索example子目录。例如，我们可以上传一个名为factoring.ipynb的笔记本，位于Interactive Widgets子目录下（见下图）：

点击运行后，我们可以更改n的值（当我们选择变量为8时，结果如下）：

当n增加到20时，我们得到了相应的输出：

有时，在运行 Jupyter Notebook 并退出登录后，我们需要令牌或密码才能再次登录。我们可以运行以下代码来查找我们的令牌：

Jupyter notebook list

或者，我们可以运行以下代码将令牌保存到文本文件中：

Jupyter notebook list > t.txt

下一个示例展示了如何激活 Jupyter QtConsole，也就是如何使用 QtConsole 连接到现有的 IPython 内核。同样，Jupyter Notebook 也包含在前面的下载中。首先，我们上传名为Connecting with the Qt Console.ipynb的笔记本。为了节省空间，这里仅显示前几行：

程序运行没有问题后，我们将看到以下窗口：

然后，我们在此输入命令。QtConsole是一个轻量级应用程序，类似于终端。然而，它提供了只有在图形界面中才能实现的许多增强功能，例如内联图形、带语法高亮的多行编辑和图形化的调用提示。QtConsole 可以使用任何 Jupyter 内核。以下是一个示例：

import numpy as np 
from scipy.special import jn 
import matplotlib.pyplot as plt 
from matplotlib.pyplot import plot 
# 
x=np.linspace(0,3*np.pi) 
for i in range(6): 
    plot(x,jn(i,x)) 
# 
plt.show()

相关图示如下：

Jupyter Notebook 格式

在本节中，我们讨论与 Jupyter Notebook 格式相关的问题的核心内容。

若要了解与 Jupyter Notebook 格式相关的更多信息，请参考此处有用的链接：nbformat.readthedocs.io/en/latest/。首先，让我们看一个最简单的笔记本，Custom Widget –Spreadsheet.ipynb。它仅有五行，如下所示：

{ 
 "cells": [], 
 "metadata": {}, 
 "nbformat": 4, 
 "nbformat_minor": 0 
}

整个笔记本代码包含在一对大括号中。在最高层次，Jupyter 笔记本是一个字典，包含以下几个键：

  • metadata（dict）

  • nbformat（int）

  • nbformat_minor（int）

  • cells（list）

在上面的示例代码块中，cells和metadata都是空的。笔记本格式的值为4。通常情况下，自己生成一个简单程序并保存为 Jupyter Notebook 格式，然后查看其结构是一个好主意。接下来，让我们通过 Jupyter Notebook 生成一个简单的 Python 程序（见下方三行）：

若要下载此程序，只需点击文件 | 下载为，并选择 Notebook（.ipynb）作为格式。以下是前面三行代码相关内容。它的文件名为c11_01simplePython.ipynb：

{ 
 "cells": [ 
  { 
   "cell_type": "code", 
   "execution_count": null, 
   "metadata": { 
    "collapsed": true 
   }, 
   "outputs": [], 
   "source": [ 
    "# import numpy as npn", 
    "x=10n", 
    "print(np.sqrt(x))" 
   ] 
  } 
 ], 
 "metadata": { 
  "kernelspec": { 
   "display_name": "Python 3", 
   "language": "python", 
   "name": "python3" 
  }, 
  "language_info": { 
   "codemirror_mode": { 
    "name": "ipython", 
    "version": 3 
   }, 
   "file_extension": ".py", 
   "mimetype": "text/x-python", 
   "name": "python", 
   "nbconvert_exporter": "python", 
   "pygments_lexer": "ipython3", 
   "version": "3.6.3" 
  } 
 }, 
 "nbformat": 4, 
 "nbformat_minor": 2 
}

笔记本共享

要共享笔记本或项目，请按照以下步骤操作：

  1. 保存你的笔记本。

  2. 通过运行 Anaconda 登录命令进行登录。

  3. 要将你的笔记本上传到云端，请打开 Anaconda 提示符或终端，并输入以下命令：

anaconda upload my-notebook.ipynb
  1. 为了检查，我们可以尝试访问notebooks.anaconda.org/<USERNAME>/my-notebook链接，其中 USERNAME 是你的用户名。以下展示了一个例子，我们生成了一个简单的 Jupyter 笔记本，使用了之前的代码：

  1. 假设我们将其下载为c11_01.ipynb. 首先，启动 Anaconda 提示符。

  2. 移动到包含我们 Jupyter 笔记本的正确子目录。然后输入以下命令：

 Anaconda upload c11_01.jpynb
  1. 相应的输出如下所示：

  1. 上一张截图中的最后一条指令告诉我们，可以在anaconda.org/paulyan/c11_01找到它（见下图）：

显然，在那之后，我们可以与合作伙伴或共同作者共享该链接。

项目共享

首先，让我们看看项目的定义。项目是一个包含anaconda-project.yml配置文件的文件夹，文件夹内有脚本（代码）、笔记本、数据集和其他文件。我们可以通过将名为anaconda-project.yml的配置文件添加到文件夹中，将文件夹加入到项目中。配置文件可以包括以下部分：命令、变量、服务、下载、包、通道和环境规范。数据科学家可以使用项目来封装数据科学项目并使其易于移植。项目通常会被压缩成.tar.bz2文件以便共享和存储。

Anaconda Project 自动化了设置步骤，这样你与之共享项目的人只需要以下命令就可以运行你的项目：

anaconda-project run

要安装 Anaconda Project，请键入以下命令：

conda install anaconda-project

Anaconda Project 封装了数据科学项目，使它们易于移植。它自动化了设置步骤，如安装正确的包、下载文件、设置环境变量和运行命令。Project 使得重新制作工作、与他人共享项目以及在不同平台上运行它们变得简单。它还简化了部署到服务器的过程。Anaconda 项目在你的机器上、其他用户的机器上或部署到服务器时运行相同。

传统的构建脚本，如setup.py，自动化项目的构建——从源代码到可运行的东西——而 Project 则自动化了运行项目的过程，处理构建产物，并在执行之前进行必要的设置。

我们可以在 Windows、macOS 和 Linux 上使用 Project。Project 是由 Anaconda Inc® 及其贡献者在三条款 BSD 许可证下支持并提供的。项目共享将节省我们大量时间，因为其他开发人员不会在已经完成的工作上浪费过多时间。以下是具体步骤：

  1. 构建你的项目

  2. 登录到 Anaconda

  3. 从计算机上的项目目录中，输入以下命令：

anaconda-project upload

或者，在 Anaconda Navigator 中，在 Projects 标签页下，点击右下角的上传按钮，将项目上传到 Anaconda Cloud。

项目可以是任何代码和资源的目录。例如，项目通常包含笔记本或 Bokeh 应用程序。在这里，我们展示如何生成一个名为project01的项目。首先，我们需要进入正确的位置。假设我们选择了c:/temp/，关键命令如下所示：

anaconda-project init --directory project01

接下来，两个命令并排显示：

$ cd c:/temp/ 
$ anaconda-project init --directory project01 
Create directory 'c:tempproject01'? y 
Project configuration is in c:tempproject01iris/anaconda-project.yml

对应的输出如下所示：

我们还可以通过切换到该目录并运行anaconda-project init（不带选项或参数）将任何现有目录转换为项目。我们可以使用 MS Word 打开anaconda-project.yml（以下显示的是前几行）：

# This is an Anaconda project file. 
# 
# Here you can describe your project and how to run it. 
# Use `anaconda-project run` to run the project. 
# The file is in YAML format, please see http://www.yaml.org/start.html for more. 
# 
# Set the 'name' key to name your project 
# 
name: project01 
# 
# Set the 'icon' key to give your project an icon 
# 
icon: 
# 
# Set a one-sentence-or-so 'description' key with project details 
# 
description: 
# 
# In the commands section, list your runnable scripts, notebooks, and other code. 
# Use `anaconda-project add-command` to add commands. 
#

有两种方法可以与他人共享我们的项目。首先，我们通过输入以下命令来归档项目：

anaconda-project archive project01.zip

然后，我们将 ZIP 文件通过电子邮件发送给我们的同事或其他人。共享项目的第二种方式是使用 Anaconda Cloud。首先登录到 Anaconda Cloud。从我们计算机上的项目目录中，输入anaconda-project upload，或者在 Anaconda Navigator 中，在 Projects 标签页下，点击右下角的上传按钮，将项目上传到 Anaconda Cloud。

环境共享

就计算机软件而言，操作环境或集成应用环境是用户可以执行软件的环境。通常，这样的环境由用户界面和 API 组成。在一定程度上，术语平台可以看作它的同义词。我们希望与他人共享我们的环境有很多原因。例如，他们可以重现我们做过的测试。为了让他们能够快速重建我们带有所有软件包和版本的环境，可以将你的environment.yml文件副本提供给他们。根据操作系统的不同，我们有以下方法导出环境文件。请注意，如果当前目录中已有environment.yml文件，执行此任务时它将被覆盖。

根据使用的操作系统，有不同的方法来激活myenv环境文件。对于 Windows 用户，在 Anaconda 提示符下输入以下命令：

activate myenv

在 macOS 和 Linux 系统中，在终端窗口输入以下命令：

source activate myenv

请注意，我们将myenv替换为环境的名称。要将我们当前活动的环境导出到新文件中，输入以下命令：

conda env export > environment.yml

若要共享，我们可以简单地通过电子邮件或复制导出的 environment.yml 文件给对方。另一方面，为了删除一个环境，我们可以在终端窗口或 Anaconda 提示符下运行以下代码：

conda remove --name myenv --all

或者，我们可以像这里一样指定名称：

conda env remove --name myenv

要验证环境是否已被移除，请运行以下命令：

conda info --envs

在本地复制他人环境

首先，我们可以通过以下命令导出我们的 Anaconda 环境：

conda env export > myEnv.yml

生成此文件后，可以使用记事本打开它（请参见以下几个输出文件的行）。为了节省空间，仅显示第一行和最后几行：

name: base 
channels: 
  - anaconda 
  - defaults 
dependencies: 
  - bzip2=1.0.6=vc14h31cfb99_1 
  - curl=7.55.1=vc14h8488bd0_3 
  - freetype=2.8=vc14hfa46bb4_0 
  - hdf5=1.10.1=vc14h7c25517_0 
  - icu=58.2=vc14hbe8e9fa_0 
  - jpeg=9b=vc14h39a59fb_1 
  - libiconv=1.15=vc14h61b1384_5 
  - libpng=1.6.32=vc14hf267d31_3 
  - libssh2=1.8.0=vc14h91c0462_2 

  - xlrd=1.1.0=py36he7b893d_1 
  - xlsxwriter=1.0.2=py36hde92fec_0 
  - xlwings=0.11.4=py36h89f095e_0 
  - xlwt=1.3.0=py36hb79324b_0 
  - zict=0.1.3=py36hf291af1_0 
prefix: C:UsersyanyAppDataLocalContinuumanaconda3

然后，接收上述文件的人可以通过以下命令重新创建它：

conda env create -f myEnv.yml

从 Anaconda 下载软件包

有时，用户可能会生成自己的软件包并上传到 Anaconda Cloud。对于一个团队项目，团队成员也可以这么做。因此，我们需要了解如何从 Anaconda Cloud 下载软件包。以下是一般的操作步骤：

  1. 访问 anaconda.org

  2. 使用关键字或多个关键字搜索软件包，如此示例所示：

假设我们对 r-data.table 软件包感兴趣。

  1. 执行以下命令：
conda install -c r-data.table

有时，我们可以生成一组函数并与他人共享。以下是一个简单示例。假设我们生成了以下带有多个函数的程序：

def pv_f(r,n,fv): 
    """ 
    Objective: estimate present value 
           r : period rate 
           n : number of periods 
          fv : future value 
                           fv 
    formula used : pv = --------       
                        (1+r)**n 
    Example 1: >>>pv_f(0.1,1,100)   # meanings of input variables  
                 90.9090909090909   # based on their input order 
    Example #2 >>>pv_f(r=0.1,fv=100,n=1) # on keywords 
                 90.9090909090909 
    """ 
    return fv/(1+r)**n 
# 
def pvGrowingPerpetuity(c,r,q): 
    return(c/(r-q)) 
# 
def fv_f(pv,r,n): 
    return pv*(1+r)**n 
def fvAnnuity(r,n,c): 
    return c/r*((1+r)**n-1) 
# 
def fvAnnuityDue(r,n,c): 
    return c/r*((1+r)**n-1)*(1+r)

为了节省空间，这里仅展示第一个函数的帮助信息。假设之前的函数叫做 myfincal.py 并保存在 c:/temp 下。我们可以使用以下命令生成 myfincal.pyc 并导入 py_compile。

py_compile.compile('c:/temp/myfincal.py')

我们已经生成了一组包含在 fincal.pyc 中的函数。如果你有兴趣，可以按照以下步骤下载并导入它：

  1. 从 canisius.edu/~yany/python/fincal.pyc 下载它。

  2. 启动 Python 并尝试导入它。有几种方法可以使 fincal.pyc 可访问：

  • 方法 1：假设文件保存在 c:/temp/ 目录下。可以像截图右侧那样更改路径：

  • 方法 2：将 fincal.pyc 复制到一个可访问的子目录下。要查看所有路径，执行以下代码：
import sys 
sys.path

输出如下所示。不同用户将会有不同的输出：

现在，只需将 fincal.pyc 复制到上述子目录之一即可。

  • 方法 3：改为添加路径，见下面的代码：
import sys 
sys.path.append('c:\temp')

我们可以执行 sys.path 来检查，见以下截图：

注意，如果我们想删除路径，可以使用以下代码：

import sys 
sys.path.remove('c:\temp')
  1. 现在，我们可以导入该模块，见下面的代码：
import fincal 
x=dir(fincal) 
print(x)

相关输出如下所示：

请注意，由于 Yahoo!Finance 和 Google Finance 改变了它们的数据结构，许多与从它们的网站下载数据相关的功能将无法使用。

总结

在本章中，我们讨论了 Anaconda Cloud。内容包括深入探讨 Jupyter Notebook，Jupyter Notebook 的不同格式，如何与伙伴共享笔记本，如何在不同平台间共享项目，如何共享工作环境，以及如何在本地复制他人的环境。

在下一章中，我们将讨论分布式计算和 Anaconda Accelerate。当我们的数据或任务变得更加复杂时，我们将需要一个良好的系统或一套工具来处理数据并运行复杂的算法。为此，分布式计算是一个解决方案。具体来说，我们将解释许多概念，例如计算节点、项目附加组件、并行处理、数据并行的高级 Python 等。除此之外，我们还将提供几个示例，展示如何使用分布式计算。

复习问题和练习

  1. 云 是什么意思？

  2. 云计算 是什么意思？

  3. 为什么我们关心与他人共享我们的工作环境？

  4. 我们如何在 Anaconda Cloud 上注册？

  5. 用户需要账户才能使用 Anaconda Cloud 平台吗？

  6. 我们如何将笔记本上传到 Anaconda Cloud？

  7. 为什么共享我们的项目很重要？

  8. 如何共享你的项目？创建一个项目并与他人共享。

  9. 如何重建你伙伴的 Anaconda 环境？

  10. 以下两行命令的含义是什么：

conda remove --name myenv -all 
conda info -envs

  1. 如何启动 Jupyter QtConsole？

  2. 在 examples/Builtin Extension 子目录下运行名为 Octave Maric.ipynb 的 Jupyter 笔记本。请注意，首先你需要找到方法安装一个名为 octavemagic 的包。

  3. 与他人共享你的环境，以查看效果。

  4. 围绕一个主题生成一组函数，并生成相应的 .pyc 文件，与同事或合作伙伴共享。

第十二章：分布式计算、并行计算和 HPCC

由于我们的社会已经进入数据密集型时代（即大数据时代），我们面临着越来越大的数据集。因此，企业和用户正在考虑在处理数据时可以使用哪些工具来加速过程。一个显而易见的解决方案是增加他们的数据存储容量。不幸的是，这涉及到巨大的成本。其他解决方案包括分布式计算以及一些加速我们的过程的方法。

在本章中，我们将讨论以下主题：

  • 分布式计算与并行计算的简介

  • 理解 MPI

  • Python 中的并行处理

  • 计算节点

  • Anaconda 附加组件

  • HPCC 简介

分布式计算与并行计算的简介

分布式计算是计算机科学的一个子领域，研究分布式系统和模型，其中位于网络计算机上的组件通过传递消息进行通信和协调操作。这些组件相互作用，以实现共同的目标。

值得讨论的另一个短语是：并行计算。并行计算与多线程紧密相关，或如何充分利用单个 CPU，而分布式计算则涉及分而治之的概念，在不同的机器上执行子任务，然后合并结果。

由于我们已经进入了所谓的大数据时代，似乎这种区分正在消失。事实上，现在许多系统采用了并行计算和分布式计算的结合方式。

并行处理的任务视图

对于 R，存在一个任务视图叫做使用 R 进行高性能和并行计算。回顾一下，任务视图是围绕特定主题的一组 R 程序。为了找到使用 R 进行高性能和并行计算的任务视图，我们访问 r-project.org，点击左侧的 CRAN，选择一个附近的镜像位置，然后点击 Packages 和 Task Views。

双击任务视图后，我们可以看到以下列表——为了节省空间，仅显示了顶部的任务视图：

双击相关的任务视图（HighPerformanceComputing）后，我们可以看到以下截图——为了节省空间，仅显示了顶部几行：

上面的任务视图包含了一些包的列表，这些包按照不同的主题进行分组，可能对高性能计算（HPC）与 R 语言的结合有用。在此背景下，任务视图的维护者将高性能计算的定义相当宽泛，只要是与推动 R 向前发展相关的内容，都会涉及其中：使用编译代码、并行计算（包括显式和隐式模式）、处理大对象以及性能分析。上述任务视图可以在CRAN.R-project.org/view=HighPerformanceComputing下载。如前几章所讨论的，我们可以使用以下命令来安装所有相关的 R 包：

install.packages("ctv") 
library("ctv") 
install.views("HighPerformanceComputing")

2018 年 5 月 14 日，通过运行之前的代码，下载并安装了 217 个相关的 R 包。

Python 中的示例程序

对于 Python 并行计算程序，我们可以访问IPython 深入教程，网址为github.com/ipython/ipython-in-depth。下载 ZIP 文件并解压后，我们可以找到与并行计算相关的程序（参考下面的两张截图）：

上面的截图显示了几个子目录，而下面的截图展示了包括 Jupyter Notebook 和 Python 程序在内的 19 个程序：

理解 MPI

通常，平行算法需要在不同引擎之间移动数据。做到这一点的一个方法是通过直接视图先进行拉取再推送。然而，这种方法非常缓慢，因为所有数据都必须经过控制器到达客户端，然后再通过控制器返回到最终目标。一个更好的方法是使用消息传递库，比如消息传递接口（MPI）。IPython 的并行计算架构已经设计成可以与 MPI 集成。要下载并安装 Windows 版本的 MPI，读者可以参考msdn.microsoft.com/en-us/library/bb524831%28v=vs.85%29.aspx。

此外，你还可以安装mpi4py包。

R 包 Rmpi

要找到与Rmpi包相关的示例，我们可以执行以下两行代码：

library(Rmpi) 
demo()

按下Enter键后，我们将看到以下输出：

对于第一个函数，叫做cslavePI，我们知道应该将cslavePI.c从 Rmpi 库目录复制到工作目录，并使用mpicc -o cslavePI cslavePI.c编译它。要找到 Rmpi 的路径，我们可以执行find.package()函数（参考以下代码和结果）：

> find.package("Rmpi") 
[1] "C:/Users/yany/Documents/R/win-library/3.4/Rmpi"

请注意，不同的读者将得到不同的路径。我们可以使用demo(cslavePI)来查找它的功能。参考代码和相关的输出，如下所示：

mpicc 软件用于编译和链接用 C 语言编写的 MPI 程序。

R 包 plyr

plyr R 包的目标是实现 R 中的拆分-应用-组合范式。这在数据分析中非常常见：我们通过将一个复杂问题分解为小块，对每个块做一些处理，然后将结果重新合并。以下是一个来自其菜单的示例，经过小幅修改：

library(plyr) 
d1<-c(rep('A', 8), rep('B', 15), rep('C', 6)) 
d2<-sample(c("M", "F"), size = 29, replace = TRUE) 
d3<-runif(n = 29, min = 18, max = 54) 
# 
dfx <- data.frame(group =d1,sex=d2,age=d3) 
# 
ddply(dfx, .(group, sex), summarize, 
 mean = round(mean(age), 2), 
 sd = round(sd(age), 2)) 
# 
ddply(baseball[1:100,], ~ year, nrow) 
ddply(baseball, .(lg), c("nrow", "ncol")) 
rbi<-ddply(baseball, .(year), summarise, 
      mean_rbi=mean(rbi, na.rm = TRUE)) 
plot(mean_rbi~year,type="l",data = rbi) 
base2<-ddply(baseball,.(id),mutate, 
    career_year = year - min(year) + 1 
)

为了节省空间，这里仅显示图形：

arrange()函数按数据框的列进行排序（参考以下代码）：

library(datasets) 
library(plyr) 
data(mtcars) 
# 
d1<-mtcars[with(mtcars, order(cyl, disp)), ] 
d2<-arrange(mtcars, cyl, disp) 
myCars = cbind(vehicle=row.names(mtcars), mtcars) 
d3<-arrange(myCars, cyl, disp) 
d4<-arrange(myCars, cyl, desc(disp))

R 包 parallel

首先，让我们看一下 R 函数lapply()的简单用法（参考以下代码）：

> lapply(1:3,function(x) c(sin(x),x²)) 
[[1]] 
[1] 0.841471 1.000000 
[[2]] 
[1] 0.9092974 4.0000000 
[[3]] 
[1] 0.14112 9.00000

含义很明确：我们有1、2和3这三个输入值，并将它们分配给三个函数。以下示例稍微复杂一些：

myFunctions<-c(sin(x),x²+2,4*x²-x³-2) 
inputValue<-1:10 
output<-lapply(inputValue,function(x) myFunctions)

前几行输出如下所示：

以下示例来自于Gordon（2015）：

library(parallel) 
n_cores <- detectCores() - 1 
cl <- makeCluster(n_cores) 
parLapply(cl, 2:4,function(exponent) 2^exponent) 
stopCluster(cl)

在前面的代码中，makeCluster()函数将设置集群。parLapply()函数调用lapply()的并行版本或parLapply()函数。输出如下所示：

 [[1]] 
[1] 4 

[[2]] 
[1] 8 

[[3]] 
[1] 16

对于以下代码，我们将看到一个错误信息：

c2<-makeCluster(n_cores) 
base <- 2 
parLapply(c2, 2:4, function(exponent) base^exponent) 
stopCluster(c2)

错误信息如下：

Error in checkForRemoteErrors(val) :  
  3 nodes produced errors; first error: object 'base' not found

为了修正这个问题，将添加基变量（参考以下代码）。

c3<-makeCluster(n_cores) 
base <- 2 
clusterExport(c3, "base") 
parLapply(c3, 2:4, function(exponent)  base^exponent) 
stopCluster(c3)

为了节省空间，输出将在此不显示。以下是另一个示例，展示调用lapply()和mclapply()函数之间的区别：

library(parallel) 
detectCores() 
myFunction<- function(iter=1,n=5){ 
    x<- rnorm(n, mean=0, sd=1 ) 
    eps <- runif(n,-2,2) 
    y <- 1 + 2*x + eps 
    result<-lm( y ~ x ) 
    final<-cbind(result$coef,confint(result)) 
    return(final)  
} 
# 
m<-5000
n2<-5000
system.time(lapply(1:m,myFunction,n=n2))
system.time(mclapply(1:m,myFunction,n=n2))

输出如下所示：

> system.time(lapply(1:n,myFunction,n=n2)) 
 user  system elapsed  
  63.97    3.26   22.49
> system.time(mclapply(1:n,myFunction,n=n2)) 
 user  system elapsed  
  63.33 3.28 22.26

在前面的代码中，使用了lappy()和mclappy()函数。mclapply()函数是lapply()函数的并行化版本。它返回一个与X长度相同的列表，每个元素都是将FUN应用于X中相应元素的结果。以下程序来自于www.smart-stats.org/wiki/parallel-computing-cluster-using-r，并经过了少量修改。请注意，程序是在 UNIX 上运行的，而不是 PC：

library(snow) 
library(parallel) 
#library(Rmpi) 
myFunction<-function(n) { 
    a<-rnorm(n) 
    final<-log(abs(a))+a³+2*a; 
    return(final) 
} 
nCores=11; 
#Using multicore 
system.time(mclapply(rep(5E6,11),myFunction,mc.cores=nCores)) 
#Using snow via MPI 
system.time(sapply(rep(5E6,11),myFunction)) 
#cl <- getMPIcluster() 
cl <- makeCluster(c("localhost","localhost"), type = "SOCK") 
system.time(parSapply(cl,rep(5E6,11),myFunction))

相关输出如下所示：

> system.time(mclapply(rep(5E6,11),myFunction,mc.cores=nCores)) user  system elapsed 
  4.440   1.075   1.926 > system.time(sapply(rep(5E6,11),myFunction)) user  system elapsed 
 10.294   0.992  11.286 > system.time(parSapply(cl,rep(5E6,11),myFunction)) user  system elapsed 
  0.655   0.626   7.328 > proc.time() user  system elapsed 
 15.621   2.936  22.134

R 包 snow

该包用于简单工作站网络（SNOW）。让我们来看一个与销毁相关的程序：

library(snow) 
cl <- makeSOCKcluster(c("localhost","localhost")) 
clusterApply(cl, 1:2, get("+"), 3) 
clusterEvalQ(cl, library(boot)) 
x<-1 
clusterExport(cl, "x") 
clusterCall(cl, function(y) x + y, 2)

makeSOCKcluster() 函数用于启动和停止 snow 集群，并设置默认的集群选项。clusterApply() 在第一个集群节点上调用该函数，参数为 seq[[1]] and ...，在第二个节点上调用 seq[[2]] and ...，以此类推。如果 seq 的长度大于集群节点的数量，则会回收集群节点。返回一个结果列表；结果列表的长度将等于 seq 的长度。clusterCall() 在集群 cl 中每个节点上使用相同的参数调用函数，并返回结果列表。clusterEvalQ() 函数在每个集群节点上评估一个字面表达式。它是 evalq 的集群版本，是一个基于 clusterCall() 的便捷函数。

Python 中的并行处理

以下示例关于计算 π 的数字，摘自网站 ipyparallel.readthedocs.io/en/latest/demos.html#parallel-examples。由于第一部分需要一个名为 one_digit_freqs() 的函数，我们可以运行一个名为 pidigits.py 的 Python 程序，该程序包含在 .../ipython-ipython-in-depth-4d98937\examples\Parallel Computing\pi 路径下，该路径取决于读者下载并保存文件的位置。

为了完成我们的部分，我们只需将其包含在程序的第一部分，如下所示：

import matplotlib.pyplot as plt
import sympy
import numpy as np 
#
def plot_one_digit_freqs(f1):
    """
    Plot one digit frequency counts using matplotlib.
    """
    ax = plt.plot(f1,'bo-')
    plt.title('Single digit counts in pi')
    plt.xlabel('Digit')
    plt.ylabel('Count')
    return ax
#
def one_digit_freqs(digits, normalize=False):
    """
    Consume digits of pi and compute 1 digit freq. counts.
    """
    freqs = np.zeros(10, dtype='i4')
    for d in digits:
        freqs[int(d)] += 1
    if normalize:
        freqs = freqs/freqs.sum()
    return freqs
#
pi = sympy.pi.evalf(40)
pi
pi = sympy.pi.evalf(10000)
digits = (d for d in str(pi)[2:]) # create a sequence of digits
freqs = one_digit_freqs(digits)
plot_one_digit_freqs(freqs)
plt.show()

相关的图表如下所示：

词频的并行处理

首先，让我们来看一个简单的 Python 程序，找出输入文本文件中最常用的单词。我们随机选择了《达·芬奇密码》，可以在 www.gutenberg.org/files/5000/5000-8.txt 找到。假设下载的小说保存在 c:/temp/daVinci.txt 下。以下 Python 代码将列出最常用的前 10 个单词：

text = open("c:/temp/daVinci.txt",'r').read().lower() 
def byFreq(pair): 
    return pair[1] 
for ch in '!"#$%&()*+,-./:;<=>?@[\]^_`{|}~': 
    text = text.replace(ch, ' ') 
    words = text.split() 
counts = {} 
for w in words: 
    counts[w] = counts.get(w,0) + 1 
n = 10   # for the first n most frequetly used words 
words= list(counts.items()) 
words.sort() 
words.sort(key=byFreq, reverse=True) 
for i in range(n): 
    word, count =words[i] 
    print("{0:<15}{1:>5}".format(word, count))

相关的输出结果如下所示：

the            22989 
of             11232 
and             8434 
in              5750 
to              5313 
a               4725 
is              4273 
it              3071 
that            2902 
which           2545

并行蒙特卡洛期权定价

这个示例来自之前讨论的 Python 示例程序。该笔记本展示了如何使用 ipyparallel 包进行蒙特卡洛期权定价的并行计算。该笔记本计算了不同执行价格和波动率下大量期权的价格。

为了节省空间，这里只给出了代码的前几行：

%matplotlib inline 
import matplotlib.pyplot as plt 
import sys 
import time 
from ipyparallel import Client 
import numpy as np 
price = 100.0  # Initial price 
rate = 0.05  # Interest rate 
days = 260  # Days to expiration 
paths = 10000  # Number of MC paths 
n_strikes = 6  # Number of strike values 
min_strike = 90.0  # Min strike price 
max_strike = 110.0  # Max strike price 
n_sigmas = 5  # Number of volatility values 
min_sigma = 0.1  # Min volatility 
max_sigma = 0.4  # Max volatility 
# (more ....)

要运行它，点击 IPython Clusters。在右侧点击 IPython Clusters 后，我们将看到以下截图：

我们可以点击“启动”以使用默认设置。引擎数量会显示为 4，如下所示：

现在，我们回到我们上传的 Jupyter Notebook，进行并行蒙特卡洛期权定价。总共有四个输出图像。为了节省空间，这里只显示第一个：

请注意，使用股票平均价格作为最终终端价格的亚洲看跌期权的支付函数如下所示，其中 Put(Asian) 是亚洲看跌期权，K 是执行价格，而 是路径上的平均价格：

计算节点

计算节点提供短暂存储、网络、内存和处理资源，这些资源可以被虚拟机实例消耗。云系统支持两种类型的计算节点：ESX 集群，其中集群在 VMware vCenter Server 中创建，以及 KVM 计算节点，其中 KVM 计算节点是手动创建的。在前一章中，我们提到了云的概念。

在云环境中，这对于更复杂的项目非常有用，计算节点是资源的核心。通常，这些节点提供虚拟机实例所需的处理、内存、网络和存储。当实例被创建时，它会与具有可用资源的计算节点匹配。一个计算节点可以托管多个实例，直到其所有资源被消耗完。

Anaconda 附加组件

以下信息来自 Anaconda 附加组件开发指南。

Anaconda 附加组件是一个 Python 包，其中包含一个包含 __init__.py 文件和其他源目录（子包）的目录。因为 Python 只允许每个包名称导入一次，所以包的顶级目录名称必须是唯一的。同时，名称可以是任意的，因为附加组件会根据名称加载；唯一的要求是它们必须放在特定的目录中。

因此，建议的附加组件命名约定类似于 Java 包或 D-Bus 服务名称：将附加组件名称的前缀设置为贵组织的反向域名，使用下划线（_）代替点号，这样目录名称就是一个有效的 Python 包标识符。根据这些建议的命名约定，附加组件名称示例如 org_fedora_hello_world。此命名约定遵循了 Python 包和模块名称的推荐命名方案。感兴趣的读者可以在 rhinstaller.github.io/anaconda-addon-development-guide/index.html#sect-anaconda-introduction-addons 查找有关 Anaconda 附加组件的更多信息。

HPCC 简介

HPCC 代表 高性能计算集群。它也被称为 数据分析超级计算机 (DAS)，是 LexisNexis Risk Solutions 开发的一个开源、数据密集型计算系统平台。HPCC 平台包含一种在计算集群上实现的软件架构，提供高性能、数据并行处理设计，用于使用大数据的各种应用。HPCC 平台包括支持并行批量数据处理（Thor）和高性能在线查询应用程序（Roxie）的系统配置，这些应用程序使用索引数据文件。HPCC 平台还包括一种数据中心声明式编程语言，用于并行数据处理，称为 ECL。

你可以在 research-it.wharton.upenn.edu/documentation/ 查看 Wharton HPCC 系统的一个简单示例。Wharton 的 HPC 集群（HPCC）为 Wharton 教职工、教职工合作者、研究助理以及 Wharton 博士生提供先进的计算研究硬件和软件。它旨在通过一组紧密集成的硬件，配备专用的网络和存储，进行简单且并行的处理。

关于硬件的更多信息，请参阅硬件页面。HPCC 用户可以访问多种科学、数学和分析软件，包括 MATLAB、Mathematica、R、Stata 和 SAS。也可以提供 MySQL 服务器访问权限。HPCC 还具备 GNU 和 Intel 版本的 Fortran、C 和 C++ 编译器。以下是连接到 HPCC 平台的简单步骤：

  1. 首先，下载并安装 FortClient 和 MobaXterm 软件

  2. 通过 FortClient 连接到 Wharton VPN（如下图所示）：

  1. 连接后，以下界面将出现：

  1. 使用 MobaXterm 软件连接到 Wharton 的 HPCC 平台。这里假设你已经有 Wharton 的账号（参见下图）：

  1. 现在，我们可以进行连接，如下图所示：

  1. 现在，用户将编写自己的程序，利用 HPCC 加速他们的研究和实验。更多信息，请参考 research-it.wharton.upenn.edu/documentation/ 上的文档。

总结

在本章中，我们讨论了几个 R 包，如 plyr、snow、Rmpi 和 parallel，以及 Python 包 ipyparallel。此外，我们还提到了计算节点、项目插件、并行处理和 HPCC。

现在，我们已经走到了旅程的尽头。我们祝愿你在未来的冒险中好运，并且能够利用从本书中学到的知识去做一些了不起的事情。

回顾问题和练习

  1. 什么是分布式计算？它有什么用？

  2. 我们可以从哪里获得并行计算的任务视图？

  3. 从与并行计算相关的任务视图中，我们可以找到许多 R 包。找出其中的一些包。安装两个并展示使用这两个包的示例。

  4. 使用以下方式进行词频分析：亚历山大·仲马的《基督山伯爵》（输入文件在 www.gutenberg.org/files/1184/1184-0.txt）。

  5. 我们可以从哪里找到更多关于 Anaconda 插件的信息？

  6. 什么是 HPCC，它是如何工作的？

  7. 我们如何找到已安装的 R 包的路径？

  8. 在关于并行蒙特卡洛期权定价的示例 Jupyter 笔记本中，相关的亚洲期权在此定义，其中 call(Asian) 是亚洲看跌期权，Put(Asian)，K 是行使价格，且 是路径上的平均价格：

编写一个 Jupyter 笔记本，使用以下亚洲期权的定义：

  1. 在本章中，我们提到可以使用以下三行代码来下载与高性能计算相关的所有 R 包：
install.packages("ctv") 
library("ctv") 
install.views("HighPerformanceComputing")

尝试这个并报告下载了多少个 R 包。

  1. 查找与 R 包 Rmpi 相关的更多示例。

  2. 运行名为 Using MPI 的示例 Jupyter 笔记本，文件为 IPython Parallel.ipynb。解释其含义。

  3. R 的 doRNG 包提供了执行可重现的并行 foreach 循环的函数，使用由 rstream 包生成的独立随机流，适用于不同的 foreach 后端。下载并安装此包及其他相关包。展示一些示例。

第十三章：参考文献

第一章：Anaconda 生态系统

第二章：Anaconda 安装

第三章：数据基础

第四章：数据可视化

第五章：Anaconda 中的统计建模

第六章：包管理

第七章：Anaconda 中的优化

第八章：Anaconda 中的无监督学习

第九章：Anaconda 中的监督学习

第十章：预测数据分析 – 建模与验证

第十一章：Anaconda Cloud

第十二章：分布式计算、并行计算与高性能计算中心（HPCC）

avatar
文章
阅读
粉丝