NO IMAGE

手把手,74行程式碼實現手寫數字識別

689 次閱讀 – 2015.12.29 – 人工智慧 – 龍貓
http://dataunion.org/20992.html
1、 引言:不要站在岸上學游泳
“機 器學習”是一個很實踐的過程。就像剛開始學游泳,你在只在岸上比劃一堆規定動作還不如先跳到水裡熟悉水性學習來得快。以我們學習“機器學習”的經驗來看, 很多高大上的概念剛開始不懂也沒關係,先寫個東西來跑跑,有個感覺了之後再學習那些概念和理論就快多了。如果別人已經做好了輪子,直接拿過來用則更快。因 此,本文直接用Michael Nielsen先生的程式碼(github地址: https://github.com/mnielsen/neural-networks-and-deep-learning)作為例子,給大家展現
神經網路分析的普遍過程:匯入資料,訓練模型,優化模型,啟發式理解等。
本文假設大家已經瞭解python的基本語法,並在自己機器上執行過簡單python指令碼。
2、 我們要解決的問題:手寫數字識別
手寫數字識別是機器學習領域中一個經典的問題,是一個看似對人類很簡單卻對程式十分複雜的問題。很多早期的驗證碼就是利用這個特點來區分人類和程式行為的,當然此處就不提12306近乎反人類的奇葩驗證碼了。
驗證碼圖
回到手寫數字識別,比如我們要識別出一個手寫的“9”,人類可能通過識別“上半部分一個圓圈,右下方引出一條豎線”就能進行判斷。但用程式表達就似乎很困難了,你需要考慮非常多的描述方式,考慮非常多的特殊情況,最終發現程式寫得非常複雜而且效果不好。
而用(機器學習)神經網路的方法,則提供了另一個思路:獲取大量的手寫數字的影象,並且已知它們表示的是哪個數字,以此為訓練樣本集合,自動生成一套模型(如神經網路的對應程式),依靠它來識別新的手寫數字。
手寫數字
本文中採用的資料集就是著名的“MNIST資料集”。它的收集者之一是人工智慧領域著名的科學家——Yann LeCu。這個資料集有60000個訓練樣本資料集和10000個測試用例。運用本文展示的單隱層神經網路,就可以達到96%的正確率。
3、圖解:解決問題的思路
我們可以用下圖展示上面的粗略思路。
粗略思路
但是如何由“訓練集”來“生成模型”呢?
在這裡我們使用反覆推薦的逆推法——假設這個模型已經生成了,它應該滿足什麼樣的特性,再以此特性為條件反過來求出模型。
可 以推想而知,被生成的模型應該對於訓練集的區分效果非常好,也就是相應的訓練誤差非常低。比如有一個未知其相應權重和偏移的神經網路,而訓練神經網路的過 程就是逐步確定這些未知引數的過程,最終使得這些引數確定的模型在訓練集上的誤差達到最小值。我們將會設計一個數量指標衡量這個誤差,如果訓練誤差沒有達 到最小,我們將繼續調整引數,直到這個指標達到最小。但這樣訓練出來的模型我們仍無法保證它面對新的資料仍會有這樣好的識別效果,就需要用測試集對模型進
行考核,得出的測試結果作為對模型的評價。因此,上圖就可以細化成下圖:
細化成下圖
但 是,如果我們已經生成了多個模型,怎麼從中選出最好的模型?一個自然的思路就是通過比較不同模型在測試集上的誤差,挑選出誤差最小的模型。這個想法看似沒 什麼問題,但是隨著你測試的模型增多,你會覺得用測試集篩選出來的模型也不那麼可信。比如我們增加一個神經網路的隱藏層節點,就會產生新的對應權重,產生 一個新的模型。但是我也不知道增加多少個節點是合適的,所以比較全面的想法就是嘗試測試不同的節點數x∈(1,2,3,4,…,100), 來觀察這些不同模型的測試誤差,並挑出誤差最小的模型。這時我們發現我們的模型其實多出來了一個引數x,
我們挑選模型的過程就是確定最優化的引數x 的過程。這個分析過程與上面訓練引數的思路如出一轍!只是這個過程是基於同一個測試集,而不訓練集。那麼,不同的神經網路的層數是不是也是一個新的引數 y∈(1,2,3,4,…,100), 也要經過這麼個過程來“訓練”?
我 們會發現我們之前生成模型過程中很多不變的部分其實都是可以變換調節的,這些也是新的引數,比如訓練次數、梯度下降過程的步長、規範化引數、學習回合數、 minibatch 值等等,我們把他們叫做超引數。超引數是影響所求引數最終取值的引數,是機器學習模型裡面的框架引數,可以理解成引數的引數,它們通常是手工設定,不斷試 錯調整的,或者對一系列窮舉出來的引數組合一通進行列舉(網格搜尋)來確定。但無論如何,這也是基於同樣一個資料集反覆驗證優化的結果。在這個資料集上最
後的結果並不一定在新的資料繼續有效。所以為了評估這個模型的識別效果,就需要用新的測試集對模型進行考核,得出的測試結果作為對模型的評價。這個新的測 試集我們就直接叫“測試集”,之前那個用於篩選超引數的測試集,我們就叫做“交叉驗證集”。篩選模型的過程其實就是交叉驗證的過程。
所以,規範的方法的是將資料集拆分成三個集合:訓練集、交叉驗證集、測試集,然後依次訓練引數、超引數,最終得到最優的模型。
因此,上圖可以進一步細化成下圖:
進一步細化成下圖
或者下圖:
進一步細化成下圖2
可見機器學習過程是一個反覆迭代不斷優化的過程。其中很大一部分工作是在調整引數和超引數。
4、先跑跑再說:初步執行程式碼
Michael Nielsen的程式碼封裝得很好,只需以下5行命令就可以生成神經網路並測試結果,並達到94.76%的正確率!
import mnist_loader
import network
# 將資料集拆分成三個集合:訓練集、交叉驗證集、測試集
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
# 生成神經網路物件,神經網路結構為三層,每層節點數依次為(784, 30, 10)
net = network.Network([784, 30, 10])
# 用(mini-batch)梯度下降法訓練神經網路(權重與偏移),並生成測試結果。
# 訓練回合數=30, 用於隨機梯度下降法的最小樣本數=10,學習率=3.0
net.SGD(training_data, 30, 10, 3.0, test_data=test_data)
第一個命令的功能是:將資料集拆分成三個集合:訓練集、交叉驗證集、測試集。
第二個命令的功能是:生成神經網路物件,神經網路結構為三層,每層節點數依次為(784, 30, 10)。
第三個命令的功能是:用(mini-batch)梯度下降法訓練神經網路(權重與偏移),並生成測試結果。
該命令設定了三個超引數:訓練回合數=30, 用於隨機梯度下降法的最小樣本數(mini-batch-size)=10,步長=3.0。
總共的輸出結果如下:
Epoch 0: 9045 / 10000
Epoch 1: 9207 / 10000
Epoch 2: 9273 / 10000
Epoch 3: 9302 / 10000
Epoch 4: 9320 / 10000
Epoch 5: 9320 / 10000
Epoch 6: 9366 / 10000
Epoch 7: 9387 / 10000
Epoch 8: 9427 / 10000
Epoch 9: 9402 / 10000
Epoch 10: 9400 / 10000
Epoch 11: 9442 / 10000
Epoch 12: 9448 / 10000
Epoch 13: 9441 / 10000
Epoch 14: 9443 / 10000
Epoch 15: 9479 / 10000
Epoch 16: 9459 / 10000
Epoch 17: 9446 / 10000
Epoch 18: 9467 / 10000
Epoch 19: 9470 / 10000
Epoch 20: 9459 / 10000
Epoch 21: 9484 / 10000
Epoch 22: 9479 / 10000
Epoch 23: 9475 / 10000
Epoch 24: 9482 / 10000
Epoch 25: 9489 / 10000
Epoch 26: 9489 / 10000
Epoch 27: 9478 / 10000
Epoch 28: 9480 / 10000
Epoch 29: 9476 / 10000
5、神經網路如何識別手寫數字:啟發式理解
首先,我們解釋一下神經網路每層的功能。
神經網路每層
第一層是輸入層。因為mnist資料集中每一個手寫數字樣本是一個28*28畫素的影象,因此對於每一個樣本,其輸入的資訊就是每一個畫素對應的灰度,總共有28*28=784個畫素,故這一層有784個節點。
第三層是輸出層。因為阿拉伯數字總共有10個,我們就要將樣本分成10個類別,因此輸出層我們採用10個節點。當樣本屬於某一類(某個數字)的時候,則該類(該數字)對應的節點為1,而剩下9個節點為0,如[0,0,0,1,0,0,0,0,0,0]。
因此,我們每一個樣本(手寫數字的影象)可以用一個超長的784維的向量表示其特徵,而用一個10維向量表示該樣本所屬的類別(代表的真實數字),或者叫做標籤。
mnist的資料就是這樣表示的。所以,如果你想看訓練集中第n個樣本的784維特徵向量,直接看training_data[n][0]就可以找到,而要看其所屬的標籤,看training_data[n][1]就夠了。
那麼,第二層神經網路所代表的意義怎麼理解?這其實是很難的。但是我們可以有一個啟發式地理解,比如用中間層的某一個節點表示影象中的某一個小區域的特定影象。這樣,我們可以假設中間層的頭4個節點依次用來識別影象左上、右上、左下、右下4個區域是否存在這樣的特徵的。
右上、左下、右下
如果這四個節點的值都很高,說明這四個區域同時滿足這些特徵。將以上的四個部分拼接起來,我們會發現,輸入樣本很可能就是一個手寫“0”!
0
因此,同一層的幾個神經元同時被啟用了意味著輸入樣本很可能是某個數字。
當然,這只是對神經網路作用機制的一個啟發式理解。真實的過程卻並不一定是這樣。但通過啟發式理解,我們可以對神經網路作用機制有一個更加直觀的認識。
由此可見,神經網路能夠識別手寫數字的關鍵是它有能夠對特定的影象激發特定的節點。而神經網路之所以能夠針對性地激發這些節點,關鍵是它具有能夠適應相關問題場景的權重和偏移。那這些權重和偏移如何訓練呢?
6、神經網路如何訓練:進一步閱讀程式碼
上文已經圖解的方式介紹了機器學習解決問題的一般思路,但是具體到神經網路將是如何訓練呢?
其實最快的方式是直接閱讀程式碼。我們將程式碼的結構用下圖展示出來,運用其內建函式名錶示基本過程,發現與我們上文分析的思路一模一樣:
分析思路
簡單解釋一下,在神經網路模型中:
所需要求的關鍵引數就是:神經網路的權重(self.weights)和偏移(self.biases)。
超引數是:隱藏層的節點數=30,訓練回合數(epochs)=30, 用於隨機梯度下降法的最小樣本數(mini_batch_size)=10,步長(eta)=3.0。
梯度下降
用隨機梯度下降法調整引數:
用反向傳播法求出隨機梯度下降法所需要的梯度(偏導數): backprop()
用輸出向量減去標籤向量衡量訓練誤差:cost_derivative() = output_activations-y
全部程式碼如下(去掉註釋之後,只有74行):
“””
network.py
~~~~~~~~~~
A module to implement the stochastic gradient descent learning
algorithm for a feedforward neural network.  Gradients are calculated
using backpropagation.  Note that I have focused on making the code
simple, easily readable, and easily modifiable.  It is not optimized,
and omits many desirable features.
“””
#### Libraries
# Standard library
import random
# Third-party libraries
import numpy as np
class Network(object):
    def __init__(self, sizes):
        “””The list sizes contains the number of neurons in the
        respective layers of the network.  For example, if the list
        was [2, 3, 1] then it would be a three-layer network, with the
        first layer containing 2 neurons, the second layer 3 neurons,
        and the third layer 1 neuron.  The biases and weights for the
        network are initialized randomly, using a Gaussian
        distribution with mean 0, and variance 1.  Note that the first
        layer is assumed to be an input layer, and by convention we
        won’t set any biases for those neurons, since biases are only
        ever used in computing the outputs from later layers.”””
        self.num_layers = len(sizes)
        self.sizes = sizes
        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
        self.weights = [np.random.randn(y, x)
                        for x, y in zip(sizes[:-1], sizes[1:])]
    def feedforward(self, a):
        “””Return the output of the network if a is input.”””
        for b, w in zip(self.biases, self.weights):
            a = sigmoid(np.dot(w, a) b)
        return a
    def SGD(self, training_data, epochs, mini_batch_size, eta,
            test_data=None):
        “””Train the neural network using mini-batch stochastic
        gradient descent.  The training_data is a list of tuples
        (x, y) representing the training inputs and the desired
        outputs.  The other non-optional parameters are
        self-explanatory.  If test_data is provided then the
        network will be evaluated against the test data after each
        epoch, and partial progress printed out.  This is useful for
        tracking progress, but slows things down substantially.”””
        if test_data: n_test = len(test_data)
        n = len(training_data)
        for j in xrange(epochs):
            random.shuffle(training_data)
            mini_batches = [
                training_data[k:k mini_batch_size]
                for k in xrange(0, n, mini_batch_size)]
            for mini_batch in mini_batches:
                self.update_mini_batch(mini_batch, eta)
            if test_data:
                print “Epoch {0}: {1} / {2}”.format(
                    j, self.evaluate(test_data), n_test)
            else:
                print “Epoch {0} complete”.format(j)
    def update_mini_batch(self, mini_batch, eta):
        “””Update the network’s weights and biases by applying
        gradient descent using backpropagation to a single mini batch.
        The mini_batch is a list of tuples (x, y),
and eta
        is the learning rate.”””
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        for x, y in mini_batch:
            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
            nabla_b = [nb dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
            nabla_w = [nw dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
        self.weights = [w-(eta/len(mini_batch))*nw
                        for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b-(eta/len(mini_batch))*nb
                       for b, nb in zip(self.biases, nabla_b)]
    def backprop(self, x, y):
        “””Return a tuple (nabla_b, nabla_w) representing the
        gradient for the cost function C_x.  nabla_b and
        nabla_w are layer-by-layer lists of numpy arrays, similar
        to self.biases and self.weights.”””
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        # feedforward
        activation = x
        activations = [x] # list to store all the activations, layer by layer
        zs = [] # list to store all the z vectors, layer by layer
        for b, w in zip(self.biases, self.weights):
            z = np.dot(w, activation) b
            zs.append(z)
            activation = sigmoid(z)
            activations.append(activation)
        # backward pass
        delta = self.cost_derivative(activations[-1], y) * \
            sigmoid_prime(zs[-1])
        nabla_b[-1] = delta
        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
        # Note that the variable l in the loop below is used a little
        # differently to the notation in Chapter 2 of the book.  Here,
        # l = 1 means the last layer of neurons, l = 2 is the
        # second-last layer, and so on.  It’s a renumbering of the
        # scheme in the book, used here to take advantage of the fact
        # that Python can use negative indices in lists.
        for l in xrange(2, self.num_layers):
            z = zs[-l]
            sp = sigmoid_prime(z)
            delta = np.dot(self.weights[-l 1].transpose(), delta) * sp
            nabla_b[-l] = delta
            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
        return (nabla_b, nabla_w)
    def evaluate(self, test_data):
        “””Return the number of test inputs for which the neural
        network outputs the correct result. Note that the neural
        network’s output is assumed to be the index of whichever
        neuron in the final layer has the highest activation.”””
        test_results = [(np.argmax(self.feedforward(x)), y)
                        for (x, y) in test_data]
        return sum(int(x == y) for (x, y) in test_results)
    def cost_derivative(self, output_activations, y):
        “””Return the vector of partial derivatives \partial C_x /
        \partial a for the output activations.”””
        return (output_activations-y)
#### Miscellaneous functions
def sigmoid(z):
    “””The sigmoid function.”””
    return 1.0/(1.0 np.exp(-z))
def sigmoid_prime(z):
    “””Derivative of the sigmoid function.”””
    return sigmoid(z)*(1-sigmoid(z))
7、神經網路如何優化:訓練超引數與多種模型對比
由以上分析可知,神經網路只需要74行程式碼就可以完成程式設計,可見機器學習真正困難的地方並不在程式設計,而在你對數學過程本身,和對它與現實問題的對應關係有深入的理解。理解深入後,你才能寫出這樣的程式,並對其進行精微的調優。
我們初步的結果已經是94.76%的正確率了。但如果要將準確率提得更高怎麼辦?
這其實是一個開放的問題,有許多方法都可以嘗試。我們這裡僅僅是拋磚引玉。
首先,隱藏層只有30個節點。由我們之前對隱藏層的啟發式理解可以猜測,神經網路的識別能力其實與隱藏層對一些細節的識別能力正相關。如果隱藏層的節點更多的話,其識別能力應該會更強的。那麼我們設定100個隱藏層節點試試?
net = network.Network([784, 100, 10])
net.SGD(training_data, 30, 10, 3.0, test_data=test_data)
發現結果如下:
Epoch 0: 6669 / 10000
Epoch 1: 6755 / 10000
Epoch 2: 6844 / 10000
Epoch 3: 6833 / 10000
Epoch 4: 6887 / 10000
Epoch 5: 7744 / 10000
Epoch 6: 7778 / 10000
Epoch 7: 7876 / 10000
Epoch 8: 8601 / 10000
Epoch 9: 8643 / 10000
Epoch 10: 8659 / 10000
Epoch 11: 8665 / 10000
Epoch 12: 8683 / 10000
Epoch 13: 8700 / 10000
Epoch 14: 8694 / 10000
Epoch 15: 8699 / 10000
Epoch 16: 8715 / 10000
Epoch 17: 8770 / 10000
Epoch 18: 9611 / 10000
Epoch 19: 9632 / 10000
Epoch 20: 9625 / 10000
Epoch 21: 9632 / 10000
Epoch 22: 9651 / 10000
Epoch 23: 9655 / 10000
Epoch 24: 9653 / 10000
Epoch 25: 9658 / 10000
Epoch 26: 9653 / 10000
Epoch 27: 9664 / 10000
Epoch 28: 9655 / 10000
Epoch 29: 9672 / 10000
發現,我們只是改了一個超引數,準確率就從94.76%提升到96.72%!
這 裡強調一下,更加規範的模型調優方法是將多個模型用交叉驗證集的結果來橫向比較,選出最優模型後再用一個新的測試集來最終評估該模型。本文為了與之前的結 果比較,才採用了測試集而不是交叉驗證集。讀者千萬不要學博主這樣做哈,因為這很有可能會過擬合。這是工程實踐中資料探勘人員經常犯的錯誤,我們之後會專 門寫篇博文探討。
我們現在回來繼續調優我們的模型。那麼還有其他的隱藏節點數更合適嗎?這個我們也不知道。常見的方法是用幾何級數增長的數列(如:10,100,1000,……)去嘗試,然後不斷確定合適的區間,最終確定一個相對最優的值。
但是即便如此,我們也只嘗試了一個超引數,還有其他的超引數沒有調優呢。我們於是嘗試另一個超引數:步長。之前的步長是3.0,但是我們可能覺得學習速率太慢了。那麼嘗試一個更大的步長試試?比如100?
net = network.Network([784, 30, 10])
net.SGD(training_data, 30, 10, 100.0, test_data=test_data)
發現結果如下:
Epoch 0: 1002 / 10000
Epoch 1: 1002 / 10000
Epoch 2: 1002 / 10000
Epoch 3: 1002 / 10000
Epoch 4: 1002 / 10000
Epoch 5: 1002 / 10000
Epoch 6: 1002 / 10000
Epoch 7: 1002 / 10000
Epoch 8: 1002 / 10000
Epoch 9: 1002 / 10000
Epoch 10: 1002 / 10000
Epoch 11: 1002 / 10000
Epoch 12: 1001 / 10000
Epoch 13: 1001 / 10000
Epoch 14: 1001 / 10000
Epoch 15: 1001 / 10000
Epoch 16: 1001 / 10000
Epoch 17: 1001 / 10000
Epoch 18: 1001 / 10000
Epoch 19: 1001 / 10000
Epoch 20: 1000 / 10000
Epoch 21: 1000 / 10000
Epoch 22: 999 / 10000
Epoch 23: 999 / 10000
Epoch 24: 999 / 10000
Epoch 25: 999 / 10000
Epoch 26: 999 / 10000
Epoch 27: 999 / 10000
Epoch 28: 999 / 10000
Epoch 29: 999 / 10000
發現準確率低得不忍直視,看來步長設得太長了。根本跑不到最低點。那麼我們設定一個小的步長試試?比如0.01。
net = network.Network([784, 100, 10])
net.SGD(training_data, 30, 10, 0.001, test_data=test_data)
結果如下:
Epoch 0: 790 / 10000
Epoch 1: 846 / 10000
Epoch 2: 854 / 10000
Epoch 3: 904 / 10000
Epoch 4: 944 / 10000
Epoch 5: 975 / 10000
Epoch 6: 975 / 10000
Epoch 7: 975 / 10000
Epoch 8: 975 / 10000
Epoch 9: 974 / 10000
Epoch 10: 974 / 10000
Epoch 11: 974 / 10000
Epoch 12: 974 / 10000
Epoch 13: 974 / 10000
Epoch 14: 974 / 10000
Epoch 15: 974 / 10000
Epoch 16: 974 / 10000
Epoch 17: 974 / 10000
Epoch 18: 974 / 10000
Epoch 19: 976 / 10000
Epoch 20: 979 / 10000
Epoch 21: 981 / 10000
Epoch 22: 1004 / 10000
Epoch 23: 1157 / 10000
Epoch 24: 1275 / 10000
Epoch 25: 1323 / 10000
Epoch 26: 1369 / 10000
Epoch 27: 1403 / 10000
Epoch 28: 1429 / 10000
Epoch 29: 1451 / 10000
呃,發現準確率同樣低得不忍直視。但是有一個優點,準確率是穩步提升的。說明模型在大方向上應該還是對的。如果在除錯模型的時候忽視了這個細節,你可能真的找不到合適的引數。
可 見,我們第一次嘗試的神經網路結構的超引數設定還是比較不錯的。但是真實的應用場景中,基本沒有這樣好的運氣,很可能剛開始測試出來的結果全是奇葩生物, 長得違反常理,就像來自另一個次元似的。這是資料探勘工程師常見的情況。此時最應該做的,就是遏制住心中數萬草泥馬的咆哮奔騰,靜靜地觀察測試結果的分佈 規律,嘗試找到些原因,再繼續將模型試著調優下去,與此同時,做好從一個坑跳入下一個坑的心理準備。當然,在機器學習工程師前赴後繼的填坑過程中,還是總
結出了一些調優規律。我們會在接下來專門寫博文分析。
當 然,以上的調優都沒有逃出神經網路模型本身的範圍。但是可不可能其他的模型效果更好?比如傳說中的支援向量機?關於支援向量機的解讀已經超越了本文的篇 幅,我們也考慮專門撰寫博文分析。但是在這裡我們只是引用一下在scikit-learn中提供好的介面,底層是用效能更好的C語言封裝的著名的 LIBSVM。
相關程式碼也在Michael Nielsen的檔案中。直接引入,並執行一個方法即可。
import mnist_svm
mnist_svm.svm_baseline()
我們看看結果:
Baseline classifier using an SVM.
9435 of 10000 values correct.
94.35%,好像比我們的神經網路低一點啊。看來我們的神經網路模型還是更優秀一些?
然 而,實際情況並非如此。因為我們用的只是scikit-learn給支援向量機的設好的預設引數。支援向量機同樣有一大堆可調的超引數,以提升模型的效 果。 跟據 Andreas Mueller的這篇博文,調整好超引數的支援向量機能夠達到98.5%的準確度!比我們剛才最好的神經網路提高了1.8個百分點!
然而,故事並沒有結束。2013年,通過深度神經網路,研究者可以達到99.79%的準確度!而且,他們並沒有運用很多高深的技術。很多技術在我們接下來的博文中都可以繼續介紹。
所以,從目前的準確度來看:
簡單的支援向量機<淺層神經網路<調優的支援向量機<深度神經網路
但還是要提醒一下,炫酷的演算法固然重要,但是良好的資料集有時候比演算法更重要。Michael Nielsen專門寫了一個公式來來表達他們的關係:
精緻的演算法 ≤ 簡單的演算法 良好的訓練資料
sophisticated algorithm ≤ simple learning algorithm good training data.
所以為了調優模型,往往要溯源到資料本身,好的資料真的會有好的結果。
作者介紹:
龍心塵和寒小陽:從事機器學習/資料探勘相關應用工作,熱愛機器學習/資料探勘
注:轉載文章均來自於公開網路,僅供學習使用,不會用於任何商業用途,如果侵犯到原作者的權益,請您與我們聯絡刪除或者授權事宜,聯絡郵箱:[email protected]。轉載數盟網站文章請註明原文章作者,否則產生的任何版權糾紛與數盟無關。