前端機器學習——邏輯迴歸

時間 2019-11-29

標籤前端機器學習邏輯迴歸简体版

原文原文鏈接

前端實現機器學習

機器學習愈來愈火，而做爲一個遊手好閒的前端程序員！我固然要看一下這個機器學習，是個什麼東西。html

先說作什麼

咱們用機器學習能夠作什麼呢，他和咱們前端有什麼關係呢？比方說咱們作一個數據管理平臺，老闆要看數據狀況，獲得一些規律或者信息（幾月賺錢多啊，賣啥賺錢多啊，下個月銷售量估計怎樣啊），這個時候後段給了你之前每一天的各類數據，某某日，啥啥啥，咋咋地買的好很差。咱們不可能就給老闆看這些點，像個芝麻燒餅同樣。因此咱們就須要用到機器學習，將這些點擬合成一條合適的線（最簡單的線性迴歸），就顯得很好。（別問爲啥不是後端返回來線的截距和斜率，問就是自食其力），下面的我就舉一個小栗子，寫一個小demo，經過你不斷選擇色塊，分析你喜歡的顏色特徵，來預測在下一個色塊的選擇中你的選擇是？前端

再說怎麼作

我是照着python代碼手擼的js版本，其實沒有什麼難度，js與python相比，因爲沒有矩陣，我使用的是二維數組遍歷進行運算的，其餘也沒什麼，下面話很少說，直接貼代碼。java

python代碼

// python代碼
import numpy as np

def sigmoid(z):
   sigmoid = 1.0 / (1.0 + np.exp(-z))
   return sigmoid

# 梯度方向
def gradient(X, h, y):
   gradient = np.dot(X.T, (h - y)) / y.shape[0]
   return gradient

# 邏輯迴歸過程
def Logistic_Regression(x, y, lr=0.05, count=200):
   intercept = np.ones((x.shape[0], 1)) # 初始化截距爲 1
   x = np.concatenate((intercept, x), axis=1)
   w = np.zeros(x.shape[1]) # 初始化參數爲 0
   for i in range(count): # 梯度降低迭代
       z = np.dot(x, w) # 線性函數
       h = sigmoid(z)
       g = gradient(x, h, y) # 計算梯度
       w -= lr * g # 經過學習率 lr 計算步長並執行梯度降低

   return w # 返回迭代後的梯度和參數
//這是我手動選擇色塊獲得的假數據，爲何是三維呢？由於我只存了兩個色塊三原色的差值
x = np.array([
   [-255, -255, -255],
   [-12, 43, -89],
   [-42, -25, 102],
   [7, 202, 81],
   [142, -67, -120],
   [100, 52, -6],
   [-19, -41, -24],
   [-108, 179, 78],
   [-192, 166, 27],
   [80, -30, -47],
   [53, 38, 140]
])
y = np.array([1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0])
w = Logistic_Regression(x, y)
複製代碼

javascript代碼

// js代碼
// 這個是假數據，註釋掉了，由於把它總體封裝成了一個方法
// const x = [
// [-255, -255, -255],
// [-12, 43, -89],
// [-42, -25, 102],
// [7, 202, 81],
// [142, -67, -120],
// [100, 52, -6],
// [-19, -41, -24],
// [-108, 179, 78],
// [-192, 166, 27],
// [80, -30, -47],
// [53, 38, 140]
// ]
// const y = [1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0]
// const z = [-30, 100, -66]
// 入參x是以前色塊的數據矩陣（條件），y是選擇矩陣（結果），z是最後選擇時色塊的色差（最新條件）
export const MySigmod = function(x, y, z) {
    //sigmod函數
    const sigmod = function(z) {
        let c = []
        for(let i = 0; i < z.length; i++) {
            c.push(1/(1+Math.exp(-z[i])))
        }
        return c
    }
    //梯度方向
    const gradient = function(x, h, y) {
        let g = []
        for(let j = 0; j < x[0].length; j++) {
            let c = 0
            for(let i = 0; i < y.length; i++) {
                c = c + x[i][j] * (h[i] - y[i])
            }
            c = c / y.length
            g.push(c)
        }
        return g
    }
    //邏輯迴歸過程
    function Logistic_Regression(x, y, lr=0.05, count=500) {
        let w = []
        x.map(item => {
            item.push(1)
        })
        for(let i = 0; i < x[0].length; i++) {
            w.push(0)
        }
        for(let m = 0; m < count; m++) {
            let z = []
            for(let i = 0; i < x.length; i++) {
                let item = 0
                for(let j = 0; j < w.length; j++) {
                    item = item + x[i][j] * w[j]
                }
                z.push(item)
            }
            let h = sigmod(z)
            let g = gradient(x, h, y)
            for(let i = 0; i < w.length; i++) {
                w[i] = w[i] - lr * g[i]
            }
            // l = loss(h, y)
        }
        return w
    }

    let w = Logistic_Regression(x,y)
    //使用求出的權重係數盡心選擇
    let p = w[0]
    for(let i = 0; i < z.length; i++) {
        p = p + z[i] * w[i]
    }
    p = 1/(1+Math.exp(p))
    return p
}
複製代碼

就算大功告成啦，看一下能不能成功呢！我以前選的都是淺色，因此應該選左面。估計結束！ python

沒得問題，很成功哦！

再說爲何

那麼它的原理是什麼呢，他怎樣知道我想要的是淺色色塊的呢。這個就是用到了機器學習中第二基礎的算法——邏輯迴歸（我本身以爲是第二基礎，第一基礎我以爲是線性迴歸，就只是我以爲啊～～），邏輯迴歸是一個名爲迴歸實爲分類的算法，用來二分類，輸出的結果是一個機率（選某一邊的機率），將以前的選擇變成機率，擬合到sigmod函數上，而sigmod函數以下：程序員