Kode R algoritma cepat penduga GS

(1)

(2)

Lampiran 1 Kode R algoritma cepat penduga GS

fast.gs <- function(x,y,N=100,best.r=5,b=.5,cc=0.9958,cc.alpha=4.68){

#==================================================

#Pada tulisan ini jumlah reampel yang ditarik dalam algoritma resampling

# adalah 100, jumlah iterasi yang digunakan pada algoritma I step yang

# diterapkan untuk memperbaiki dugaan yang dihasilkan dengan algoritma #

resampling adalah K iterasi = 2, sedangkan jumlah kandidat dugaan

# terbaik yang diperbaiki pada penerapan kedua algoritma I step

# adalah K simpan = 5.

# cc.alpha=4.68 adalah tuning constant untuk pendugaan intersep.

#---

#==================================================

# subrutin untuk fungsi bobot dalam algoritma I step

#---

fw.gs <- function(u,cc){ tmp <- (1-(u/cc)^2)^2 tmp[abs(u/cc)>1] <- 0 return(tmp)}

#==================================================

# subrutin untuk pendugaan koefisien regresi

#---

coeff.est <- function(x,y,N,best.r,b,cc){

#=============================================

# subrutin untuk penyelesaian persamaan liner

#---

our.solve <- function(a,b){

a <- qr(a)

da <- dim(a$qr)

if(a$rank < (p<-da[2])) return(NA)

else qr.coef(a,b)}

#=============================================

norm <- function(x) sqrt(sum(x^2))

#=============================================

# subrutin untuk fungsi rho

#---

rho <- function(u, cc){ w <- abs(u)<=cc v <- (u^2/(2)*(1-(u^2/(cc^2)) +(u^4/(3*cc^4))))*w +(1-w)*(cc^2/6) v <- v*6/cc^2 return(v) }

#=============================================

loss.GS <- function(u,s,cc) mean(rho(u/s,cc))

#=============================================

# subrutin untuk penghitungan selisih vektor yang akan

# digunakan dalam penghitungan selisih sisaan

#---

vec.diff <- function(vector,n) {

diff.vec <- numeric()

jit(2) i3 <- 0

(3)

for (i1 in 1:(n-1)){

for (i2 in (i1+1):n){ i3 <- i3 + 1

diff.vec[i3] <- vector[i1]-vector[i2]}}

return(diff.vec)}

#=============================================

# subrutin untuk penghitungan selisih matriks yang akan

# digunakan dalam penghitungan selisih matriks peubah penjelas

#---

mat.diff <- function(matr){ n <- dim(matr)[1] p <- dim(matr)[2] n.gs <- choose(n,2) diff.mat <- matrix(0,nrow=n.gs,ncol=p) jit(2) i3 <- 0 for (i1 in 1:(n-1)){

for (i2 in (i1 + 1):n){ i3 <- i3 + 1

diff.mat[i3,] <- matr[i1,]-matr[i2,]}}

return(diff.mat)}

#=============================================

# Subrutin untuk perbaikan dugaan koefisien regresi yang

# digunakan dalam algoritma I step untuk penghitungan dengan

# K iterasi yang diterapkan guna memperbaiki nilai awal kandidat

# dugaan dan untu penghitungan sampai tercapainya konvergensi

#---

beta.calc <-function(x,y,n.gs,p,res.diff, scale,initial.beta){ weights <- fw.gs(res.diff/scale,cc) W <- matrix(weights,n.gs,p) x.gs <- mat.diff(x) y.gs <- vec.diff(y,n) xw <- x.gs*sqrt(W) yw <- y.gs*sqrt(weights) beta.1 <- our.solve(t(xw)%*%xw,t(xw)%*%yw) if(any(is.na(beta.1))){ beta.1 <- initial.beta break} scale <- sqrt(scale^2*mean(rho(res.diff/scale,cc))/b) return(beta.1)}

#=============================================

# subrutin untuk algoritma I step

#---

GS.i.step <- function(conv,x,y,n.gs,p,

initial.beta,initial.scale){

res <- y-x %*% initial.beta

res.diff <- vec.diff(res,n)

if( missing( initial.scale ) )

initial.scale <- scale <- median(abs

(res.diff[res.diff!=0]))/.6745

else scale <- initial.scale

beta.rw <- initial.beta

if (conv==0){

for (l in 1:2){

beta.rw <- beta.calc(x,y,n.gs,p,

(4)

res <- y-x%*%beta.rw res.diff <- vec.diff(res,n)}} else{ max.it <- 200 l <- 0 eps <- 1e-20 err <- 1

while(((l<-l+1)<max.it) && (err>eps)){

beta.1 <- beta.calc(x,y,n.gs,p,res.diff, scale,initial.beta) err <- norm(beta.rw-beta.1)/ norm(beta.rw) res <- y-x%*%beta.1 res.diff <- vec.diff(res,n) beta.rw <- beta.1}} return(list(beta.rw=beta.rw,scale=scale))}

#=============================================

# subrutin untuk penghitungan dugaan skala yang

# digunakan dalam algoritma I step

#---

scale.calc <- function(u,b,cc){ max.it <- 50 initial.sc <- median(abs(u[u!=0]))/.6745 sc <- initial.sc l <- 0 eps <- 1e-20 err <- 1

while(((l<-l+1)<max.it) && (err>eps)){

sc2 <- sqrt(sc^2*mean(rho(u/sc,cc))/b) err <- abs(sc2/sc-1) sc <- sc2} return(sc)}

#=============================================

# penghitungan algoritma cepat penduga GS dengan

# menggabungkan subrutin di atas

#---

n <- dim(x)[1]

p <- dim(x)[2]

n.gs <- choose(n,2)

best.betas <- matrix(0, best.r, p)

best.scales <- rep(1e20, best.r)

scale.out <- rep(0, best.r)

s.worst <- 1e20

for(k in 1:N){

#=======================================

# ambil N resampel dari data

# hitung dugaan OLS parameter regresi

# untuk tiap resampel

# misalkan digaan yang diperoleh initial.beta's

#---

singular <- T while(singular==T){ indices <- sample(n,p) xs <- x[indices,] ys <- y[indices] initial.beta <- our.solve(xs,ys) singular <- any(is.na(initial.beta))}

(5)

#=======================================

#terapkan prosedur I step dua kali

#untuk perbaiki nilai awal beta

#---

tmp <- GS.i.step(0,x,y,n.gs,p,initial.beta) beta.rw <- tmp$beta.rw scale <- tmp$scale res.rw <- y-x%*%beta.rw res.diff.rw <- vec.diff(res.rw,n)

#=======================================

#hitung dugaan skala kelima kandidat dugaan terbaik

#---

if(k > 1){ scale.test <- loss.GS(res.diff.rw,s.worst,cc) if(scale.test < b){ s.best <- scale.calc(res.diff.rw,b,cc) ind <- order(best.scales)[best.r] best.scales[ind] <- s.best best.betas[ind,] <- beta.rw s.worst <- max(best.scales)}} else{ best.scales[best.r] <- scale.calc(res.diff.rw, b,cc) best.betas[best.r,] <- beta.rw}

#=======================================}

#=============================================

#hitung dugaan akhir beta

#---

super.best.scale <- 1e10 for (k in 1:best.r){ tmp <- GS.i.step(1,x,y,n.gs,p,best.betas[k,], best.scales[k]) if(tmp$scale < super.best.scale) { super.best.scale <- tmp$scale super.best.beta <- tmp$beta.rw}}

#=============================================

return(list(super.best.beta=as.vector(super.best.beta), super.best.scale=super.best.scale))}

#=============================================

# subrutin untuk pendugaan intersep yang gunakan

# hasil yang diperoleh dari pendugaan koefisien regresi dengan

# algoritma cepat di atas

#---

intercept.est <- function(a,cc.alpha){ initial.alpha <- median(a) scale.alpha <- median(abs(a-initial.alpha))/0.6745 alpha <- initial.alpha eps <- 1e-20 err <- 1

while (err > eps){

weights <- fw.gs((a-alpha)/scale.alpha,4.68)

alpha.2 <- mean(weights*alpha)/mean(weights)

err <- abs(alpha.2 - alpha)/scale.alpha

(6)

return(list(alpha=alpha, scale.alpha=scale.alpha))}

#=============================================

#==================================================

#

PROGRAM UTAMA

#---

tmp <- coeff.est(x,y,N,best.r,b,cc) beta.est <- tmp$super.best.beta scale.beta <- tmp$super.best.scale res <- y-x%*%beta.est tmp <- intercept.est(res,cc.alpha) alpha.est <- tmp$alpha estimates.gs <- c(alpha.est,beta.est) return(list(estimates.gs=as.vector(estimates.gs)))

#==================================================}

Lampiran 2 Kode R simulasi dalam evaluasi kinerja algoritma cepat penduga

GS

simulation<- function(iteration,n=60,p= (jumlah peubah penjelas)){

#==================================================

# Pada simulasi ini, jumlah peubah penjelas yang ditinjau

# adalah p = 2 dan 5,

# model pembangkit yang digunakan adalah (1,1,1)

# dan (0.5,3,2) untuk p=2

# dan (1,1,1,1,1,1) dan (1, 2, 1.5, 0.5, 0.5, 1.5) untuk p=5,

# sedangkan pencilan sisaan yang dibangkitkan punya rataan

# mu = 10 dan 100 dan ragam var = 1 dan 3

# Dalam menggunakan program ini, kode R untuk algoritma cepat

# hendaknya disimpan pada file "D:\\ fasts.txt"

# dan untuk algoritma cepat penduga GS pada "D:\\fastgs.txt".

#---

data.generating<- function(){ beta <- c(generating model) mean.x <- rep(0,p)

sigma.x <- diag(1,p)

x <- rmvnorm(n,mean=mean.x,sigma=sigma.x) x1 <- cbind(1,x)

e0 <- rnorm(60)

e.out <- rnorm(9, mean= mu, sd= var) e1.1 <- e0[1:57] e1.2 <- e.out[7:9] e1 <- c(e1.1,e1.2) e2.1 <- e0[1:51] e2.2 <- e.out e2 <- c(e2.1,e2.2) y0 <- x1 %*% beta + e0 y1 <- x1 %*% beta + e1 y2 <- x1 %*% beta + e2

return(list(x=x,y0=y0, y1=y1, y2=y2))}

#=============================================

# Simulasi ini dilakukan 50 kali dengan iterasi mengikuti

# seeding seperti pada Lampiran 3.

#---

for (i in 50:iteration){ set.seed(i) tmp <- data.generating() x <- tmp$x y0 <-tmp$y0

(7)

y1 <-tmp$y1

y2 <-tmp$y2

#data without outliers

model.ls0 <- lm(y0~x) beta.ls0 <- as.vector(model.ls0$coefficients) print(beta.ls0) source("D:\\ fasts.txt") temp <- fast.s(x,y0) estimates.s0 <- as.vector(temp$estimates.s) print(estimates.s0) source("D:\\fastgs.txt") temp <- fast.gs(x,y0) estimates.gs0 <- as.vector(temp$estimates.gs) print(estimates.gs0)

#data with 5% outlier

model.ls1 <- lm(y1~x) beta.ls1 <- as.vector(model.ls1$coefficients) print(beta.ls1) source("D:\\ fasts.txt") temp <- fast.s(x,y1) estimates.s1 <- as.vector(temp$estimates.s) print(estimates.s1) source("D:\\fastgs.txt") temp <- fast.gs(x,y1) estimates.gs1 <- as.vector(temp$estimates.gs) print(estimates.gs1) #data with 15% outlier

model.ls2 <- lm(y2~x) beta.ls2 <- as.vector(model.ls2$coefficients) print(beta.ls2) source("D:\\ fasts.txt") temp <- fast.s(x,y2) estimates.s2 <- as.vector(temp$estimates.s) print(estimates.s2) source("D:\\fastgs.txt") temp <- fast.gs(x,y2) estimates.gs2 <- as.vector(temp$estimates.gs) print(estimates.gs2)

# calculation of coefficient determination and RMSE

# of regregression estimates yielded by fast gs

# fast s, as well as OLS

rmse.0 <- summary.lm(model.ls0)$sigma r.squared.0 <- summary.lm(model.ls0)$r.squared rmse.1 <- summary.lm(model.ls1)$sigma r.squared.1 <- summary.lm(model.ls1)$r.squared rmse.2 <- summary.lm(model.ls2)$sigma r.squared.2 <- summary.lm(model.ls2)$r.squared rmse.r.squared <- c(rmse.0,r.squared.0,rmse.1, r.squared.1, rmse.2,r.squared.2) print(rmse.r.squared) }}