2. 程式人生 > >特徵真的越多越好嗎？從特徵工程角度看“garbage in，garbage out”

特徵真的越多越好嗎？從特徵工程角度看“garbage in，garbage out”

阿新 • • 發佈：2019-10-24

1. 從樸素貝葉斯在醫療診斷中的迷思說起

這個模型最早被應用於醫療診斷，其中，類變數的不同值用於表示患者可能患的不同疾病。證據變數用於表示不同症狀、化驗結果等。在簡單的疾病診斷上，樸素貝葉斯模型確實發揮了很好的作用，甚至比人類專家的診斷結果都要好。但是在更深度的應用中，醫生髮現，對於更復雜（由多種致病原因和症狀共同表現）的疾病，模型表現的並不好。

資料科學家經過分析認為，出現這種現象的原因在於：模型做了集中通常並不真實的強假設，例如：

  • 一個患者至多可能患一種疾病
  • 在已知患者的疾病條件下，不同症狀的出現與否，不同化驗結果，之間是互相獨立的

這種模型可用於醫學診斷是因為少量可解釋的引數易於由專家獲得，早期的機器輔助醫療診斷系統正式建立在這一技術之上。

但是，之後更加深入的實踐表明，構建這種模型的強假設降低了模型診斷的準確性，尤其是“過度計算”某些特定的證據，該模型很容易過高估計某些方面特徵的影響。

例如，“高血壓”和“肥胖症”是心臟病的兩個硬指標，但是，這兩個症狀之間相關度很高，高血壓一般就伴隨著肥胖症。在使用樸素貝葉斯公式計算的時候，由於乘法項的緣故，關於這方面的證據因子就會被重複計算，如下式：

P(心臟病 | 高血壓，肥胖症) = P(高血壓 | 心臟病) * P(高血壓 | 肥胖症) / P(高血壓，肥胖症)

由於“高血壓”和“肥胖症”之間存在較強相關性的緣故，我們可以很容易想象，分子乘積增加的比率是大於分母聯合分佈增加的比率的。因此，當分子項繼續增加的時候，最終的後驗概率就會不斷增大。但是因為新增的特徵項並沒有提供新的資訊，後驗概率的這種增大變化反而降低了模型的預測效能。

實際上，在實踐中人們發現，樸素貝葉斯模型的診斷效能會隨著特徵的增加而降低，這種降低常常歸因於違背了強條件獨立性假設。

筆者將這種現象稱之為“過度特徵化（over-featuring）”，這是工程中常見的一種現象，過度特徵化如果無法得到有效規避，會顯著降低模型的泛化和預測效能。在這篇文章中，我們通過實驗和分析來論證這個說法。

 

2. 用鳶尾花分類例子討論特徵工程問題

0x1：資料集觀察

Iris 鳶尾花資料集是一個經典資料集，在統計學習和機器學習領域都經常被用作示例。   資料集內包含 3 類共 150 條記錄，每類各 50 個數據，每條記錄都有 4 項特徵：
  • 花萼長度
  • 花萼寬度
  • 花瓣長度
  • 花瓣寬度

可以通過這4個特徵預測鳶尾花卉屬於（iris-setosa, iris-versicolour, iris-virginica）中的哪一品種。

0x2：欠特徵化（under-featuring）

我們先來討論欠特徵化（under-featuring）的情況，我們的資料集中有4個維度的特徵，並且這4個特徵和目標target的相關度都是很高的，換句話說這4個特徵都是富含資訊量的特徵：

# -*- coding: utf-8 -*-

from sklearn.naive_bayes import GaussianNB
import numpy as np
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import numpy
from sklearn.utils import shuffleif __name__ == '__main__':
    # naive Bayes
    muNB = GaussianNB()

    # load data
    iris = load_iris()
    print "np.shape(iris.data): ", np.shape(iris.data)

    # feature vec
    X_train = iris.data[:int(len(iris.data)*0.8)]
    X_test = iris.data[int(len(iris.data)*0.8):]
    # label
    Y_train = iris.target[:int(len(iris.data)*0.8)]
    Y_test = iris.target[int(len(iris.data)*0.8):]

    # shuffle
    X_train, Y_train = shuffle(X_train, Y_train)
    X_test, Y_test = shuffle(X_test, Y_test)

    # load origin feature
    X_train_vec = X_train[:, :4]
    X_test_vec = X_test[:, :4]

    print "Pearson Relevance X[0]: ", numpy.corrcoef(np.array([i[0] for i in X_train_vec[:, 0:1]]), Y_train)[0, 1]
    print "Pearson Relevance X[1]: ", numpy.corrcoef(np.array([i[0] for i in X_train_vec[:, 1:2]]), Y_train)[0, 1]
    print "Pearson Relevance X[2]: ", numpy.corrcoef(np.array([i[0] for i in X_train_vec[:, 2:3]]), Y_train)[0, 1]
    print "Pearson Relevance X[3]: ", numpy.corrcoef(np.array([i[0] for i in X_train_vec[:, 3:4]]), Y_train)[0, 1]

4個特徵的皮爾森相關度都超過了0.5

現在我們分別嘗試只使用1個、2個、3個、4個特徵情況下，訓練得到的樸素貝葉斯模型的泛化和預測效能：

# -*- coding: utf-8 -*-

from sklearn.naive_bayes import GaussianNB
import numpy as np
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import numpy
from sklearn.utils import shuffle

def model_tain_and_test(feature_cn):
    # load origin feature
    X_train_vec = X_train[:, :feature_cn]
    X_test_vec = X_test[:, :feature_cn]

    # train model
    muNB.fit(X_train_vec, Y_train)
    # predidct the test data
    y_predict = muNB.predict(X_test_vec)

    print "feature_cn: ", feature_cn
    print 'accuracy is: {0}'.format(accuracy_score(Y_test, y_predict))
    print 'error is: {0}'.format(confusion_matrix(Y_test, y_predict))
    print ' '

if __name__ == '__main__':
    # naive Bayes
    muNB = GaussianNB()

    # load data
    iris = load_iris()
    print "np.shape(iris.data): ", np.shape(iris.data)

    # feature vec
    X_train = iris.data[:int(len(iris.data)*0.8)]
    X_test = iris.data[int(len(iris.data)*0.8):]
    # label
    Y_train = iris.target[:int(len(iris.data)*0.8)]
    Y_test = iris.target[int(len(iris.data)*0.8):]

    # shuffle
    X_train, Y_train = shuffle(X_train, Y_train)
    X_test, Y_test = shuffle(X_test, Y_test)

    # train and test the generalization and prediction
    model_tain_and_test(1)
    model_tain_and_test(2)
    model_tain_and_test(3)
    model_tain_and_test(4)

可以看到，只使用1個特徵的時候，在測試集上的預測精確度只有33.3%，隨著特徵數的增加，測試集上的預測精確度逐漸增加。

用貝葉斯網的角度來看樸素貝葉斯模型，有如下結構圖，

Xi節點這裡相當於特徵，網路中每個Xi節點的增加，都會改變對Class結果的概率推理，Xi越多，推理的準確度也就越高。

從資訊理論的角度也很好理解，我們可以將P(Class | Xi)看成是條件熵的資訊傳遞過程，我們提供的資訊越多，原則上，對Class的不確定性就會越低。

至此，我們得出如下結論：

特徵工程過程中需要特別關注描述完整性問題（description integrity problem），特徵維度沒有完整的情況下，提供再多的資料對模型效果都沒有實質的幫助。樣本集的概率完整性要從“特徵完整性”和“資料完整性”兩個方面保證，它們二者歸根結底還是資訊完整性的本質問題。

0x3：過特徵化（over-featuring）

現在我們在原始的4個特徵維度上，繼續增加新的無用特徵，即那種和目標target相關度很低的特徵。

# -*- coding: utf-8 -*-

from sklearn.naive_bayes import GaussianNB
import numpy as np
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import numpy
from sklearn.utils import shuffle
import random


def feature_expend(feature_vec):
    # colum_1 * colum_2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 0], feature_vec[:, 1])])))
    # random from colum_1
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 0]])))
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 0]])))
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 0]])))
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 0]])))
    # random from colum_2
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 1]])))
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 1]])))
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 1]])))
    feature_vec = np.hstack((feature_vec, np.array([[random.uniform(.0, i)] for i in feature_vec[:, 1]])))

    return feature_vec


def model_tain_and_test(X_train, X_test, Y_train, Y_test, feature_cn):
    # load origin feature
    X_train_vec = X_train[:, :feature_cn]
    X_test_vec = X_test[:, :feature_cn]

    # train model
    muNB.fit(X_train_vec, Y_train)
    # predidct the test data
    y_predict = muNB.predict(X_test_vec)

    print "feature_cn: ", feature_cn
    print 'accuracy is: {0}'.format(accuracy_score(Y_test, y_predict))
    print 'error is: {0}'.format(confusion_matrix(Y_test, y_predict))
    print ' '



if __name__ == '__main__':
    # naive Bayes
    muNB = GaussianNB()

    # load data
    iris = load_iris()
    print "np.shape(iris.data): ", np.shape(iris.data)

    # feature vec
    X_train = iris.data[:int(len(iris.data)*0.8)]
    X_test = iris.data[int(len(iris.data)*0.8):]
    # label
    Y_train = iris.target[:int(len(iris.data)*0.8)]
    Y_test = iris.target[int(len(iris.data)*0.8):]

    # shuffle
    X_train, Y_train = shuffle(X_train, Y_train)
    X_test, Y_test = shuffle(X_test, Y_test)

    # expend feature
    X_train = feature_expend(X_train)
    X_test = feature_expend(X_test)
    print "X_test: ", X_test

    # show Pearson Relevance
    for i in range(len(X_train[0])):
        print "Pearson Relevance X[{0}]: ".format(i), numpy.corrcoef(np.array([i[0] for i in X_train[:, i:i+1]]), Y_train)[0, 1]

    model_tain_and_test(X_train, X_test, Y_train, Y_test, len(X_train[0]))

我們用random函式模擬了一個無用的新特徵，可以看到，無用的特徵對模型不但沒有幫助，反而降低了模型的效能。 

至此，我們得出如下結論：

特徵不是越多越多，機器學習不是洗衣機，一股腦將所有特徵都丟進去，然後雙手合十，指望著模型能施展魔法，自動篩選出有用的好特徵，當然，dropout/正則化這些手段確實有助於提高模型效能，它們的工作本質也是通過去除一些特徵，從而緩解垃圾特徵對模型帶來的影響。

當然，未來也許會發展出autoFeature的工程技術，但是作為資料科學工作者，我們自己必須要理解特徵工程的意義。

0x4：特徵加工對模型效能的影響

所謂的“特徵加工”，具體來說就是對原始的特徵進行線性變換（拉伸和旋轉），得到新的特徵，例如：

  • X_i * X_j
  • X_i ^ 2
  • X_i / X_j
  • X_i + X_j
  • X_i - X_j

本質上來說，我們可以將深度神經網路的隱層看做是一種特徵加工操作，稍有不同的是，深度神經網路中啟用函式充當了非線性扭曲的作用，不過其本質思想還是不變的。

那接下來問題是，特徵加工對模型的效能有沒有影響呢？

準確的回答是，特徵加工對模型的影響取決於新增特徵的相關度，以及壞特徵在所有特徵中的佔比。

我們來通過幾個實驗解釋上面這句話，下面筆者先通過模擬出幾個典型場景，最終給出總結結論：

1. 新增的特徵和目標target相關度很低，同時該壞特徵的佔比還很高

# -*- coding: utf-8 -*-

from sklearn.naive_bayes import GaussianNB
import numpy as np
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import numpy
from sklearn.utils import shuffle


def feature_expend(feature_vec):
    # colum_1 * colum_2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 0], feature_vec[:, 1])])))
    # colum_1 / colum_2
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.divide(feature_vec[:, 0], feature_vec[:, 1])])))
    # colum_3 * colum_4
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 2], feature_vec[:, 3])])))
    # colum_4 * colum_1
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 3], feature_vec[:, 0])])))
    # colum_1 ^ 2
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 0], feature_vec[:, 0])])))
    # colum_2 ^ 2
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 1], feature_vec[:, 1])])))
    # colum_3 ^ 2
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 2], feature_vec[:, 2])])))
    # colum_4 ^ 2
    # feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 3], feature_vec[:, 3])])))
    return feature_vec


def model_tain_and_test(X_train, X_test, Y_train, Y_test, feature_cn):
    # load origin feature
    X_train_vec = X_train[:, :feature_cn]
    X_test_vec = X_test[:, :feature_cn]

    # train model
    muNB.fit(X_train_vec, Y_train)
    # predidct the test data
    y_predict = muNB.predict(X_test_vec)

    print "feature_cn: ", feature_cn
    print 'accuracy is: {0}'.format(accuracy_score(Y_test, y_predict))
    print 'error is: {0}'.format(confusion_matrix(Y_test, y_predict))
    print ' '



if __name__ == '__main__':
    # naive Bayes
    muNB = GaussianNB()

    # load data
    iris = load_iris()
    print "np.shape(iris.data): ", np.shape(iris.data)

    # feature vec
    X_train = iris.data[:int(len(iris.data)*0.8)]
    X_test = iris.data[int(len(iris.data)*0.8):]
    # label
    Y_train = iris.target[:int(len(iris.data)*0.8)]
    Y_test = iris.target[int(len(iris.data)*0.8):]

    # shuffle
    X_train, Y_train = shuffle(X_train, Y_train)
    X_test, Y_test = shuffle(X_test, Y_test)

    # expend feature
    X_train = feature_expend(X_train)
    X_test = feature_expend(X_test)
    print "X_test: ", X_test

    # show Pearson Relevance
    for i in range(len(X_train[0])):
        print "Pearson Relevance X[{0}]: ".format(i), numpy.corrcoef(np.array([i[0] for i in X_train[:, i:i+1]]), Y_train)[0, 1]

    model_tain_and_test(X_train, X_test, Y_train, Y_test, len(X_train[0])-1)
    model_tain_and_test(X_train, X_test, Y_train, Y_test, len(X_train[0]))

上面程式碼中，我們新增了一個“colum_1 * colum_2”特徵維度，並且列印了該特徵的皮爾森相關度，相關度只有0.15，這是一個很差的特徵。同時該壞特徵佔了總特徵的1/5比例，是一個不低的比例。

因此在這種情況下，模型的檢出效果受到了影響，下降了。原因之前也解釋過，壞的特徵因為累乘效應，影響了最終的概率值。

2. 新增的一批特徵中，出現了少量的壞特徵，即壞特徵佔比很低

# -*- coding: utf-8 -*-

from sklearn.naive_bayes import GaussianNB
import numpy as np
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import numpy
from sklearn.utils import shuffle


def feature_expend(feature_vec):
    # colum_1 * colum_2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 0], feature_vec[:, 1])])))
    # colum_1 / colum_2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.divide(feature_vec[:, 0], feature_vec[:, 1])])))
    # colum_3 * colum_4
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 2], feature_vec[:, 3])])))
    # colum_4 * colum_1
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 3], feature_vec[:, 0])])))
    # colum_1 ^ 2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 0], feature_vec[:, 0])])))
    # colum_2 ^ 2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 1], feature_vec[:, 1])])))
    # colum_3 ^ 2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 2], feature_vec[:, 2])])))
    # colum_4 ^ 2
    feature_vec = np.hstack((feature_vec, np.array([[i] for i in np.multiply(feature_vec[:, 3], feature_vec[:, 3])])))
    return feature_vec


def model_tain_and_test(X_train, X_test, Y_train, Y_test, feature_cn):
    # load origin feature
    X_train_vec = X_train[:, :feature_cn]
    X_test_vec = X_test[:, :feature_cn]

    # train model
    muNB.fit(X_train_vec, Y_train)
    # predidct the test data
    y_predict = muNB.predict(X_test_vec)

    print "feature_cn: ", feature_cn
    print 'accuracy is: {0}'.format(accuracy_score(Y_test, y_predict))
    print 'error is: {0}'.format(confusion_matrix(Y_test, y_predict))
    print ' '



if __name__ == '__main__':
    # naive Bayes
    muNB = GaussianNB()

    # load data
    iris = load_iris()
    print "np.shape(iris.data): ", np.shape(iris.data)

    # feature vec
    X_train = iris.data[:int(len(iris.data)*0.8)]
    X_test = iris.data[int(len(iris.data)*0.8):]
    # label
    Y_train = iris.target[:int(len(iris.data)*0.8)]
    Y_test = iris.target[int(len(iris.data)*0.8):]

    # shuffle
    X_train, Y_train = shuffle(X_train, Y_train)
    X_test, Y_test = shuffle(X_test, Y_test)

    # expend feature
    X_train = feature_expend(X_train)
    X_test = feature_expend(X_test)
    print "X_test: ", X_test

    # show Pearson Relevance
    for i in range(len(X_train[0])):
        print "Pearson Relevance X[{0}]: ".format(i), numpy.corrcoef(np.array([i[0] for i in X_train[:, i:i+1]]), Y_train)[0, 1]

    model_tain_and_test(X_train, X_test, Y_train, Y_test, len(X_train[0]))

在這個場景中，“colum_1 * colum_2”這個壞特徵依然存在，但和上一個場景不同的是，除了這個壞特徵之外，新增的特徵都是好特徵（相關度都很高）。

根據簡單的乘積因子原理可以很容易理解，這個壞特徵對最終概率數值的影響會被“稀釋”，從而降低了對模型效能的影響。

至此，我們得出如下結論：

深度神經網路的隱層結構大規模增加了特徵的數量。本質上，深度神經網路通過矩陣線性變換和非線性啟用函式得到海量的特徵維度的組合。我們可以想象到，其中一定有好特徵（相關度高），也一定會有壞特徵（相關度低）。

但是有一定我們可以確定，好特徵的出現概率肯定是遠遠大於壞特徵的，因為所有的特徵都是從輸入層的好特徵衍生而來的（遺傳進化思想）。那麼當新增特徵數量足夠多的時候，從概率上就可以證明，好特徵的影響就會遠遠大於壞特徵，從而消解掉了壞特徵對模型效能的影響。這就是為什麼深度神經網路的適應度很強的原因之一。

用一句通俗的話來說就是：如果你有牛刀，殺雞為啥不用牛刀？用牛刀殺雞的好處在於，不管來的是雞還是牛，都能自適應地保證能殺掉。

 

3. 不同機器學習模型中，過特徵化的結構基礎

冗餘特徵和過特徵化現象在機器學習模型中並不罕見，在不同的模型中有不同的表現形式，例如：

  • 樸素貝葉斯：累乘效應
  • 多項式迴歸：累加效應
  • 深度神經網路：累加、累乘效應

 

4. 一些工程實踐指導原則 

這裡列舉一些筆者在工程實踐中總結出的一些指導性原則：

  • 將benchmark作為基本操作，在探索複雜模型之前採用決策樹、簡單邏輯迴歸、樸素貝葉斯這樣的基礎模型進行基準測試。目的是獲取目標問題真實難度的大致判斷。
  • 在專案開始的時候，儘量先選用小的模型，一般來說，模型複雜度越低，泛化效能越好。
  • 將正則化作是機器學習訓練中的標準配置，例如剪枝、dropout、正則引數懲罰等，目的是為了將決策權重集中到真正有價值的特徵上。深度神經網路dropout的作用，一定程度上可以理解為，去除相關性較低的特徵在最終決策中的權重，避免“低相關度特徵累乘現象”導致的誤差效應。
  • 重視特徵工程環節，對候選的特定進行相關性分析，優先選出相關度大於0.25的特徵維度，篩選掉低相關度的無用特徵。

&n

相關推薦

特徵真的越多越好嗎？從特徵工程角度看“garbage in，garbage out”

1. 從樸素貝葉斯在醫療診斷中的迷思說起 這個模型最早被應用於醫療診斷，其中，類變數的不同值用於表示患者可能患的不同疾病。證據變數用於表示不同症狀、化驗結果等。在簡單的疾病診斷上，樸素貝葉斯模型確實發揮了很好的作用，甚至比人類專家的診斷結果都要好。但是在更深度的應用中，醫生髮現，對於更復雜（由多種致病原因和

sincerit LLLYYY的數字思維(9越多越好)

連結：https://ac.nowcoder.com/acm/contest/318/G 來源：牛客網 題目描述 LLLYYY很喜歡寫暴力模擬貪心思維。某一天在機房，他突然拋給了隊友ppq一 個問題。問題如下： 有一個函式f ()： int f(int x){ int tmp = 0;

where 條件並不是越多越好

今天在寫一個sql時，遇到這麼個問題，where條件多寫了幾個，結果結果執行計劃顯得很槽糕： 表A 有欄位 heard_id，class_no，bath_no，class_name 表B有欄位 heard_id，class_no，bath_no，class_value 首先

“知識越多越反動”這句話是錯誤的，我還要說培根的“知識就力量”這句話也是有時代局限的（在今天信息爆炸的時代，信息和技能永遠在過時的道路上）

寬容 .com 開學典禮 事業 理解 思考 過時 一個 RKE 第一，養成並保持學習的能力。我在每一次開學典禮上都要談一個話題：上大學是為了什麽？我認為兩件事情最為重要：一是掌握學習的能力，二是養成合作的習慣。掌握了學習的能力和擁有合作的習慣，才能事業順利，缺一不成。在我看

事情越多越需要一款適合的任務管理軟件

size 工作 可能 pro src 成績 技術 焦慮 思考 你有沒有經歷過這樣的一幕：每天都感覺自己特別的忙，然而每當到晚上要睡覺的時候，想不起今天具體做了些什麽事情。可能是這天做的事情太多了，忙到自己也記不清楚了。可以說，是相當的忙，從早上一睜眼，一直忙到晚上睡覺。但是

自主汽車品牌瘋狂兜售智慧配置，越加越多越心慌

   文 |魏啟揚 來源 | 智慧相對論（ID：aixdlun）   不久前，奇瑞在釋出的新款瑞虎5x 1.5L上配備了手環鑰匙，作為奇瑞“雄獅LION”智慧化戰略的一部分，奇瑞用“手環開車”作為新款瑞虎5x 1.5L的主要賣點，奇瑞將車鑰匙與時下

從核心的角度看程序以及多執行緒

  前言：就如我之前所說的一樣，程式只是一個被編譯器（包括彙編器以及聯結器）將你的抽象程式碼轉換為計算機能理解的有一定格式的二進位制檔案，它有一定格式（ELF，PE之類），就如之前的我所說的例子，就好比程式就如一段鐵軌，你是鐵路設計師，編譯器負責把鐵軌做好，那麼之後很多複雜

架構漫談（八）：從架構的角度看如何寫好程式碼

架構漫談是由資深架構師王概凱Kevin執筆的系列專欄，專欄將會以Kevin的架構經驗為基礎，逐步討論什麼是架構、怎樣做好架構、軟體架構如何落地、如何寫好程式等問題。 本文是漫談架構專欄的第八篇，作者Kevin舉例介紹瞭如何寫好程式碼。當我們有了好的架構，那就需要考慮如何

朋友圈的代購還好嗎？電商征稅來襲，千萬微商告別“裸奔”！

href oss 否則 表頭 所有 新電商 調整 生產 導入 朋友圈的代購還好嗎？電商征稅來襲，千萬微商告別“裸奔”！ 新的電商法已經出臺！你的營業執照領了嗎？從2019年起，《×××電子商務法》將正式實施。新電商法明確了從事個人代購、微商、開網店也須依法辦理工商登記取得相

從進化的角度看為啥要均貧富

從進化的角度看為啥要均貧富 　 柳鯤鵬 2008-2-20 　 關鍵字：進化 變異 數量 均貧富 簡介：人的存在，就是要進化到更高的層次，這主要靠變異。而變異就要靠數量才能維護。只有保證社會絕大多數人的正常生活，人類社會才能正常進化。所以要均貧富。 　 　 　　關

從互聯網+角度看雲計算的現狀與未來（2）

大數據平臺 堅強 隱藏 用戶管理 圖像識別 都是 人工智能 大致 統計數據 此文已由作者劉超授權網易雲社區發布。歡迎訪問網易雲社區，了解更多網易技術產品運營經驗。六、業務架構趨勢一：互聯網沖擊已成必然，快速變更成為核心競爭力，DevOps重構組織架構，流程，文化是必然選擇在

從來源的角度解析l1稀疏，l2平滑

為了簡單化模型我們在損失函式中加入了罰項即l1，l2正則化項，l1更趨向於產生少的特徵項而其它特徵項為0，l2更趨向於選擇更多的項而讓這些多的特徵項趨近於0，可能思維能力好的大神們都已經有了模型能理解l1稀疏，l2平滑了，而接下來是通過概率函式模型推演來解釋的，更加直觀 ：貝葉斯演算法大量應

從概率的角度看logistic regression

logistic regression假設樣本 x x x為正的概率是：

C#中從記憶體空間的角度看資料型別，並延申到static方法的分析

資料型別這篇文章主要討論的是值型別和引用型別，值型別在定義的時候就會將該值儲存在棧中，而引用型別是分配在堆中，在堆中存放的是資料區域地址，它用來指向一塊記憶體空間。棧可以理解為儲存的都是一些資料變數，而堆中放的都是一些例項化物件。在對值型別操作時不會影響其他值，而當引用變數引用其他引用變數時

02 從JDK原始碼角度看Boolean

Java的Boolean類主要作用就是對基本型別boolean進行封裝，提供了一些處理boolean型別的方法，比如String型別和boolean型別的轉換。 主要實現原始碼如下圖所示，具體實現程式碼可自行檢視對應的程式碼。 既然是對基本型別boolean的封裝，那

從 JDK 原始碼角度看 Object

Java的Object是所有其他類的父類，從繼承的層次來看它就是最頂層根，所以它也是唯一一個沒有父類的類。它包含了物件常用的一些方法，比如getClass、hashCode、equals、clone、toString、notify、wait等常用方法。所以其他類繼承了Obje

【轉】架構之路：從管理者的角度看問題

  http://www.cnblogs.com/freeflying/p/6036910.html 同步釋出在知乎，也不知道在部落格園裡這算不算水文，能不能上首頁。但園子裡還有一千多粉絲，我主要是想通知下面這件事：   +++++++++++++++++++ 這個系列寫得很坎坷

從另一個角度看事件驅動和協程

有一些新的想法，可能大部分的軟體架構就是人的活動的一種抽象。比如事件驅動，就可以從人的日常活動中提煉出來，設想一個禮拜天你在家裡打遊戲/上網，這個時候你媽媽打電話過來說外面下雨了，讓你去收衣服，這就是一個典型的事件驅動，你這個時候去收衣服，就是執行了回撥函式，如果不去收繼續打遊戲，就是出了B

08-1 從線性變換角度看叉積

I.問題描述 我們在08小節給出一個計算三維向量叉積的公式，但是這個公式為啥是那樣呢？ 為啥這樣計算出的向量滿足三條性質呢？ (1).長度=平行四邊形的面積 (2).方向垂直於向量v和向量u (3).滿足右手定則 通過公式推理，我們可

深入理解閉包系列第二篇——從執行環境角度看閉包

前面的話 　　本文從執行環境的角度來分析閉包，先用一張圖開宗明義，然後根據圖示內容對程式碼進行逐行說明，試圖對閉包進行更直觀的解釋 圖示 說明 　　下面按照程式碼執行流的順序對該圖示進行詳細說明 function foo(){ var a = 2; funct