演算法2.1

train <- function(mat) {

  nr <- nrow(mat)
  nc <- ncol(mat)

  w0 <- matrix(0,nc - 1,1)
  b0 <- 0      
  n <- 1       #學習率

  study_count <- 0
  nochange_count <- 0
  nochange_upper_limit <- 100000       #連續分類正確次數上限
  study_total <- 10000                 #學習次數總數

  while (TRUE
 
) {

    nochange_count <- nochange_count + 1
    if (nochange_count > nochange_upper_limit) {break}    #連續分類正確次數大於上限時，將跳出while迴圈，認為訓練完成

    index <- sample(nr,1,replace = FALSE)
    img <- mat[index,1:(nc-1)]
    yi <- mat[index,nc]
    result <- (img %*% w0 + b0) *yi

    if (result <= 0
 
) {

      img <- matrix(mat[index,1:(nc-1)],nc-1,1)

      w0 <- w0 + n * yi * img
      b0 <- b0 + n * yi

      study_count <- study_count + 1

      if (study_count > study_total) {break}    ##學習次數超過10000次，將跳出while迴圈，認為訓練完成
      nochange_count <- 0                       ##分類錯誤的話，nochange_count重歸0
 

    }
    #print(index) 
  }

  wb <- list(w0 = w0,b0 = b0)
  return (wb)

}

mat <- matrix(c(3,3,1,4,3,1,1,1,-1),nrow = 3,byrow = TRUE)#例題
mat
# debug(train) #除錯
# train(mat)
# undebug(train)

wb <- train(mat)
wb
#$w0
#     [,1]
#[1,]    1
#[2,]    1

#$b0
#[1] -3

###predict function
predict <- function(test_mat) {

  result <- NULL
  for ( i in 1:nrow(test_mat)){

    result_1 <-  test_mat[i,] %*% wb$w0 + wb$b0 
    result_1 <- ifelse(result_1 > 0,1,-1)

    result <- rbind(result,result_1)
  }
  return(result)
}

test_ <- matrix(seq(-100,99,by = 1),100,2,byrow = TRUE)
predict(test_)

演算法2.2

#計算gram矩陣
caculate_gram <- function(mat) {

  mat_g <- mat[,-ncol(mat)]    ##最後一列為標籤值
  #mat_g
  mat_gr <- matrix(0,nrow(mat_g),nrow(mat_g))
  for (i in 1:nrow(mat_g)) {
    for (j in 1:nrow(mat_g)) {
      mat_gr[i,j] <- mat_g[i,] %*% mat_g[j,]
    }
  }
  return(mat_gr)
}

matr <- matrix(seq(1:1000),100,10)
caculate_gram(matr)
#計算gram矩陣結束

mat <- matrix(c(3,3,1,4,3,1,1,1,-1),nrow = 3,byrow = TRUE)#例題
gram_mat <- caculate_gram(mat)      #計算gram矩陣
train_2 <- function(mat) {

  nr <- nrow(mat)
  nc <- ncol(mat)

  alpha <- matrix(0,nr,1)
  b0 <- 0
  n <- 1     #學習率

  study_count <- 0
  nochange_count <- 0
  nochange_upper_limit <- 100000       #連續分類正確次數上限
  study_total <- 10000                 #學習次數總數

  while (TRUE) {
    nochange_count <- nochange_count + 1
    if (nochange_count > nochange_upper_limit) {break}    #連續分類正確次數大於上限時，將跳出while迴圈，認為訓練完成

    index <- sample(nr,1,replace = FALSE)
    yi <- mat[index,nc]

    result <- yi * (sum(alpha * mat[,nc] * gram_mat[index,]) + b0)

    if (result <= 0) {

      alpha[index,1] <- alpha[index,1] + n
      b0 <- b0 + n * yi

      study_count <- study_count + 1

      if (study_count > study_total) break      ##學習次數超過10000次，將跳出while迴圈，認為訓練完成   

      nochange_count <- 0                       ##分類錯誤的話，nochange_count重歸0
    }
    print(index)
  }

  #計算w
  w <- 0
  for (k in 1:nr) {
    w0 <- alpha[k,1] * mat[k,-nc] * mat[k,nc]
    w <- w + w0 
  }

  #print(index)

  wb <- list(alpha = alpha,w = w,b0 = b0, nochange_count = nochange_count,study_count = study_count)
  return (wb)
}

wb <- train_2(mat)
wb         #演算法有多個解
#$w
#[1] 2 1

#$b0
#[1] -5

#$nochange_count
#[1] 100001

#$study_count
#[1] 11

#predict function
predict <- function(test_mat) {

  result <- NULL
  for ( i in 1:nrow(test_mat)){

    result_1 <-  test_mat[i,] %*% wb$w + wb$b0 
    result_1 <- ifelse(result_1 > 0,1,-1)

    result <- rbind(result,result_1)
  }
  return (result)
}

test_ <- matrix(seq(-100,99,by = 1),100,2,byrow = TRUE)
predict(test_)