推薦系統主要是把物品推薦給喜歡的使用者，在使用的環境中，物品和使用者皆會持續的增長變化，也因此會持續面對有新物品和新使用者的情境；有新的物品和使用者使得無法做好的推薦就稱為冷啟動，我們要討論在這種情況下如何做合適的推薦。

基本的冷啟動可以分成三類：

1. 使用者冷啟動：新用戶產生時沒有有任何瀏覽購買紀錄，如何推薦用品的問題。
2. 物品冷啟動：新物品如何推薦給合適的用戶。
3. 系統冷啟動：新系統上線時，物品、使用者、資料皆不足的推薦問題。

圖片來源：https://www.researchgate.net/figure/Illustration-of-Cold-Start-problem-in-recommender-systems-New-user-problem-left-and_fig2_332511384

接下來我們介紹幾個常見的解決方式

排行榜推薦

新物品的推薦

秉持著大家會喜新厭舊的心態，推薦新的物品給使用者；像是電影、影集等等就很適合，有新影片上線時，不管是新或舊的使用者都會想看。

熱門物品的推薦

推薦大家都喜歡的物品給使用者，這是非常常見的做法，簡單有效；也可以用作新演算法的AB test或benchmark，等到資料足夠後才做個性化推薦。

常用物品、必需品推薦

推薦生活必需品、常用物品給新使用者；這種情況適合一些居家用品、常用家電、廚房用具等等的情境。

標籤推薦

這種方式是針對前三項作更細微的推薦，像是ott 串流平台可以直接選擇喜劇、動作片、愛情片等等的推薦；但要注意標籤要先設計完整。

圖片來源：https://deepai.org/publication/addressing-the-cold-start-problem-in-outfit-recommendation-using-visual-preference-modelling

簡易的使用者推薦

簡易的使用者推薦

根據使用者簡易的年齡、性別等等資料分出人群進行推薦。

授權平台推薦

導入第三方社交平台facebook、google等等，根據這些平台的歷史數據進行推薦。

問答題推薦

目前有許多平台都是這種方式，註冊登入時會問幾個問題，了解你的喜好，根據你的反饋來推薦物品。

新物品的相似度推薦

新物品推薦系統在不同的平台有不同的重要程度，在新聞媒體等等時效性強的平台就特別重要，必須要快速的推薦出去，不然時間過了這個資訊、消息也就不重要了。

新物品跟用戶的相似度

計算新物品的特徵（標籤、cos相似度、TF-IDF、影像相似度等等）和使用者的行為特徵進行推薦。

新物品和舊物品的相似度

新物品進入平台後，根據平台的標籤、屬性資訊等等，計算出相似的物品，再推薦給喜歡此物品的使用者。

試探策略

這幾年短影片的流行，無論是純做短影片的網站，抑或是一般影音平台的短影片，皆是爆發性的成長；快速試探策略就很適合，快速、隨機推薦影片給使用者，再根據使用者觀看、點擊、滑動瀏覽網站、停留時間等等的行為，快速獲得使用者的資訊，再進行推薦。

結尾

上面是簡單介紹幾個常用的方式，還有許多做法可以解決遇到的冷啟動問題，主要必須先定義好問題，知道自己產品、平台的特徵、類型、使用者如何才會滿意等等的資訊，才能真正的對症下藥。

最後推薦幾篇論文，大家有興趣可以看看他們遇到的問題是什麼又是如何解決的。

Behavior-based popularity ranking on Amazon Video

Billion-scale Commodity Embedding for E-commerce Recommendation in Alibaba

Performance of recommender algorithms on top-N recommendation tasks

Real-time Personalization using Embeddings for Search Ranking at Airbnb

Deep Reinforcement learning (DRL) combined with deep learning technology is even more powerful. AlphaGo, is a typical application of deep reinforcement learning.

Source: Reinforcement Learning: An Introduction (Sutton & Barto)

It is composed of agent/actions/(status/rewards)/environment.

Reinforcement learning builds the agent and environment continuously interact with each other. After each action, the agent will receive the reward Rt+1 and the next state St+1. The goal is to improve the policy so as to maximize the sum of rewards (return).

Deep Reinforcement learning (DRL) ?

In DRL. A table(Q-table) will be stored to record all actions executed in a specific state and the value generated. Through this table, you can find the best execution method. The design of Q-Table is transformed into a neural network for learning. Through neural network learning, with different layers, huge features can be extracted from the environment to learn.

Gym MountainCar

There is the MountainCar game environment in the Gym environment library launched by OpenAI.

# show game
import gym
from gym import wrappers

env = gym.make('MountainCar-v0')
print(env.action_space.n)
print(env.observation_space)
print(env.observation_space.high)
print(env.observation_space.low)
env = wrappers.Monitor(env, "./gym-results", force=True)
env.reset()
for _ in range(1000):
    action = env.action_space.sample()
    observation, reward, done, info = env.step(action)
    if done: break
env.close()

Actions:

Type: Discrete(3)
Num    Action
0      Accelerate to the Left
1      Don't accelerate
2      Accelerate to the Right

Observation:

Type: Box(2)
Num    Observation               Min            Max
0      Car Position              -1.2           0.6
1      Car Velocity              -0.07          0.07

we use a simpler fully connected neural network.

class DQNetwork(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = tf.keras.layers.Dense(units=64, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=16, activation=tf.nn.relu)
        self.dense3 = tf.keras.layers.Dense(units=active_n)

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        x = self.dense3(x)
        return x

    def predict(self, inputs):
        q_values = self(inputs)
        return tf.argmax(q_values, axis=-1)

implement Q learning

https://www.cse.unsw.edu.au/~cs9417ml/RL1/images/qalg.gif

source https://www.cse.unsw.edu.au/~cs9417ml/RL1/algorithms.html

In this game, we set gamma in 1.0 which means there is no decrease.

After 20 mins….

Done !!!!

code : https://github.com/KbWen/tf2test/blob/gym_MountainCar/gym_MountainCar-v0.ipynb

今天用tf2來實作MNIST分類問題

MNIST

MNIST是一個很標準的手寫數字分類問題，

數據集下載有很多方式，這次直接使用tf API提供的

28 * 28 且只有黑白的數據

開發

在local 起 jupyter lab

先看看GPU是否啟用

%matplotlib widget
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np

# check gpu
tf.config.list_physical_devices('GPU')
tf.test.is_built_with_cuda()
# output True

方法一

繼承 tf.keras.model

class MLP(tf.keras.Model):

    def __init__(self):
        super().__init__()
        self.flatten = tf.keras.layers.Flatten()
        self.dense1 = tf.keras.layers.Dense(units=100, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=20, activation=tf.nn.leaky_relu)
        self.dense3 = tf.keras.layers.Dense(units=10)

    @tf.function
    def call(self, inputs):  # [batch_size, 28, 28, 1]
        flat1 = self.flatten(inputs)  # [batch_size, 784]
        dens1 = self.dense1(flat1)  # [batch_size, 100]
        dens2 = self.dense2(dens1)  # [batch_size, 20]
        dens3 = self.dense3(dens2)  # [batch_size, 10]
        output = tf.nn.softmax(dens3)
        return output

使用tf.GradientTape訓練

# @tf.function
def one_batch_step(X, y, **kwargs):
    with tf.GradientTape() as tape:
        y_pred = model(X)
        loss = tf.keras.losses.sparse_categorical_crossentropy(y_true=y, y_pred=y_pred)
        loss = tf.reduce_mean(loss)
        tf.print(f"{batch_index} loss {loss}", [loss])
        with summary_writer.as_default():
            tf.summary.scalar("loss", loss, step=batch_index)
    grads = tape.gradient(loss, model.variables)
    optimizer.apply_gradients(grads_and_vars=zip(grads, model.variables))

for epoch_index in range(num_epochs):
    for batch_index in range(num_batches):
        X, y = data_loader.get_batch(batch_size)
        one_batch_step(X, y, batch_index=batch_index)
with summary_writer.as_default():
    tf.summary.trace_export(name="model_trace", step=0, profiler_outdir=log_dir)

tf.saved_model.save(model, f"saved/{model_name}")

方法二

使用keras Pipeline來疊每一層要用的函數，彈性較低，但非常適合簡單的Model

model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(100, activation=tf.nn.relu),
    tf.keras.layers.Dense(units=20, activation=tf.nn.leaky_relu),
    tf.keras.layers.Dense(10),
    tf.keras.layers.Softmax()
])

model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
    loss=tf.keras.losses.sparse_categorical_crossentropy,
    metrics=[tf.keras.metrics.sparse_categorical_accuracy]
)

model.fit(data_loader.train_data, data_loader.train_label, epochs=num_epochs, batch_size=batch_size)

print(model.evaluate(data_loader.test_data, data_loader.test_label))

model_name = "mnist_model2"
tf.saved_model.save(model, f"saved/{model_name}")

疊完model後，先compiler選擇優化和計算方式，再fit data進去就行了

訓練狀況

需要點類神經網路的概念才看得懂程式碼，但這是個非常簡單的例子就不多介紹

可以去官網逛逛: https://www.tensorflow.org/tutorials

來更了解tf2和相對應使用

相關程式碼：github

語意分析(syntactic analysis)能夠提取語言的訊息，把文章拆成句子，句子在拆成更小的每個分詞，做更進一步的分析，Goole NLP API 會給予每個字詞的詞性以及彼此的關係。

Analyzing syntax

進入GCP新增一個API Key 並確認NLP API狀態為enable；詳細的GCP申請操作步驟可以看官方文件。(或是以後有機會寫。)

API Enabled

因為這次是介紹，所以使用google cloud shell；在平常使用下可以把某些步驟改成習慣的語言及IDE。

新增環境變數

export API_KEY=<YOUR_KEY>

確認輸入後，增加要丟進API的文字json檔 text.json

{
  "document":{
    "type":"PLAIN_TEXT",
    "content": "Beirut rescuers search the site for possible survivor 30 days after the explosion."
  },
  "encodingType": "UTF8"
}

標準的json檔輸入資訊：https://cloud.google.com/natural-language/docs

使用curl post資料

curl "https://language.googleapis.com/v1/documents:analyzeSyntax?key=${API_KEY}" \
  -s -X POST -H "Content-Type: application/json" --data-binary @text.json

會得到解析出來的資訊

{
  "sentences": [
    {
      "text": {
        "content": "Beirut rescuers search the site for possible survivor 30 days after the explosion.",
        "beginOffset": 0
      }
    }
  ],
  "tokens": [
    {
      "text": {
        "content": "Beirut",
        "beginOffset": 0
      },
      "partOfSpeech": {
        "tag": "NOUN",
        "aspect": "ASPECT_UNKNOWN",
        "case": "CASE_UNKNOWN",
        "form": "FORM_UNKNOWN",
        "gender": "GENDER_UNKNOWN",
        "mood": "MOOD_UNKNOWN",
        "number": "SINGULAR",
        "person": "PERSON_UNKNOWN",
        "proper": "PROPER",
        "reciprocity": "RECIPROCITY_UNKNOWN",
        "tense": "TENSE_UNKNOWN",
        "voice": "VOICE_UNKNOWN"
      },
      "dependencyEdge": {
        "headTokenIndex": 1,
        "label": "NN"
      },
      "lemma": "Beirut"
    },
    {
      "text": {
        "content": "rescuers",
        "beginOffset": 7
      },
      "partOfSpeech": {
        "tag": "NOUN",
        "aspect": "ASPECT_UNKNOWN",
        "case": "CASE_UNKNOWN",
        "form": "FORM_UNKNOWN",
        "gender": "GENDER_UNKNOWN",
        "mood": "MOOD_UNKNOWN",
        "number": "PLURAL",
        "person": "PERSON_UNKNOWN",
        "proper": "PROPER_UNKNOWN",
        "reciprocity": "RECIPROCITY_UNKNOWN",
        "tense": "TENSE_UNKNOWN",
        "voice": "VOICE_UNKNOWN"
      },
      "dependencyEdge": {
        "headTokenIndex": 2,
        "label": "NSUBJ"
      },
      "lemma": "rescuer"
    },
    {
      "text": {
        "content": "search",
        "beginOffset": 16
      },
      "partOfSpeech": {
        "tag": "VERB",
        "aspect": "ASPECT_UNKNOWN",
        "case": "CASE_UNKNOWN",
        "form": "FORM_UNKNOWN",
        "gender": "GENDER_UNKNOWN",
        "mood": "INDICATIVE",
        "number": "NUMBER_UNKNOWN",
        "person": "PERSON_UNKNOWN",
        "proper": "PROPER_UNKNOWN",
        "reciprocity": "RECIPROCITY_UNKNOWN",
        "tense": "PRESENT",
        "voice": "VOICE_UNKNOWN"
      }
    }
    ......
  ],
  "language": "en"
}

觀察一下上面的結果

• partOfSpeech: tag告訴你詞性rescuers是none，search是verb。
• lemma: 詞的標準行事，例如 run, runs 和ran都會是run。
• headTokenIndex: 代表他修改、修飾的是哪一個字。(index從零開始看起)
• dependencyEdge: 本質上可以看成一幅圖，他會告訴你每個單詞間關聯。如下圖

dependency tree

處理分類完這些文字後，接下來可以做更多使用。

更多詳細的介紹以及參數意義可以看官網的doc，裡面也有很多語言詳細的說明。

在訓練過程中，該演算法使用 AdaBoost，即利用多個「弱分類器」級聯 (Cascade) 來判別。每一步都會提取一個特徵值來判斷是否為人臉：

• 如果判斷為「是」，則進入下一個層級的強分類器。
• 如果判斷為「否」，則直接排除該區域。

廣義來看，這就像是讓所有弱分類器進行投票，並根據各自的準確率加權集成。其組成的分類器架構稱為 Cascade，形式上類似於簡單的多層決策樹。

實際應用與調整

在實際使用中，Haar Cascade 的挑戰主要在於參數的調優，尤其是 scaleFactor 和 minNeighbors：

• scaleFactor：控制影像縮放的比例。數值調大時，檢測的層數會變少，速度快但容易漏掉較小的目標。
• minNeighbors：決定一個目標區域被聲明為「人臉」前，周圍必須也被檢測到的人臉鄰居數量。

由於不同圖片的解析度與場景差異，往往需要手動調整參數才能達到最佳效果，這在自動化處理上較為困難。未來我會嘗試使用深度學習等更強健的方式。

參考來源：Face Recognition with Python

下圖是檢測人臉與眼睛的結果，圖片來源為 USA Volleyball National Team 合照：

My Github

在深度學習模型中，輸入必須是數字。Keras 提供了 Tokenizer 模組，會依照英文單字出現頻率進行排序並編號：Keras Tokenizer 官方文件。

接著利用 Word Embedding 將編號清單轉換為向量清單，最後丟進 LSTM 模型進行學習。

Keras 封裝了許多方便的功能，讓文字轉數字與模型建立變得非常簡單。

這是我的 Model Summary。將數字序列轉換為 64 維的向量序列，並使用了三層隱藏層進行訓練。

準確率：0.8543

實際測試

造訪 IMDb 網站，抓取《蜘蛛人：返校日 (Spider-Man: Homecoming)》的評論進行檢驗。輸入正面評論後，模型正確辨識為正面（1 為正面，0 為負面）。

My Github

相關文章

• Keras Cifar-10

CIFAR-10 是 32*32 的 RGB 彩色圖形，包含飛機、狗、貓等 10 個類別，可以視為 MNIST 的進階挑戰版。

在數據預處理 (Preprocess) 階段，流程與 MNIST 類似，包括標準化與 One-hot encoding。

模型架構：

• 卷積層 (Convolution)：兩層，選用 3*3 Kernel，Same padding。
• 池化層 (Max-pooling)：2*2 大小。
• 全連接層 (Dense)：由 4096 降至 1024，最後輸出 10 個類別。

可以觀察 Keras 與 TensorFlow 在參數表現與語法上的些微差异。

利用 pandas 建立混淆矩陣 (Confusion Matrix)，分析模型是否在特定類別間產生混淆。

從矩陣中可以看出：

• 第 3 類 (cat) 與第 5 類 (dog) 較容易混淆。
• 動物類與交通工具類之間區分得相當清楚。

兩層 CNN 準確率：0.732

My Github

相關文章

• Keras IMDb

k-NN 是監督式學習 (Supervised learning) 的一種，名稱非常簡明扼要，就是尋找「K 個最相近的鄰居」。

這個演算法在實作時，會找到附近 K 個最近的點，根據鄰居的類別來判斷自己要歸在哪一類。雖然它是監督式學習，但其實並不需要訓練模型參數，而是將所有訓練資料儲存起來進行即時對比。

我們可以藉由調整 K 的數值來增加演算法的 Noise Margin。然而，此演算法存在著儲存空間需求大（空間複雜度高）的問題，且容易受到數據不平衡的影響。

在實作上，核心在於計算點與點之間的距離。我使用了 Scipy 的函數來實作，為了方便觀察，先取 K=1，並將結果與 sklearn 的 KNN 進行比較。

實作思路是利用 for 迴圈計算每個測試資料與所有訓練資料的距離，並取最近者的類別作為預測結果。

準確率比較：

• sklearn knn : 0.9733
• 手刻 knn : 0.9467

My Github

想像人在思考或閱讀文章時，並不是從零開始，而是會保留過去的記憶。RNN 就是為了解決這方面的問題而設計的。

每次訓練時，網路會保留過去的訊息並持續傳遞。而 LSTM 則是一種特殊的 RNN 形式。

The Problem of Long-Term Dependencies

在許多情況下，我們需要更多的上下文訊息，但這些關鍵資訊可能距離當前時間點非常遙遠。一般的 RNN 在處理這種長距離依賴時，容易產生梯度消失或梯度爆炸的問題。

LSTM

LSTM 稱為「長短期記憶網絡」(Long Short Term Memory networks)，是一種特殊的 RNN 架構。

不同於傳統 RNN 在每個 Cell 裡只包含一個 tanh 層，LSTM 增加了：

• input gate (輸入門)
• output gate (輸出門)
• forget gate (遺忘門)

這些閘門都是用來精準控制資料的操作。使用 sigmoid 激活函數可以看做是控制記憶與讀取資料量的多寡：0 代表不通過，1 代表全部通過。

詳細的數學推導可以參考原文。文中也介紹了 GRU——一種更為簡煉高效的 LSTM 變體。值得注意的是，現今我們從 RNN 領域獲得的優異成果，幾乎指的都是 LSTM 的應用。

在 TensorFlow 中，LSTM 已經封裝完善，呼叫即可使用。

下圖是用 LSTM (紅虛線) 去學習黑線 (x*sin(x)) 的擬合結果：

使用豐原站的觀測記錄，將資料分為訓練集 (train set) 與測試集 (test set)：

• train.csv：每個月前 20 天的所有觀測資料。
• test_X.csv：從每個月剩下的 10 天中取樣。每筆資料包含連續 10 小時，以前九小時的所有觀測數據作為 Feature，預測第十小時的 PM2.5 濃度。一共取出 240 筆不重複的測試資料。

sklearn 在使用上非常直接。目前的策略是採用最基礎的方式：取出所有前九小時的值作為 Feature，不進行額外的特徵工程或化簡，直接觀察結果。

在 Private 排名約在中間，略高於 Baseline。

因為使用的是 Linear Regression，對 Gradient Descent 而言：計算一次斜率，直接就能找到解。

My Github

相關文章

• Kaggle Digit Recognizer
• Kaggle Titanic

The sinking of the RMS Titanic is one of the most infamous shipwrecks in history. On April 15, 1912, during her maiden voyage, the Titanic sank after colliding with an iceberg, killing 1502 out of 2224 passengers and crew. This sensational tragedy shocked the international community and led to better safety regulations for ships. One of the reasons that the shipwreck led to such loss of life was that there were not enough lifeboats for the passengers and crew. Although there was some element of luck involved in surviving the sinking, some groups of people were more likely to survive than others, such as women, children, and the upper-class.

In this challenge, we ask you to complete the analysis of what sorts of people were likely to survive. In particular, we ask you to apply the tools of machine learning to predict which passengers survived the tragedy.

從題目可以知道，這是一個 binary classification，最初想到 SVM 和 perception。

從題目給的數據，選擇 Decision Tree 或 Random Forest 可能是比較合理的想法。不過這邊我想用 Logistic Regression 來試試 (sigmoid + cross entropy)。

把訓練資料的內容全部都變成 0-1 的數字，剩下的就交給 NN 去解決。因為我們最後一層的 active function 是 sigmoid，為了避免梯度消失，因此在做 cross entropy 時把最大最小值定為 0.00001 和 0.99999，做每次的訓練時才不會有 Nan 的問題。

結果

Kaggle : 0.76555

分數只有這樣，大概有幾個地方需要檢討：

1. overfitting??：train 可以到 90% 但是 test 最高就是這數字。除了 overfitting，另外一個就是資料的考量，因為有故意捨去某些資料來做訓練，可能留下的在測試資料中反而是缺失的。
2. 解決 overfitting 的方式：選用 dropout 可能在這裡沒有比 regularization 還好，這需要調整。
3. 填補資料的方式：在空白資料上很多是填上零或者平均值，有些隱藏相關沒考慮到？
4. feature：最可能就是 feature 的問題了，因為在類似的作法下，使用 XGB 試過也沒有好多少，因此應該要嘗試其他表現方式。

原本想考慮好好用 Random Forest 和 XGB 認真做一次，想想應該真的是在 feature 上有問題；同樣用 Deep learning 來做的人，肯定也有做到非常高。

先邁入下個試題，希望回頭後有新想法。

My Github

相關文章

• Kaggle Digit Recognizer
• Kaggle PM2.5 Prediction

這是一個用 CSV 儲存的 MNIST 問題，因此選用 CNN 來解決。資料格式如下：

If we omit the “pixel” prefix, the pixels make up the image like this:

000 001 002 003 ... 026 027
028 029 030 031 ... 054 055
056 057 058 059 ... 082 083
 |   |   |   |  ...  |   |
728 729 730 731 ... 754 755
756 757 758 759 ... 782 783 

The test data set, (test.csv), is the same as the training set, except that it does not contain the “label” column. Your submission file should be in the following format:

ImageId,Label
1,3
2,7
3,8 
(27997 more lines)

The evaluation metric for this contest is the categorization accuracy. For example, a categorization accuracy of 0.97 indicates that you have correctly classified all but 3% of the images.

圖像化類似這個樣子；一個 28*28 黑白階的圖片。程式代碼和 MNIST 練習時代碼類似，額外加上了 CSV 的讀取與儲存邏輯。

Kaggle 分數：0.98614

使用了兩次卷積加上一層隱藏層，配上 SGD 優化，目前差不多就是這樣的結果。準備往下一個題目邁進。

My Github

相關文章

• Kaggle Titanic
• Kaggle PM2.5 Prediction

要在字詞中找到他們之間的某種關聯，而不只是分散無意義的符號代表。

做這個問題的核心概念是： 「假設兩個不同句子中的詞上下文相同，則代表兩個詞的語意相近。」

今天要來使用 skip-gram 模型，一個類似二元分類的方式 (判斷像或是不像)。一開始也同之前的問題，先做數據處理。

1. 計算出現數量：[(most count word1, n1), (second word2, n2)]
2. 文字轉成向量：

例如：The actual code for this tutorial is very short

生成的 skip-gram pairs 示意：

• ([the, code], actual), ([actual, for], code), …
• (actual, the), (actual, code), (code, actual), …

在這之間都會給他編號，轉化為 (10, 20), (10, 30), (30, 10), (30, 40) ... 的形式。

用到 nce_loss，目前我還不是非常熟練，概念上是讓目標詞的機率越高越好，並讓其餘 K 個負面樣本 (negative samples) 的機率降低。

經典案例： king - queen = man - woman ==> king - queen + woman = man

給 queen 加上負號，並取不要的值，我想是這種感覺吧？

結果

會把相似的詞分的近一些：

原版 tensorflow 範例有用上 sklearn 的 TSNE 來做降維，在很多地方都比 PCA 效果好。

My Github

系列文章

• TensorFlow 練習1：Polynomial Regression
• TensorFlow 練習2：CNN
• TensorFlow 練習3：FizzBuzz

從網路上看到的幽默問題，算是一個很有趣的使用，適合在做完 Classification 後練習。

輸入資料處理和原版程式碼一樣，因為還蠻直觀的：

• 1 – 000000001 – [0 0 0 0 0 0 0 0 1]
• 2 – 000000010 – [0 0 0 0 0 0 0 1 0]
• ………

輸出則是用 [1 0 0 0] [0 1 0 0] [0 0 1 0] [0 0 0 1] 來代表四個分類。

輸入輸出都是一個矩陣的形式。利用兩層 hidden layer 分別是 512 和 256，激勵函數選擇 relu，剩下的就交給 tensorflow 分類。

結果

一開始一直分不出來，都會卡在把每個資料都判定成同一類 (0.533)。後來減低每次訓練丟進去的量就 OK 了 (忘記一開始做分類時也只丟一點點進去)。

卡在 0.533 代表他受非 5 非 3 倍數的值影響很大，畢竟是機率最高的地方。也看成是 local minimum，要跳出去就是使用 batch。

這是有加入 0.8 dropout 的結果，可以看到訓練跟測試差不多，而且很快就達到 1.0 的準確率。

My GitHub

系列文章

• TensorFlow 練習1：Polynomial Regression
• TensorFlow 練習2：CNN
• TensorFlow 練習4：word2vec

輸入圖形是一個 2828 灰階 0~9 的數字。輸出是一個 110 的矩陣，代表預測 0~9 的機率分布。

流程如下： 輸入 – convolution – pooling – convolution – pooling – hidden layer – output

在代碼中用到 [None, xx, xx] 和 [-1, XX, xx]，代表我們忽略輸入的大小（batch size），它會跟隨著輸入自動改變。

max pooling 表示我們選擇的是那個 kernel size 裡的最大值。結構中也加入了 dropout 來避免 overfitting。

結果

上圖是沒有 dropout，下圖是有 dropout。就這個例子而言差別不大，但還是看得出來上面的訓練會比測試好。

準確率落在 97%~99% 之間 (1000 次訓練)。 （目前使用 GradientDescent，更換優化器應該會更好）。

My GitHub

系列文章

• TensorFlow 練習1：Polynomial Regression
• TensorFlow 練習3：FizzBuzz
• TensorFlow 練習4：word2vec

根據林軒田教授的機器學習基石課程，實作一下這個基礎的機器學習演算法。 我們探討的是監督式學習 (Supervised learning) 大架構下的二元分類 (YES/NO) 問題。

Perceptron ⇔ linear (Binary) Classifiers

我們有一組訓練資料 D，包含數據 Xn 和對應的 Yn (在這裡就是 1, -1)；Hypothesis set H 代表全部可能的解 (無限多條線)，經過演算法 A，從 H 找到一個可能的 g 與我們的目標函數 f 相近。

這個演算法的主要兩大步驟：找到錯誤的點，進行向量修正。 詳細課程可以參考教授的講解！！其中 naive cycle 是常用的作法。

這方法只適用於 linear separable PLA。

除此以外，當資料中有雜訊也無法使用這個方式，目前在線性問題上較好的解是用 Pocket PLA。

Linear separable PLA

首先整理一下資料。把原始格式如 ['x0\ty0\tz0\nx1\ty1\tz1\nx2\ty2\tz2\n....'] 轉換為 array([[(x0, y0), z0], [(x1, y1), z1], [(x2, y2), z2].....]) 的格式。

NAIVE PLA 實作，畫線則是用 ax + by = 0。

最終結果

Pocket PLA

Pocket PLA 是一個貪婪演算法，把最好的權重握在手上繼續往下算，每次都會比較看有沒有比手上的好。停止方式則是讓它運行一定次數，或是多久沒有變更好等等。這裡暫不詳述。

My GitHub

• "/cpu:0": The CPU of your machine.
• "/gpu:0": The GPU of your machine, if you have one.
• "/gpu:1": The second GPU of your machine, etc.

用 with tf.device() 來分配這個語句下使用的設備。

可以用以下設定來優化運算：

• log_device_placement = True: 紀錄我們使用 device 的情況。
• allow_soft_placement = True: 避免指定的 device 不存在，讓他能自行分配到存在且可運行的地方。

我沒有多顆 CPU，其他的語法先不試。

Nerual network 分析二維四次多項式

先定義輸入輸出格式，None表示我們不限制它的Row

在 Tensorflow 中，要定義它是常數、變數，或是從外部輸入，必須要分別指定成：

• tf.constant()
• tf.Variable()
• tf.placeholder()

他才會是那個形式；而想使用 Tensorflow 的任何內容，必須要用 sess.run() 去啟動它，不然會是 Tensor 的格式。

其中 sess = tf.Session()

定義一個 Y = W*x + b 的線性方程，在隱藏層中利用 activation function 去改變它。

評估模型好壞常用有 square error 和 cross_entropy，這裡利用 square error 計算 loss。

選擇基本的梯度下降並最小化 loss；optimizer 是個小於 1 的值。

設定要訓練的數值和函數 (記得要有一定的雜訊)

• W shape = (in_dim, hidden_units) = (10,1)
• predictions shape = (200,1)*(1,10)*(10,1) = (200,1)

訓練 1000 次每 50 次看結果：視覺化和數據化

placeholder 給資料會是一個字典的形式：

Session.run(*****, feed_dict={a:a_data, b:b_data, .....})

最後結果

My GitHub

系列文章

• TensorFlow 練習2：CNN
• TensorFlow 練習3：FizzBuzz
• TensorFlow 練習4：word2vec