• Posts tagged "base64"

Blog Archives

R语言中的编码和解码

R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大。

R语言作为统计学一门语言,一直在小众领域闪耀着光芒。直到大数据的爆发,R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入,R语言的社区在迅速扩大成长。现在已不仅仅是统计领域,教育,银行,电商,互联网….都在使用R语言。

要成为有理想的极客,我们不能停留在语法上,要掌握牢固的数学,概率,统计知识,同时还要有创新精神,把R语言发挥到各个领域。让我们一起动起来吧,开始R的极客理想。

关于作者:

  • 张丹,分析师/程序员/Quant: R,Java,Nodejs
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-encode-decode/

前言

编码是信息从一种形式或格式转换为另一种形式的过程,解码是编码的逆过程。编码和解码的应用场景,普遍存在于数据通信,不同系统的对接,数据格式标准化等领域。

本文主要介绍了3种类型的编码和解码的方法,都有对应的R语言函数来支持,这样就让我们的开发工作变得更容易了。

目录

  1. base64编码和解码
  2. URL编码和解码
  3. 序列化和反序列化

1. base64编码和解码

base64编码,是在网络数据传输过程中,一种常用的数据编码格式。Base64是网络上最常见的用于传输8Bit字节码的编码方式之一,Base64就是一种基于64个可打印字符来表示二进制数据的方法。Base64编码是从二进制到字符的过程,可用于在HTTP环境下传递较长的标识信息。采用Base64编码具有不可读性,需要解码后才能阅读。

Base64是一种编码方式,最初是在“MIME内容传输编码规范”中提出。Base64不是一种加密算法,它是一种二进制转换到文本的编码方式,它能够将任意二进制数据转换为ASCII字符串的形式,以便在只支持文本的环境中也能够顺利地传输二进制数据。

  • base64编码(encode):把二进制数据转为字符;
  • base64解码(decode):把字符转为二进制数据;

我们可以使用R语言的base64enc包,进行base64编码和解码。


# 加载base64enc包
> library(base64enc)

# 原始文本数据
> value<-"abc=!@#$%^&*()_+abc试试中文"

# 字符串转换为原始字节
> x <- charToRaw(value);x
 [1] 61 62 63 3d 21 40 23 24 25 5e 26 2a 28 29 5f 2b 61 62 63
[20] ca d4 ca d4 d6 d0 ce c4

# base64编码
> y <- base64encode(x);y
[1] "YWJjPSFAIyQlXiYqKClfK2FiY8rUytTW0M7E"

# base64解码
> z <- base64decode(y);z
 [1] 61 62 63 3d 21 40 23 24 25 5e 26 2a 28 29 5f 2b 61 62 63
[20] ca d4 ca d4 d6 d0 ce c4

# 字节转换为字符串
> a <- rawToChar(z);a
[1] "abc=!@#$%^&*()_+abc试试中文"

同时,也可以使用jsonlite包进行,进行base64编码和解码。


# 加载jsonlite包
> library(jsonlite)

# 原始文本数据
> value<-"abc=!@#$%^&*()_+abc试试中文"

# base64编码,默认会做charToRaw
> a<-base64_enc(value);a
[1] "YWJjPSFAIyQlXiYqKClfK2FiY8rUytTW0M7E"

# base64解码,字节转换为字符串
> b<-rawToChar(base64_dec(a));b
[1] "abc=!@#$%^&*()_+abc试试中文"

上面2种方法,都可以正确地进行base64的编码和解码。

2. URL编码和解码

URL encoding是Uniform Resource Identifier(URI)规范文档中对特殊字符编码制定的规则。本质是把一个字符转为%加上UTF-8编码对应的16进制数字。

url编码是一种浏览器用来打包表单输入的格式的方法。浏览器从表单中获取所有的name和其中的值 ,将它们以name/value参数编码(移去那些不能传送的字符,将数据排行等等)作为URL的一部分或者分离地发给服务器。服务器端的表单输入格式,如: theName=Ichabod+Crane&gender=male&status=missing&headless=yes

URL 只支持 ASCII 码传输,URL encoding 使用 % 加上两个十六进制数编码不支持的字符,URL 不能含有空格,URL encoding 替换空格成 %20 。

  • URL编码(encode):把URL文本转换为URL编码
  • URL解码(decode):把URL编码转换为URL文本

# 原始URL
> url<-"http://blog.fens.me/abc=中@文&action=你 好"

# URL编码
> a1<-URLencode(url);a1
[1] "http://blog.fens.me/abc=%D6%D0@%CE%C4&action=%C4%E3%20%BA%C3"

# URL解码
> b1<-URLdecode(a);b1
[1] "http://blog.fens.me/abc=中@文&action=你 好"

# 把'保留'字符编码,如http://中的://
> a2<-URLencode(url,reserved = TRUE);a2
[1] "http%3A%2F%2Fblog.fens.me%2Fabc%3D%D6%D0%40%CE%C4%26action%3D%C4%E3%20%BA%C3"

# URL解码
> b2<-URLdecode(a);b2
[1] "http://blog.fens.me/abc=中@文&action=你 好"

3. 序列化和反序列化

序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间,对象将其当前状态写入到临时或持久性存储区。以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象。

序列化的目标:以某种存储形式使自定义对象持久化,将对象从一个地方传递到另一个地方,使程序更具维护性。基本上只要是涉及到跨平台存储或者进行网络传输的数据,都需要进行序列化。

  • seriallization 序列化 : 将对象转化为便于传输的格式, 常见的序列化格式:二进制格式,字节数组,json字符串,xml字符串。
  • deseriallization 反序列化:将序列化的数据恢复为对象的过程。

字符数据序列化。


# 原始字符数据
> value<-"abc=!@#$%^&*()_+abc试试中文"

# 序列化
> a<-serialize(value,NULL);a
 [1] 58 0a 00 00 00 03 00 04 00 03 00 03 05 00 00 00 00 05 43 50
[21] 39 33 36 00 00 00 10 00 00 00 01 00 00 00 09 00 00 00 1b 61
[41] 62 63 3d 21 40 23 24 25 5e 26 2a 28 29 5f 2b 61 62 63 ca d4
[61] ca d4 d6 d0 ce c4

# 反序列化
> b<-unserialize(a);b
[1] "abc=!@#$%^&*()_+abc试试中文"

data.frame数据序列化。


# 原始数据
> dat<-mtcars[1:2,];dat
              mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4      21   6  160 110  3.9 2.620 16.46  0  1    4    4
Mazda RX4 Wag  21   6  160 110  3.9 2.875 17.02  0  1    4    4

# 序列化
> a<-serialize(dat,NULL);a
  [1] 58 0a 00 00 00 03 00 04 00 03 00 03 05 00 00 00 00 05 43
 [20] 50 39 33 36 00 00 03 13 00 00 00 0b 00 00 00 0e 00 00 00
 [39] 02 40 35 00 00 00 00 00 00 40 35 00 00 00 00 00 00 00 00
 [58] 00 0e 00 00 00 02 40 18 00 00 00 00 00 00 40 18 00 00 00
 [77] 00 00 00 00 00 00 0e 00 00 00 02 40 64 00 00 00 00 00 00
 [96] 40 64 00 00 00 00 00 00 00 00 00 0e 00 00 00 02 40 5b 80
[115] 00 00 00 00 00 40 5b 80 00 00 00 00 00 00 00 00 0e 00 00
[134] 00 02 40 0f 33 33 33 33 33 33 40 0f 33 33 33 33 33 33 00
[153] 00 00 0e 00 00 00 02 40 04 f5 c2 8f 5c 28 f6 40 07 00 00
[172] 00 00 00 00 00 00 00 0e 00 00 00 02 40 30 75 c2 8f 5c 28
[191] f6 40 31 05 1e b8 51 eb 85 00 00 00 0e 00 00 00 02 00 00
[210] 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 0e 00
[229] 00 00 02 3f f0 00 00 00 00 00 00 3f f0 00 00 00 00 00 00
[248] 00 00 00 0e 00 00 00 02 40 10 00 00 00 00 00 00 40 10 00
[267] 00 00 00 00 00 00 00 00 0e 00 00 00 02 40 10 00 00 00 00
[286] 00 00 40 10 00 00 00 00 00 00 00 00 04 02 00 00 00 01 00
[305] 04 00 09 00 00 00 05 6e 61 6d 65 73 00 00 00 10 00 00 00
[324] 0b 00 04 00 09 00 00 00 03 6d 70 67 00 04 00 09 00 00 00
[343] 03 63 79 6c 00 04 00 09 00 00 00 04 64 69 73 70 00 04 00
[362] 09 00 00 00 02 68 70 00 04 00 09 00 00 00 04 64 72 61 74
[381] 00 04 00 09 00 00 00 02 77 74 00 04 00 09 00 00 00 04 71
[400] 73 65 63 00 04 00 09 00 00 00 02 76 73 00 04 00 09 00 00
[419] 00 02 61 6d 00 04 00 09 00 00 00 04 67 65 61 72 00 04 00
[438] 09 00 00 00 04 63 61 72 62 00 00 04 02 00 00 00 01 00 04
[457] 00 09 00 00 00 09 72 6f 77 2e 6e 61 6d 65 73 00 00 00 10
[476] 00 00 00 02 00 04 00 09 00 00 00 09 4d 61 7a 64 61 20 52
[495] 58 34 00 04 00 09 00 00 00 0d 4d 61 7a 64 61 20 52 58 34
[514] 20 57 61 67 00 00 04 02 00 00 00 01 00 04 00 09 00 00 00
[533] 05 63 6c 61 73 73 00 00 00 10 00 00 00 01 00 04 00 09 00
[552] 00 00 0a 64 61 74 61 2e 66 72 61 6d 65 00 00 00 fe

# 反序列化
> b<-unserialize(a);b
              mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4      21   6  160 110  3.9 2.620 16.46  0  1    4    4
Mazda RX4 Wag  21   6  160 110  3.9 2.875 17.02  0  1    4    4

JSON序列化,把用于把data.frame的数据结构,转换为JSON结构的过程。


# 原始数据
> dat<-mtcars[1:2,];dat
              mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4      21   6  160 110  3.9 2.620 16.46  0  1    4    4
Mazda RX4 Wag  21   6  160 110  3.9 2.875 17.02  0  1    4    4

# JSON序列化
> s1 <- serializeJSON(dat);s1
{"type":"list","attributes":{"names":{"type":"character","attributes":{},"value":["mpg","cyl","disp","hp","drat","wt","qsec","vs","am","gear","carb"]},"row.names":{"type":"character","attributes":{},"value":["Mazda RX4","Mazda RX4 Wag"]},"class":{"type":"character","attributes":{},"value":["data.frame"]}},"value":[{"type":"double","attributes":{},"value":[21,21]},{"type":"double","attributes":{},"value":[6,6]},{"type":"double","attributes":{},"value":[160,160]},{"type":"double","attributes":{},"value":[110,110]},{"type":"double","attributes":{},"value":[3.9,3.9]},{"type":"double","attributes":{},"value":[2.62,2.875]},{"type":"double","attributes":{},"value":[16.46,17.02]},{"type":"double","attributes":{},"value":[0,0]},{"type":"double","attributes":{},"value":[1,1]},{"type":"double","attributes":{},"value":[4,4]},{"type":"double","attributes":{},"value":[4,4]}]} 

# JSON反序列化
> s2 <- unserializeJSON(jsoncars);s2
              mpg cyl disp  hp drat    wt  qsec vs am gear carb
Mazda RX4      21   6  160 110  3.9 2.620 16.46  0  1    4    4
Mazda RX4 Wag  21   6  160 110  3.9 2.875 17.02  0  1    4    4

# 对比序列化前后的数据是否一致
> identical(dat, s2)
[1] TRUE

本文总结了3种常用的编码和解码的方法,让R语言能在工程的过程中,有了底层工具的支持,为我们的开发有提供便利性。不用关心底层,用心做好模型。

本文代码已上传到github: https://github.com/bsspirit/encrypt/blob/master/encode.r

转载请注明出处:
http://blog.fens.me/r-encode-decode/
打赏作者

caTools一个奇特的工具集

R的极客理想系列文章,涵盖了R的思想,使用,工具,创新等的一系列要点,以我个人的学习和体验去诠释R的强大。

R语言作为统计学一门语言,一直在小众领域闪耀着光芒。直到大数据的爆发,R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入,R语言的社区在迅速扩大成长。现在已不仅仅是统计领域,教育,银行,电商,互联网….都在使用R语言。

要成为有理想的极客,我们不能停留在语法上,要掌握牢固的数学,概率,统计知识,同时还要有创新精神,把R语言发挥到各个领域。让我们一起动起来吧,开始R的极客理想。

关于作者:

  • 张丹(Conan), 程序员Java,R,PHP,Javascript
  • weibo:@Conan_Z
  • blog: http://blog.fens.me
  • email: bsspirit@gmail.com

转载请注明出处:
http://blog.fens.me/r-catools/

r-caTools

前言

R语言生来就是自由的,不像Java,PHP等有统一的规范约束。R语言不仅命名、语法各包各异,就连功能也是各种混搭。caTools库就是这种混搭库,包括了不相关的几组函数工具集,有图片处理的,有编解码的,有分类器的,有向量计算的,有科学计算的。而且都很好用!

以致于我都不知道,如何用简短的语言去描述这个包了!!唯有“奇特”来概括它的特点。

目录

  1. caTools介绍
  2. caTools安装
  3. caTools的API介绍
  4. caTools使用

1. caTools介绍

caTools是一个基础的工具包,包括移动窗口统计,二进制图片读写,快速计算AUC,LogitBoost分类器,base64的编码器/解码器,快速计算舍入、误差、求和、累计求和等函数。

发布页地址:http://cran.r-project.org/web/packages/caTools/index.html

2. caTools安装

系统环境

  • Linux: Ubuntu Server 12.04.2 LTS 64bit
  • R: 3.0.1 x86_64-pc-linux-gnu
  • RStudio Server online

安装caTools


~ R

> install.packages("caTools")
* installing *source* package ‘caTools’ ...
** package ‘caTools’ successfully unpacked and MD5 sums checked
** libs
g++ -I/usr/share/R/include -DNDEBUG      -fpic  -O3 -pipe  -g  -c Gif2R.cpp -o Gif2R.o
g++ -I/usr/share/R/include -DNDEBUG      -fpic  -O3 -pipe  -g  -c GifTools.cpp -o GifTools.o
gcc -std=gnu99 -I/usr/share/R/include -DNDEBUG      -fpic  -O3 -pipe  -g  -c runfunc.c -o runfunc.o
g++ -shared -o caTools.so Gif2R.o GifTools.o runfunc.o -L/usr/lib/R/lib -lR
installing to /home/conan/R/x86_64-pc-linux-gnu-library/3.0/caTools/libs
** R
** preparing package for lazy loading
** help
*** installing help indices
** building package indices
** testing if installed package can be loaded
* DONE (caTools)

3. caTools的API介绍

二进制图片读写

  • read.gif & write.gif: gif格式图片的读写
  • read.ENVI & write.ENVI: ENVI格式图片的读写,如GIS图片

base64的编码器/解码器: http://zh.wikipedia.org/wiki/Base64

  • base64encode: 编码器
  • base64decode: 解码器

快速计算AUC

  • colAUC: 计算ROC曲线(AUC)的面积
  • combs: 向量元素的无序组合
  • trapz: 数值积分形梯形法则

LogitBoost分类器

  • LogitBoost: logitBoost分类算法
  • predict.LogitBoost: 预测logitBoost分类
  • sample.split: 把数据切分成训练集和测试集

快速计算工具

  • runmad: 计算向量中位数
  • runmean: 计算向量均值
  • runmin & runmax: 计算向量最小值 和 最大值
  • runquantile: 计算向量位数
  • runsd: 计算向量标准差
  • sumexact, cumsumexact: 无误差求和,针对于编程语言对于double类型的精度优化

4. caTools使用

加载类库

> library(caTools)
  • 1). 二进制图片读写gif
  • 2). base64的编码器/解码器
  • 3). ROC计算
  • 4). 向量元素的无序组合
  • 5). 数值积分形梯形法则
  • 6). LogitBoost分类器
  • 7). 快速计算工具:runmean
  • 8). 快速计算工具组合
  • 9). 无误差求和

1). 二进制图片读写gif

读写一个gif图片


#取datasets::volcano数据集
#写入volcano.gif
> write.gif(volcano, "volcano.gif", col=terrain.colors, flip=TRUE, scale="always", comment="Maunga Whau Volcano")

#读入图片到变量y
> y = read.gif("volcano.gif", verbose=TRUE, flip=TRUE)
GIF image header
Global colormap with 256 colors 
Comment Extension
Image [61 x 87]: 3585 bytes 
GIF Terminator

#通过y变量画图
image(y$image, col=y$col, main=y$comment, asp=1)

volcano

创建一个git动画


x <- y <- seq(-4*pi, 4*pi, len=200)
r <- sqrt(outer(x^2, y^2, "+"))
image = array(0, c(200, 200, 10))
for(i in 1:10) image[,,i] = cos(r-(2*pi*i/10))/(r^.25)
write.gif(image, "wave.gif", col="rainbow")
y = read.gif("wave.gif")
for(i in 1:10) image(y$image[,,i], col=y$col, breaks=(0:256)-0.5, asp=1)

wave

谢益辉animation有一样的GIF输出动画功能,且不需要依赖其他软件库。

注:animation::saveGIF需要依赖于ImageMagick或者GraphicsMagick。

2). base64的编码器/解码器

Base64常用于在通常处理文本数据的场合,表示、传输、存储一些二进制数据。包括MIME的email,email via MIME,在XML中存储复杂数据.

把一个boolean向量编解码


#设置每个元素占用的字节数
> size=1
> x = (10*runif(10)>5)
> y = base64encode(x, size=size)
> z = base64decode(y, typeof(x), size=size)

#原始数据
> x
 [1] FALSE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE FALSE

#编码后的密文
> y
[1] "AAAAAAEBAAAAAA=="

#解码后的明文
> z
 [1] FALSE FALSE FALSE FALSE  TRUE  TRUE FALSE FALSE FALSE FALSE

把一个字符串编解码


> x = "Hello R!!" # character
> y = base64encode(x)
> z = base64decode(y, typeof(x))

#原始数据
> x
[1] "Hello R!!"

#编码后的密文
> y
[1] "SGVsbG8gUiEh"

#解码后的明文
> z
[1] "Hello R!!"

3). ROC计算

在信号检测理论中,接收者操作特征曲线(receiver operating characteristic curve,或者叫ROC曲线)是一种座标图式的分析工具,用于 (1) 选择最佳的信号侦测模型、舍弃次佳的模型。 (2) 在同一模型中设定最佳阈值。

在做决策时,ROC分析能不受成本/效益的影响,给出客观中立的建议。

ROC曲线首先是由二战中的电子工程师和雷达工程师发明的,用来侦测战场上的敌军载具(飞机、船舰),也就是信号检测理论。之后很快就被引入了心理学来进行信号的知觉检测。数十年来,ROC分析被用于医学、无线电、生物学、犯罪心理学领域中,而且最近在机器学习(machine learning)和数据挖掘(data mining)领域也得到了很好的发展。

介绍文字,摘自:ROC曲线

取MASS::cats数据集,3列分别Sex(性别),Bwt(体重),Hwt(心脏重量)


> library(MASS)
> data(cats)

> head(cats)
  Sex Bwt Hwt
1   F 2.0 7.0
2   F 2.0 7.4
3   F 2.0 9.5
4   F 2.1 7.2
5   F 2.1 7.3
6   F 2.1 7.6

> colAUC(cats[,2:3], cats[,1], plotROC=TRUE)
              Bwt      Hwt
F vs. M 0.8338451 0.759048

auc-cats

从AUC判断分类器(预测模型)优劣的标准:

  • AUC = 1,是完美分类器,采用这个预测模型时,不管设定什么阈值都能得出完美预测。绝大多数预测的场合,不存在完美分类器。
  • 0.5 < AUC < 1,优于随机猜测。这个分类器(模型)妥善设定阈值的话,能有预测价值。
  • AUC = 0.5,跟随机猜测一样(例:丢铜板),模型没有预测价值。
  • AUC < 0.5,比随机猜测还差;但只要总是反预测而行,就优于随机猜测。
  • 对结果的解释:
    从上图中,我们看到Bwt和Hwt都在(0.5,1)之间,因此,cats的数据集是一个真实有效数据集。如果cats的数据集,是一个通过分类预测的数据集,用AUC对数据集的评分,就可以检验分类器的好坏了。

    4). 向量元素的无序组合
    combs(v,k)
    v:向量
    k:组合数量小于等v的长度,[1,length(v)]

    
    > combs(2:5, 3)
         [,1] [,2] [,3]
    [1,]    2    3    4
    [2,]    2    3    5
    [3,]    2    4    5
    [4,]    3    4    5
    
    > combs(c("cats", "dogs", "mice"), 2)
         [,1]   [,2]  
    [1,] "cats" "dogs"
    [2,] "cats" "mice"
    [3,] "dogs" "mice"
    
    #快速构建矩阵
    > a = combs(1:4, 2)
    > a
          [,1] [,2]
    [1,]    1    2
    [2,]    1    3
    [3,]    1    4
    [4,]    2    3
    [5,]    2    4
    [6,]    3    4
    > b = matrix( c(1,1,1,2,2,3,2,3,4,3,4,4), 6, 2)
    > b
         [,1] [,2]
    [1,]    1    2
    [2,]    1    3
    [3,]    1    4
    [4,]    2    3
    [5,]    2    4
    [6,]    3    4
    

    5). 数值积分形梯形法则

    梯形法则原理:将被积函数近似为直线函数,被积的部分近似为梯形。请参考:牛顿-柯特斯公式

    
    # integral of sine function in [0, pi] range suppose to be exactly 2.
    # lets calculate it using 10 samples:
    > x = (1:10)*pi/10
    > trapz(x, sin(x))
    [1] 1.934983
    
    > x = (1:1000)*pi/1000
    > trapz(x, sin(x))
    [1] 1.999993
    

    6). LogitBoost分类器

    取datasets::iris数据集,5列分别Sepal.Length(花萼长), Sepal.Width((花萼宽), Petal.Length(花瓣长), Petal.Width(花瓣宽),Species(种属)

    
    > head(iris)
      Sepal.Length Sepal.Width Petal.Length Petal.Width Species
    1          5.1         3.5          1.4         0.2  setosa
    2          4.9         3.0          1.4         0.2  setosa
    3          4.7         3.2          1.3         0.2  setosa
    4          4.6         3.1          1.5         0.2  setosa
    5          5.0         3.6          1.4         0.2  setosa
    6          5.4         3.9          1.7         0.4  setosa
    
    > Data = iris[,-5]
    > Label = iris[, 5]
    
    #训练模型
    > model = LogitBoost(Data, Label, nIter=20)
    
    #预测
    > Lab = predict(model, Data)
    > Prob = predict(model, Data, type="raw")
    
    #预测结果
    > t = cbind(Lab, Prob)
    > head(t)
         Lab setosa  versicolor    virginica
    [1,]   1      1 0.017986210 1.522998e-08
    [2,]   1      1 0.002472623 3.353501e-04
    [3,]   1      1 0.017986210 8.315280e-07
    [4,]   1      1 0.002472623 4.539787e-05
    [5,]   1      1 0.017986210 1.522998e-08
    [6,]   1      1 0.017986210 1.522998e-08
    
    #增加迭代次数
    > table(predict(model, Data, nIter= 2), Label)
                Label
                 setosa versicolor virginica
      setosa         48          0         0
      versicolor      0         45         1
      virginica       0          3        45
    > table(predict(model, Data, nIter=10), Label)
                Label
                 setosa versicolor virginica
      setosa         50          0         0
      versicolor      0         47         0
      virginica       0          1        47
    > table(predict(model, Data), Label)
                Label
                 setosa versicolor virginica
      setosa         50          0         0
      versicolor      0         49         0
      virginica       0          0        48
    
    #随机划分训练集和测试集,并预测
    > mask = sample.split(Label)
    > model = LogitBoost(Data[mask,], Label[mask], nIter=10)
    > table(predict(model, Data[!mask,], nIter=2), Label[!mask])
                
                 setosa versicolor virginica
      setosa         16          0         0
      versicolor      0         15         3
      virginica       0          1        12
    > table(predict(model, Data[!mask,]), Label[!mask])
                
                 setosa versicolor virginica
      setosa         17          0         0
      versicolor      0         16         4
      virginica       0          1        13
    

    7). 快速计算工具runmean

    对时间序列数据,取均线。

    
    #取datasets::BJsales数据集
    > BJsales
    Time Series:
    Start = 1 
    End = 150 
    Frequency = 1 
      [1] 200.1 199.5 199.4 198.9 199.0 200.2 198.6 200.0 200.3 201.2 201.6 201.5
     [13] 201.5 203.5 204.9 207.1 210.5 210.5 209.8 208.8 209.5 213.2 213.7 215.1
     [25] 218.7 219.8 220.5 223.8 222.8 223.8 221.7 222.3 220.8 219.4 220.1 220.6
     [37] 218.9 217.8 217.7 215.0 215.3 215.9 216.7 216.7 217.7 218.7 222.9 224.9
     [49] 222.2 220.7 220.0 218.7 217.0 215.9 215.8 214.1 212.3 213.9 214.6 213.6
     [61] 212.1 211.4 213.1 212.9 213.3 211.5 212.3 213.0 211.0 210.7 210.1 211.4
     [73] 210.0 209.7 208.8 208.8 208.8 210.6 211.9 212.8 212.5 214.8 215.3 217.5
     [85] 218.8 220.7 222.2 226.7 228.4 233.2 235.7 237.1 240.6 243.8 245.3 246.0
     [97] 246.3 247.7 247.6 247.8 249.4 249.0 249.9 250.5 251.5 249.0 247.6 248.8
    [109] 250.4 250.7 253.0 253.7 255.0 256.2 256.0 257.4 260.4 260.0 261.3 260.4
    [121] 261.6 260.8 259.8 259.0 258.9 257.4 257.7 257.9 257.4 257.3 257.6 258.9
    [133] 257.8 257.7 257.2 257.5 256.8 257.5 257.0 257.6 257.3 257.5 259.6 261.1
    [145] 262.9 263.3 262.8 261.8 262.2 262.7
    
    plot(BJsales, col="black", main = "Moving Window Means")
    lines(runmean(BJsales, 3), col="red")
    lines(runmean(BJsales, 8), col="green")
    lines(runmean(BJsales,15), col="blue")
    lines(runmean(BJsales,24), col="magenta")
    lines(runmean(BJsales,50), col="cyan")
    

    movingMeans

    我们从图中看到6条线,黑色是原始数据。其他各颜色代表,几个点的均线。比如,红色(red)线表示3点的平均,绿色(green)线表示8个线的平均。

    均线在股票上,是非常流行,实用一种看盘指标。

    6).快速计算工具组合

    对数据集取,最大runmax ,最小runmin ,均值runmean,中位数runmed

    
    k=25; n=200;
    x = rnorm(n,sd=30) + abs(seq(n)-n/4)
    plot(x, col=col[1], main = "Moving Window Analysis Functions (window size=25)")
    lines(runmin (x,k), col="red")
    lines(runmed (x,k), col="green")
    lines(runmean(x,k), col="blue")
    lines(runmax (x,k), col="cyan")
    

    movingAnalysis

    与上例子的均线一样,这次我们取4种不同的线。

    7). 无误差求和

    sum求和

    
    > x = c(1, 1e20, 1e40, -1e40, -1e20, -1)
    > a = sum(x); print(a)
    [1] -1e+20
    
    > b = sumexact(x); print(b)
    [1] 0 
    

    我们看到x向量中的,正负加起来正好为0.但是sum函数,结果是-1e+20,由于编程精度的问题造成的计算误差。通过sumexact函数修正后,就没有误差了。

    cumsum积累求和

    
    > a = cumsum(x); print(a)
    [1]  1e+00  1e+20  1e+40  0e+00 -1e+20 -1e+20
    
    > b = cumsumexact(x); print(b)
    [1] 1e+00 1e+20 1e+40 1e+20 1e+00 0e+00
    

    cumsum同样出现了精度的误差,需要用cumsumexact来修正。

    最后还是要用“奇特”来概括这个工具集,相信你也发现了他的奇特。

    转载请注明出处:
    http://blog.fens.me/r-catools/

    打赏作者