from sklearn.linear_model import Perceptron
import argparse #一個好用的參數(shù)傳遞模型
import numpy as np
from sklearn.datasets import load_iris #數(shù)據(jù)集
from sklearn.model_selection import train_test_split #訓練集和測試集分割
from loguru import logger #日志輸出，不清楚用法

#python is also oop 
class PerceptronToby():
  """
  n_epoch:迭代次數(shù)
  learning_rate:學習率
  loss_tolerance:損失閾值，即損失函數(shù)達到極小值的變化量
  """
  def __init__(self, n_epoch = 500, learning_rate = 0.1, loss_tolerance = 0.01):
    self._n_epoch = n_epoch
    self._lr = learning_rate
    self._loss_tolerance = loss_tolerance
  
  """訓練模型，即找到每個數(shù)據(jù)最合適的權(quán)重以得到最小的損失函數(shù)"""
  def fit(self, X, y):
    # X:訓練集，即數(shù)據(jù)集，每一行是樣本，每一列是數(shù)據(jù)或標簽,一樣本包括一數(shù)據(jù)和一標簽
    # y：標簽，即1或-1
    n_sample, n_feature = X.shape #剝離矩陣的方法真帥

    #均勻初始化參數(shù)
    rnd_val = 1/np.sqrt(n_feature)
    rng = np.random.default_rng()
    self._w = rng.uniform(-rnd_val,rnd_val,size = n_feature)
    #偏置初始化為0
    self._b = 0

    #開始訓練了，迭代n_epoch次
    num_epoch = 0 #記錄迭代次數(shù)
    prev_loss = 0 #前損失值
    while True:
      curr_loss = 0 #現(xiàn)在損失值
      wrong_classify = 0 #誤分類樣本

      #一次迭代對每個樣本操作一次
      for i in range(n_sample):
        #輸出函數(shù)
        y_pred = np.dot(self._w,X[i]) + self._b
        #損失函數(shù)
        curr_loss += -y[i] * y_pred
        # 感知機只對誤分類樣本進行參數(shù)更新，使用梯度下降法
        if y[i] * y_pred <= 0:
          self._w += self._lr * y[i] * X[i]
          self._b += self._lr * y[i]
          wrong_classify += 1

      num_epoch += 1
      loss_diff = curr_loss - prev_loss
      prev_loss = curr_loss
      # 訓練終止條件：
      # 1. 訓練epoch數(shù)達到指定的epoch數(shù)時停止訓練
      # 2. 本epoch損失與上一個epoch損失差異小于指定的閾值時停止訓練
      # 3. 訓練過程中不再存在誤分類點時停止訓練
      if num_epoch >= self._n_epoch or abs(loss_diff) < self._loss_tolerance or wrong_classify == 0:
        break


  """預測模型，顧名思義"""
  def predict(self, x):
    """給定輸入樣本，預測其類別"""
    y_pred = np.dot(self._w, x) + self._b
    return 1 if y_pred >= 0 else -1

#主函數(shù)
def main():
  #參數(shù)數(shù)組生成
  parser = argparse.ArgumentParser(description="感知機算法實現(xiàn)命令行參數(shù)")
  parser.add_argument("--nepoch", type=int, default=500, help="訓練多少個epoch后終止訓練")
  parser.add_argument("--lr", type=float, default=0.1, help="學習率")
  parser.add_argument("--loss_tolerance", type=float, default=0.001, help="當前損失與上一個epoch損失之差的絕對值小于該值時終止訓練")
  args = parser.parse_args()
  #導入數(shù)據(jù)
  X, y = load_iris(return_X_y=True)
  # print(y)
  y[:50] = -1
  # 分割數(shù)據(jù)
  xtrain, xtest, ytrain, ytest = train_test_split(X[:100], y[:100], train_size=0.8, shuffle=True)
  # print(xtest)
  #調(diào)用并訓練模型
  model = PerceptronToby(args.nepoch, args.lr, args.loss_tolerance)
  model.fit(xtrain, ytrain)

  n_test = xtest.shape[0]
  # print(n_test)
  n_right = 0
  for i in range(n_test):
    y_pred = model.predict(xtest[i])
    if y_pred == ytest[i]:
      n_right += 1
    else:
      logger.info("該樣本真實標簽為：{}，但是toby模型預測標簽為：{}".format(ytest[i], y_pred))
  logger.info("toby模型在測試集上的準確率為：{}%".format(n_right * 100 / n_test))

  skmodel = Perceptron(max_iter=args.nepoch)
  skmodel.fit(xtrain, ytrain)
  logger.info("sklearn模型在測試集上準確率為：{}%".format(100 * skmodel.score(xtest, ytest)))
if __name__ == "__main__":
  main()```