#======================================================
#	8 判別分析とニューラル・ネットワーク
#======================================================
#======================================================
#	8.1 判別分析
#======================================================
#パッケージのロード
library(mlbench)      #機械学習分析用データ
library(rrcov)        #判別分析のため
library(rpart)        #ツリーモデルのため
library(randomForest) #randomForestのため
library(MASS)         #mvrnormのため

#---------------<判別分析の概要>---------------
#---------------<分散共分散行列>---------------
set.seed(456)

#多変量正規分布に従う乱数

X <- mvrnorm(500, mu=c(2.5, 2), Sigma=matrix(c(1.1, 0.85, 0.85, 1.5), nrow=2))
dimnames(X)[[2]] <- c("x1", "x2")  #変数名を付ける。
#図8.1
plot(X, xlim=c(-2, 6), ylim=c(-2, 6), pch=16, col="steelblue")     #散布図
abline(h=0, v=0, lty=2)　　　　　　　　　　　　　　　　　　　　　　#座標軸  　
abline(h=mean(X[ ,"x2"]), v=mean(X[ ,"x1"]), lwd=3, col="tomato")　#各変数の平均
text(5.5, 5, "(I)")      #正数 * 正数 = 正数 
text(0.5, 5, "(II)")     #負数 * 正数 = 負数
text(0.5, -1.5, "(III)") #負数 * 負数 = 正数　
text(5.5, -1.5, "(IV)")  #正数 * 負数 = 負数

n <- dim(X)[1]                   #観測数
p <- dim(X)[2]                   #変数の数
mu <- apply(X, 2, mean)          #列平均
M <- matrix(mu, nrow=n, ncol=p, byrow=T) #平均行列

t(X-M) %*% (X-M) / (n-1)  #分散共分散行列     

cov(X)  #分散共分散行列

#---------------<判別ルール>---------------

set.seed(456)

#２つの多変量正規分布に従う乱数

A <- mvrnorm(500, mu=c(4, 1), Sigma=matrix(c(1.1, 0.85, 0.85, 1.5), nrow=2))
B <- mvrnorm(500, mu=c(0, 2.5), Sigma=matrix(c(1.1, 0.85, 0.85, 1.5), nrow=2))
X <- data.frame(rbind(A, B))             #AとBを縦方向に結合
names(X) <- c("x1", "x2")                #変数名を付ける。
Group <- c(rep("A", 500), rep("B", 500)) #群を表すベクトル
X <- cbind(X, Group)                     #XとGroupを横方向に結合

#Xのクロス集計

bks <- seq(from=-4, to=8, by=2)              #集計区間
tbl <- table(X$Group, cut(X$x1, breaks=bks)) #クロス集計（本体）
total <- sum(tbl)                            #総合計
row.total <- apply(tbl, 1, sum)              #行合計
tbl <- cbind(tbl, row.total)                 #本体に行合計を結合
col.total <- apply(tbl, 2, sum)              #列合計
tbl <- rbind(tbl, col.total)                 #本体に列合計を結合
tbl
(prob.x <- tbl/matrix(tbl[ ,ncol(tbl)], nrow(tbl), ncol(tbl))) #行方向の確率
(prob.y <- tbl/matrix(tbl[nrow(tbl), ], nrow(tbl), ncol(tbl), byrow=T)) 
                                                               #列方向の確率

(prob.G <- row.total/sum(row.total))         #A又はBに属する確率

(prob  <- tbl/matrix(total, nrow(tbl), ncol(tbl))) #全体に占める確率

#---------------<簡単な数値例：LDA>---------------

#LDAの当てはめ

test.lda <- LdaClassic(Group ~ x1 + x2, data=X)
test.lda

#予測

test.pred <- predict(test.lda)
test.pred

#確認

x <- as.matrix(X[ , c("x1", "x2")])        #データ行列
(lin.coef <- test.lda@ldf)                 #判別関数の係数
(const <- test.lda@ldfconst)               #判別関数の切片
dist <- scale(x %*% t(lin.coef), -const, F)#判別得点の中心化
dist[c(1:3, 501:503), ]                    #判別得点のいくつかの例
test.pred@x[c(1:3, 501:503), ]             #確認
dist <- exp((dist - apply(dist, 1, max)))  #行の最大値との差の指数変換 
dist <- dist/apply(dist, 1, sum)           #行合計で除して確率とする。
dist[c(1:3, 501:503), ]                    #事後確率のいくつかの例
test.pred@posterior[c(1:3, 501:503), ]     #確認

#判別境界

x1.new <- seq(-3, 7, length=200)                          #x1
coef.diff <- test.lda@ldf[1, ] - test.lda@ldf[2, ]        #係数の差
const.diff <- test.lda@ldfconst[1] - test.lda@ldfconst[2] #切片の差
x2.new <- -(coef.diff[1] * x1.new + const.diff)/(coef.diff[2]) #x2

#２変量（x1とx2の散布図）
#図8.2
plot(X$x1[Group=="A"], X$x2[Group=="A"], xlab="x1", ylab="x2",
        xlim=c(-3, 7), ylim=c(-3, 7), pch=16, col="steelblue")　#A
points(X$x1[Group=="B"], X$x2[Group=="B"],
        pch=17, col="green")                                    #B
lines(x1.new, x2.new, lty=2, lwd=3, col="red")           #判別境界
legend(-3, 7, c("A", "B"), col=c("steelblue", "green"), pch=16:17)

#---------------<簡単な数値例：QDA>---------------

set.seed(456)

#２つの異なった分散共分散行列を有する多変量正規分布に従う乱数

A <- mvrnorm(500, mu=c(4, 1), Sigma=matrix(c(1.9, 0.85, 0.85, 1.2), nrow=2))
B <- mvrnorm(300, mu=c(0, 2.5), Sigma=matrix(c(1.3, 0.75, 0.75, 2.0), nrow=2))
X <- data.frame(rbind(A, B))             #AとBを縦方向に結合
names(X) <- c("x1", "x2")                #変数名を付ける。
Group <- c(rep("A", 500), rep("B", 300)) #群を表すベクトル
X <- cbind(X, Group)                     #XとGroupを横方向に結合

#QDAの当てはめ

test.qda <- QdaClassic(Group ~ x1 + x2, data=X)
test.qda

#予測

test.pred <- predict(test.qda)
test.pred

#予測値の計算方法

prior <- test.qda@prior                #事前確率    
ng <- length(prior)　　　　　　　　　　#群の数　
x <- as.matrix(X[ , c("x1","x2")])     #データ
xx <- matrix(0, nrow=nrow(x), ncol=ng) #判別得点行列の初期化
posterior <- xx                        #事後確率行列の初期化
center <- test.qda@center              #平均行列
covdet <- test.qda@covdet              #行列式
covinv <- test.qda@covinv              #逆行列

#判別得点行列作成のためのループ（式8.22そのもの）

for(j in 1:nrow(x)) {
        for(i in 1:ng){
            xx[j,i] <- (x[j,]-center[i,]) %*% covinv[,,i] %*% (x[j,]-center[i,]) + 
                     log(covdet[i]) - 2*log(prior[i])
            xx[j,i] <- -0.5*xx[j,i]
        }
}

#事後確率行列作成のためのループ

for(i in 1:nrow(xx)){
        tmp <- sum(exp(xx[i,]))
        for(j in 1:ncol(xx))
            posterior[i,j] <- exp(xx[i,j])/tmp
}

#計算結果の確認

xx[c(1:3, 501:503), ]                  #判別得点行列の一部
test.pred@x[c(1:3, 501:503), ]         #同じ　
posterior[c(1:3, 501:503), ]           #事後確率行列の一部
test.pred@posterior[c(1:3, 501:503), ] #同じ　

#２変量（x1とx2の散布図）
#図8.3
plot(X$x1[Group=="A"], X$x2[Group=="A"], xlab="x1", ylab="x2",
        xlim=c(-3, 7), ylim=c(-3, 7), pch=16, col="steelblue")　#A
points(X$x1[Group=="B"], X$x2[Group=="B"],
        pch=17, col="green")                                    #B
legend(-3, 7, c("A", "B"), col=c("steelblue", "green"), pch=16:17)
x1 <- x2 <- seq(-3, 7, length=200)
xx <- expand.grid(x1, x2)
pred <- predict(test.qda, newdata=xx)
contour(x1, x2, matrix(pred@posterior[ ,1] - pred@posterior[ ,2], nrow=200), 
	, levels=0, drawlabels=F, add=T, lty=2, lwd=3, col="red")

#---------------<適用例：文字認識>---------------

#データの概要

data(LetterRecognition)
summary(LetterRecognition)

#ランダムサンプリング

Let <- LetterRecognition
set.seed(456)
n <- nrow(Let)
train <- sample(1:n, ceiling(n/2))

#LDA

Let.lda <- LdaClassic(lettr ~ ., data = Let[train, ])
pred.lda <- predict(Let.lda, newdata=Let[-train, -1])
ans.lda <- table(Let$lettr[-train], pred.lda@classification)
error.lda <- (sum(ans.lda) - sum(diag(ans.lda)))/sum(ans.lda)
error.lda

#QDA

Let.qda <- QdaClassic(lettr ~ ., data = Let[train, ])
pred.qda <- predict(Let.qda, newdata=Let[-train, -1])
ans.qda <- table(Let$lettr[-train], pred.qda@classification)
error.qda <- (sum(ans.qda) - sum(diag(ans.qda)))/sum(ans.qda)
error.qda

#ツリーモデル

Let.rpt <- rpart(lettr ~ ., data = Let[train, ],
	control=rpart.control(minbucket=3, cp=0.0001))
pred.rpt <- predict(Let.rpt, newdata=Let[-train, ], type="class")
ans.rpt <- table(Let$lettr[-train], pred.rpt)
error.rpt <- (sum(ans.rpt) - sum(diag(ans.rpt)))/sum(ans.rpt)
error.rpt

#randomForest

x <- Let[train, -1]
y <- Let[train, 1]
Let.rf <- randomForest(x, y, ntree=1000, mtry=10)
pred.rf <- predict(Let.rf, newdata=Let[-train, ])
ans.rf <- table(Let$lettr[-train], pred.rf)
error.rf <- (sum(ans.rf) - sum(diag(ans.rf)))/sum(ans.rf)
error.rf

#======================================================
#	8.2 ニューラル・ネットワーク
#======================================================

#パッケージのロード
library(RSNNS)

#---------------<ニューラル・ネットワークの概要>---------------

#図8.4　フィードフォワード・ニューラル・ネットワーク
windows(10, 7)
plot(1:10, 1:10, type="n", axes=F, xlab="", ylab="")
symbols(rep(2.5, 3), c(7, 5, 3), circles=rep(0.5, 3), inches=F, add=T, bg="gray90")
symbols(rep(5, 4), c(8, 6, 4, 2), circles=rep(0.5, 4), inches=F, add=T, bg="gray60")
symbols(rep(7.5, 3), c(7, 5, 3), circles=rep(0.5, 3), inches=F, add=T, bg="gray90")
arrows(x0=rep(0, 3), y0=c(7, 5, 3), x1=rep(2, 3), y1=c(7, 5, 3), 
	length=0.15, angle=20)
arrows(x0=rep(3, 4), y0=rep(7, 4), x1=rep(4.5, 4), y1=c(8, 6, 4, 2) + 0.1, 
	length=0.15, angle=20)
arrows(x0=rep(3, 4), y0=rep(5, 4), x1=rep(4.5, 4), y1=c(8, 6, 4, 2), 
	length=0.15, angle=20)
arrows(x0=rep(3, 4), y0=rep(3, 4), x1=rep(4.5, 4), y1=c(8, 6, 4, 2) - 0.1, 
	length=0.15, angle=20)
arrows(x0=rep(5.5, 3), y0=rep(8, 4), x1=rep(7, 3), y1=c(7, 5, 3) + 0.15, 
	length=0.15, angle=20)
arrows(x0=rep(5.5, 3), y0=rep(6, 4), x1=rep(7, 3), y1=c(7, 5, 3) + 0.05, 
	length=0.15, angle=20)
arrows(x0=rep(5.5, 3), y0=rep(4, 4), x1=rep(7, 3), y1=c(7, 5, 3) - 0.05, 
	length=0.15, angle=20)
arrows(x0=rep(5.5, 3), y0=rep(2, 4), x1=rep(7, 3), y1=c(7, 5, 3) - 0.15, 
	length=0.15, angle=20)
arrows(x0=rep(8, 3), y0=c(7, 5, 3), x1=rep(10, 3), y1=c(7, 5, 3), 
	length=0.15, angle=20)
text(c(2.5, 5, 7.5), rep(9.5, 3), c("入力層", "隠れ層", "出力層"), cex=1.5)

#図8.5　ロジスティック関数
x <- seq(-4, 4, length=200)
y <- 1/(1+exp(-x))
plot(x, y, type="l", lwd=3, ylab="logit(x)", col="skyblue")
grid(col="gray60")

#図8.6　双曲線正接関数
x <- seq(-4, 4, length=200)
y <- tanh(x)
plot(x, y, type="l", lwd=3, ylab="tanh(x)", col="skyblue")
grid(col="gray60")

#----------<適用例：文字認識>----------

x <- normalizeData(Let[ , -1])      #標準化
y <- decodeClassLabels(Let[ , 1])   #ダミー変数

#----------<2-hidden-layer(50 * 50)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(50, 50),
	learnFuncParams=0.1, maxit=1000))　　　　　　　#MLP
#   ユーザ   システム       経過  
#    398.69       0.16     399.38
#図8.7 
plotIterativeError(Let.mlp2)                        #収束過程
pred.mlp2 <- predict(Let.mlp2, x[-train,])          #予測
(ans2 <- confusionMatrix(y[-train, ], pred.mlp2))   #クロス集計
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2) #誤判別率
#> error.mlp2
#[1] 0.0872

#-----------<隠れ層の数による比較>-----------

time <- c(151.72, 207.85, 260.13)
error <- c(0.1668, 0.1444, 0.1524)

#図8.8
plot(1:3, error, xlab="隠れ層の数", ylab="", axes=F, type="l", 
	lwd=3, col="steelblue")
axis(side=1, at=1:3)
axis(side=2, las=1)
par(new=T)
plot(1:3, time, axes=F, type="l", xlab="", ylab="", 
	lty=2, lwd=3, col="tomato")
axis(side=4, las=1)
legend("bottomright", c("誤判別率", "所要時間（右軸）"),
	lty=1:2, col=c("steelblue", "tomato"), lwd=3)
box()

#----------<1-hidden-layer(26)>----------

system.time(model <- mlp(x[train, ], y[train, ], size=c(26),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    151.51       0.00     151.72 
plotIterativeError(model)
pred.mlp <- predict(model, x[-train,]) 
ans <- confusionMatrix(y[-train, ], pred.mlp)
error.mlp <- (sum(ans)-sum(diag(ans)))/sum(ans)
#> error.mlp
#[1] 0.1668

#----------<2-hidden-layer(26 * 26)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    207.45       0.04     207.85 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1444

#----------<3-hidden-layer(26, 26, 26)>----------

system.time(Let.mlp3 <- mlp(x[train, ], y[train, ], size=c(26, 26, 26),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    259.76       0.03     260.13 
plotIterativeError(Let.mlp3)
pred.mlp3 <- predict(Let.mlp3, x[-train,]) 
ans3 <- confusionMatrix(y[-train, ], pred.mlp3)
error.mlp3 <- (sum(ans3)-sum(diag(ans3)))/sum(ans3)
#> error.mlp3
#[1] 0.1524

#-----------<ユニットの数による比較>-----------

x <- c(15, 26, 30, 40, 50, 60)
time <- c(134.25, 207.85, 230.96, 305.42, 399.38, 494.57)
error <- c(0.2054, 0.1444, 0.1411, 0.1105, 0.0872, 0.0946)

#図8.9
plot(x, error, xlab="ユニットの数", ylab="", axes=F, type="l", 
	lwd=3, col="steelblue")
axis(side=1, at=x)
axis(side=2, las=1)
par(new=T)
plot(x, time, axes=F, type="l", xlab="", ylab="", 
	lty=2, lwd=3, col="tomato")
axis(side=4, las=1)
legend(42, 250, c("誤判別率", "所要時間（右軸）"),
	lty=1:2, col=c("steelblue", "tomato"), lwd=3)
box()

#----------<2-hidden-layer(15 * 15)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(15, 15),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    134.13       0.00     134.25 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.2054

#----------<2-hidden-layer(26 * 26)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    207.45       0.04     207.85 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1444

#----------<2-hidden-layer(30 * 30)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(30, 30),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    230.76       0.02     230.96 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1411

#----------<2-hidden-layer(40 * 40)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(40, 40),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    305.06       0.04     305.42 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
(ans2 <- confusionMatrix(y[-train, ], pred.mlp2))
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1105

#----------<2-hidden-layer(50 * 50)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(50, 50),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    398.69       0.16     399.38 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
(ans2 <- confusionMatrix(y[-train, ], pred.mlp2))
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.0872

#----------<2-hidden-layer(60 * 60)>----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(60, 60),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    493.46       0.06     494.57 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
(ans2 <- confusionMatrix(y[-train, ], pred.mlp2))
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.0946

#-----------<学習アルゴリズムによる比較>-----------

#図8.10
x <- 1:6
time <- c(207.85, 291.88, 234.82, 232.58, 265.01, 393.78)
error <- c(0.1444, 0.1515, 0.1513, 0.1513, 0.1496, 0.1578)

plot(x, error, xlab="学習アルゴリズム", ylab="", axes=F, type="l", 
	lwd=3, col="steelblue")
axis(side=1, at=x, labels=c("Std", "Chunk", "Momentum", 
	"WeightDecay", "Rprop", "SCG"))
axis(side=2, las=1)
par(new=T)
plot(x, time, axes=F, type="l", xlab="", ylab="", 
	lty=2, lwd=3, col="tomato")
axis(side=4, las=1)
legend(1, 400, c("誤判別率", "所要時間（右軸）"),
	lty=1:2, col=c("steelblue", "tomato"), lwd=3)
box()

#----------<2-hidden-layer(26 * 26)：learnFunc="Std_Backpropagation">----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000))
#   ユーザ   システム       経過  
#    207.45       0.04     207.85 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1444

#----------<2-hidden-layer(26 * 26):learnFunc="BackpropChunk">----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000, learnFunc="BackpropChunk"))
#   ユーザ   システム       経過  
#    291.76       0.00     291.88 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1515

#----------<2-hidden-layer(26 * 26):learnFunc="BackpropMomentum">----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000, learnFunc="BackpropMomentum"))
#   ユーザ   システム       経過  
#    234.42       0.03     234.82 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1513

#----------<2-hidden-layer(26 * 26):learnFunc="BackpropWeightDecay">----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000, learnFunc="BackpropWeightDecay"))
#   ユーザ   システム       経過  
#    231.86       0.06     232.58 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1496

#----------<2-hidden-layer(26 * 26):learnFunc="Rprop">----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000, learnFunc="Rprop"))
#   ユーザ   システム       経過  
#    264.21       0.02     265.01 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1797

#----------<2-hidden-layer(26 * 26):learnFunc="SCG">----------

system.time(Let.mlp2 <- mlp(x[train, ], y[train, ], size=c(26, 26),
	learnFuncParams=0.1, maxit=1000, learnFunc="SCG"))
#   ユーザ   システム       経過  
#    393.22       0.03     393.78 
plotIterativeError(Let.mlp2)
pred.mlp2 <- predict(Let.mlp2, x[-train,]) 
ans2 <- confusionMatrix(y[-train, ], pred.mlp2)
error.mlp2 <- (sum(ans2)-sum(diag(ans2)))/sum(ans2)
#> error.mlp2
#[1] 0.1578
