<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by 追客 Fredrick Hong on Medium]]></title>
        <description><![CDATA[Stories by 追客 Fredrick Hong on Medium]]></description>
        <link>https://medium.com/@fredrick84823?source=rss-ef7f750e5ef6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*uF0JqY7YJ0WZGSuTeK0xJQ@2x.jpeg</url>
            <title>Stories by 追客 Fredrick Hong on Medium</title>
            <link>https://medium.com/@fredrick84823?source=rss-ef7f750e5ef6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 18:15:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fredrick84823/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[【Vibe Coding】Responsibly Vibe Coding]]></title>
            <link>https://fredrick84823.medium.com/responsibly-vibe-coding-9307a9295227?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/9307a9295227</guid>
            <category><![CDATA[spec-driven-development]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[coding-agents]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Fri, 08 Aug 2025 08:44:08 GMT</pubDate>
            <atom:updated>2025-08-08T09:15:34.830Z</atom:updated>
            <content:encoded><![CDATA[<h3>前言</h3><p>自從 ChatGPT 出來後，對於工作上寫 code 的幫助一直很有感，後續從起初在 ChatGPT 或 Claude 這類 UI 服務跟 AI 對話，把程式碼拼拼貼貼，一直到 Cursor (IDE)、Claude Code (CLI)，進化成 AI Agent 的工具，可以產程式碼、跑測試、寫文件、推 PR。軟體開發流程的改變真的是又大又快。</p><p>但當我們在開發流程中讓 AI 擁有越來越多決定權，當中必定會包含產生不好的影響，最被大家廣泛談論的就是「<strong>技術債</strong>」(Technical debt)。</p><p>備註：Technical debt（技術債）是指在軟體開發過程中，為了追求開發速度或節省成本，而選擇了快速但品質不佳的解決方案，導致未來需要花更多時間和資源來修正、重構或維護這些程式碼。</p><h3>正文</h3><h4>靈感</h4><p>上週末看到一部 youtube 影片，是 Anthropic 的 Technical Staff — Erik Schulntz 的演講，在談要怎麼用 Vibe Coding 的方式來開發 production 的產品，他提到的方法也有在 Claude 內部使用。</p><p>影片內容不長，但概念卻很實用，也再次提醒我使用 AI 工具來開發軟體時，必須以「負責任」的態度來實作。</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FfHWFF_pnqDk%3Fstart%3D1314%26feature%3Doembed%26start%3D1314&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DfHWFF_pnqDk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FfHWFF_pnqDk%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/00533f3dba8469c1dd31796b200f660d/href">https://medium.com/media/00533f3dba8469c1dd31796b200f660d/href</a></iframe><p>他提到的核心概念是，為了避免 Vibe Coding 產生的技術債，我們應該讓 Agent 專注在開發屬於葉節點（leaf node）的程式碼，而核心節點（core node）則仍需要工程師完全理解產生出來的程式碼。</p><h4>什麼是 葉節點（leaf node） 跟 核心節點（core node）？</h4><p>葉節點：獨立存在（下圖中橘色點）<br>核心節點：被其他節點依賴（下圖中白色點）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RJts86Oex_3Wl7RW6nhUTA.png" /><figcaption>From Vibe Coding in prod — Erik Schulntz, Member of Technical Staff at <a href="https://www.youtube.com/@anthropic-ai">‪@anthropic-ai‬</a></figcaption></figure><h4>實作方法</h4><p>Erik 提到我們應該讓 AI Agent 能夠完全自主性開發葉節點，只要我們做好測試（人工定義好輸入和預期的輸出）。至於核心節點，通常跟系統架構、設設計模式有關，現階段還是需要由工程師全面地理解這些程式碼。</p><p>影片中有舉一個例子，是 Claude 本身針對 RL codebase 提交了一個 22,000 行改動的 PR，這些改動就是用這種方式來產出的。他提到的另一個重點，我認為是他對團隊做的壓力測試很有信心，因此也更相信 AI Agent 產生出來的程式碼。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E_6TltkDbh1oXRVbn2wE6g.png" /><figcaption>From Vibe Coding in prod — Erik Schulntz, Member of Technical Staff at <a href="https://www.youtube.com/@anthropic-ai">‪@anthropic-ai‬</a></figcaption></figure><h4>實務上</h4><p>這週一上班時，我很興奮地把這種概念加入既有的工作流程中（<a href="https://github.com/CasJam">Brian Casel</a> 設計的一套跟 AI 協作的工具 <strong>agent-os</strong>），結果發現葉節點的數量出乎預期地少，大部分都是需要人工開發的核心節點，這樣的結果沒辦法提升太多效率。</p><p>所以我加入了另一個類別，並且讓 AI Agent 實作核心節點和這種類別的節點時，能夠擁有不同介入程度的模式。</p><p>下一篇再來介紹這個類別和改良後的工作流程！</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ivwwLZGT6pQnYeZJ2odABg.png" /><figcaption>From <a href="https://github.com/fredrick84823/agent-os-adaptive/blob/main/examples/agent-os-adaptive/architecture-analysis/node_classification.md">https://github.com/fredrick84823/agent-os-adaptive/blob/main/examples/agent-os-adaptive/architecture-analysis/node_classification.md</a></figcaption></figure><p>我目前的 AI 協作工具（改良自 agent-os）<br>歡迎有興趣的人可以安裝來玩玩看！</p><p><a href="https://github.com/fredrick84823/agent-os-adaptive/tree/main">GitHub - fredrick84823/agent-os-adaptive: Fork of https://github.com/buildermethods/agent-os with added leaf/core node classification. Core nodes require human review to prevent technical debt from vibe coding, while leaf nodes can be automated. Inspired by Erik Schultz&#39;s talk: https://youtu.be/fHWFF_pnqDk?si=lzHZFO4TNMKGP7As</a></p><p>目前剛把概念實現，還有很多細節需要修正才能達到理想中的效果。<br>因此很歡迎任何朋友給我回饋！希望能夠讓這套工具更接近想像中的效果。</p><blockquote>相關連結：<br>- agent-os-adaptive: <a href="https://github.com/fredrick84823/agent-os-adaptive">https://github.com/fredrick84823/agent-os-adaptive</a><br>- agent-os: <a href="https://github.com/buildermethods/agent-os">https://github.com/buildermethods/agent-os</a><br>- Vibe Coding in prod: <a href="https://www.youtube.com/watch?v=fHWFF_pnqDk">https://www.youtube.com/watch?v=fHWFF_pnqDk</a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9307a9295227" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【行銷資料科學】電商站內分群解析]]></title>
            <link>https://fredrick84823.medium.com/%E8%A1%8C%E9%8A%B7%E8%B3%87%E6%96%99%E7%A7%91%E5%AD%B8-%E9%9B%BB%E5%95%86%E7%AB%99%E5%85%A7%E5%88%86%E7%BE%A4%E8%A7%A3%E6%9E%90-5bf6636636f6?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/5bf6636636f6</guid>
            <category><![CDATA[user-segmentation]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[電子商務]]></category>
            <category><![CDATA[marketing]]></category>
            <category><![CDATA[rfm-analysis]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Sun, 14 Jan 2024 02:55:17 GMT</pubDate>
            <atom:updated>2024-01-14T02:55:17.928Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>隔了一年多沒有發表文章，主要原因是自己的惰性，加上工作中對深度學習模型的需求已經趨近於零，也少了去年很想挖掘神經網路知識的慾望。</blockquote><blockquote>取而代之的，是更多對於面向電商行銷端的思考，例如：除了模型預測找到高價值的用戶外，回歸到 rule-based 要怎麼有效將這群人區隔出來？又或者這幾年面對第三方數據即將消失的情況，越來越被重視的廣告歸因的議題…等等。</blockquote><blockquote><em>因此這篇是紀錄平時工作中的想法，也希望可以和更多人交流。</em></blockquote><blockquote><em>這次想討論的是，很多 CDP、CRM 系統都會有的 </em><strong><em>用戶分群</em> </strong><em>的功能，但什麼方式才是比較好區分用戶的規則呢？</em></blockquote><h3>前情提要</h3><p>對於<strong>「用什麼規則將用戶分群」</strong>才是比較好的方式，在討論這個問題之前，想先說明這篇不會涵蓋怎麼驗證的問題，並且假設我們手上握有的資料，是單一網站的會員資料。</p><h3>既有常見的規則</h3><h4>NAPL 與 DCIU</h4><p>上個月公司內部分享了一篇 91App 的文章：<a href="https://happylee.blog/rs/napl-x-dciu/">NAPL x DCIU ：會員模型的交乘應用</a>，也是看了這篇文章後，我才開始認真思考用戶分群的問題。</p><p>NAPL 是根據用戶的生命週期來區分的規則（以下說明取自<a href="https://happylee.blog/rs/napl-x-dciu/">這裡</a>）</p><ul><li>N (New) 首購：最近三個月有第一次購物的會員。</li><li>A (Active) 活躍：最近三個月內有購物的「非首購」會員。</li><li>P (Potential）潛在：超過三個月「沒有」購物的「非首購」會員，也就 A 標籤的人，超過三個月沒有再回購，就會從 A 變成 P。</li><li>L (Lost) 流失：超過三個月沒有回購的首購會員。也就是買過一次之後，本來是 N，但後來就沒有再買第二次了，超過三個月沒有回購，變成Ｌ。</li></ul><p>DCIU 是根據用戶的購買意願來區分的規則（以下說明取自<a href="https://happylee.blog/rs/napl-x-dciu/">這裡</a>）</p><ul><li>D (Deciding) 最高購買意圖：官網互動行為非常多，近期頻率高，且有大量加入購物車、編輯購物車等等的趨近最後購買旅程的行為。</li><li>C (Considering) 高購買意圖：官網互動行為多，但近期頻率不高，有加入購物車行為等。</li><li>I (Interesting) 低購買意圖：官網隨意瀏覽者。</li><li>U (Un-interesting) 無購買意圖：沒有任何官網互動行為的會員。</li></ul><p>NAPL 和 DCIU 的規則，其實各領域都可以自己重新設計，甚至上述 DCIU 所提到的官網互動行為，每個電商握有的使用者的互動事件可能就不太相同，只要透過合理的假設定義出規則，再上線比較各種組合後，相信可以找到一組最適合自己品牌的模式。</p><p>再退一部思考，DCIU 的概念，其實很像透過模型去預測用戶，在接下來的一段期間內是否會有購買行為的任務（Binary Classification），輸出是 0~1 之間的數值，這樣一來 DCIU 可以嘗試的組合又更多了。</p><h4>NAPL x DCIU 的交乘應用</h4><p>一般的行銷方式，都是某一個套規則將用戶分群後，直接做後續的應用，但如果把兩套規則所區分出來的各4組用戶交乘後，其實可以看到16種組合的應用，就能做到更細緻的受眾區隔，這件事情也是在上述 91App 的文章提到的。</p><h3>購買意願 VS 興趣傾向</h3><p>在做行銷時，大部分的人都理解，如果要長期提升品牌收益，除了找到最近對於有意願購買商品的人之外，長期經營對品牌有興趣的人（品牌忠誠度高），也是同樣重要的一件事情。</p><p>而上述的 NAPL x DCIU 就是屬於近期找到購買意願高的人，因此我認為我們還需要另一組能夠區隔出長期對品牌有興趣的規則，而當時的想法是將很有名的 RFM 再加上兩個指標，變成 RFM + S 來捕捉使用者對於品牌長期感興趣的程度。</p><h3>傳統 RFM</h3><p>傳統 RFM 的指標各自代表的意義</p><ul><li><strong>Recency</strong>：最近一次購買日期 與 <em>當天日期 </em>的差距</li><li><strong>Frequency</strong>：時間內購買事件次數</li><li><strong>Monetory</strong>：時間內購買總金額</li></ul><h4>自定義指標權重</h4><p>我們可以根據每個使用者的 RFM 三個指標，彈性地給予三個指標不同的權重，藉此來計算出每位使用者的最終指標。</p><p>假設我們比較在意使用者近期的活躍程度，則可以將 Recency 的權重調高。</p><p><em>最終指標 = 0.6* Recency + 0.2*Frequency + 0.2*Monetory</em></p><p>假設我們比較在意使用者消費跟購買頻率的金額，則可以將 Frequency 跟 Monetory 的權重調高。</p><p><em>最終指標 = 0.2* Recency + 0.4*Frequency + 0.4*Monetory</em></p><p>藉由計算出最終指標，我們可以了解到在會員名單 或 進站過的使用者中，哪些人是我們優先需要留住的客戶。</p><h4>分群</h4><p>除了可以自定義三個指標的權重外，我們可以直接將三個指標作為 feature，讓分群模型（最常見的 Kmeans）替我們分群。</p><p>例如我們讓模型將使用者區分成5群人，再分別將這5群人的三個指標的統計分佈拉出來觀察，可能會發現某一群的平均購買金額、平均購買次數最高、但最近一次購買時間離今天的日期比較遠。</p><p>這樣的數據代表這群人是很喜歡品牌商品，並且消費力比較大，但可能購買週期還沒到，又或者這群人的平均 Recency ，已經品牌的平均回購時間，則代表有其他因素影響這群人的購買意願，例如原本喜歡買的商品下架、商品價格調漲、折扣消失等等。</p><p>透過模型分群，我們不需要自定義三個指標的權重，但在各群使用者行為的解釋上，就需要事後觀察後才能解釋。</p><h3>RFM + S</h3><p>之前應該也有人也將 S 這個指標到 RFM 中，而我是想找到一套識別使用者長期價值的規則，因此將它加入到 RFM 中，並且在規則也有一些調整。</p><p>我的想法是，要了解一個人對於品牌的長期價值，<strong>會不會穩定地回購</strong> 是一項重要的指標。</p><p>因為 Frequency 評估的是使用者在時間區間內的購買次數，一個人可能在短期間內買了好幾次，但這時他可能剛開始認識這個品牌，忠臣度還不高，買了幾次之後，可能發現自己不是那麼喜歡，就轉向去購買其他品牌的商品。</p><p>為了避免上述情況，去評估關於「<strong>購買間隔天數</strong>」相關的指標就變得很重要。</p><ul><li><strong>Staybility</strong>：平均購買間隔天數 / 購買間隔天數標準差</li></ul><p>我們可以透過每位使用者 <strong>平均購買的間隔天數 </strong>跟 <strong>所有人購買間隔天數的標準差</strong>，來了解這位使用者的回購穩定度。</p><p>RFM + S 的流程如下</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hBSmpqCXLULeAv0PVWutyQ.png" /></figure><p>可以看到我把原本的 RFM 變成 FMS，將 Recency 當成前面的篩選條件，原因是我認為在判斷長期價值時，只要 Recency 還落在正常範圍內，Recency 的大小不應該影響到使用者長期價值，畢竟我們只要知道他一定會回購就足夠了。</p><p>因此我覺得只要設定一個門檻，這邊是選擇寬鬆一點的門檻，<em>2.5*標準差 + 平均值</em>，將已經沈睡的使用者排除掉。</p><p>接著再將以長期來看，仍然活躍的使用者，透過 Frequency、Monetory、Staybility 三個指標計算出長期價值（可以自定義指標權重 或 用分群模型來區隔受眾）。</p><p>如此一來，RFM + S 的規則比起原本的 RFM 規則，就不會發生因為回購週期還沒到（Recency 很低），但 Monetory 和 Frequency 都很高的用戶，最終指標被低估的情況。並且也透過 Stability 來評估用戶回購的穩定度。</p><h3>結論</h3><p>透過 NAPL x DCIU 找到短期對品牌有購買意圖的使用者，透過 RFM + S 找到長期對品牌有忠臣度的使用者，藉此可以根據這兩種規則找到的區隔受眾，變化出更多符合該群使用者需求的優惠、推播訊息、或是廣告。</p><p>以上就是前陣子對於用戶分群的一些想法，關於用戶分群的主題網路上有非常多討論，也很歡迎有人可以一起聊聊！如果喜歡我的分享，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5bf6636636f6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【李宏毅老師2021系列】自注意力機制 (Self-attention)]]></title>
            <link>https://fredrick84823.medium.com/%E6%9D%8E%E5%AE%8F%E6%AF%85%E8%80%81%E5%B8%AB2021%E7%B3%BB%E5%88%97-%E8%87%AA%E6%B3%A8%E6%84%8F%E5%8A%9B%E6%A9%9F%E5%88%B6-self-attention-b4cf8f9ff7d9?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4cf8f9ff7d9</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[深度學習]]></category>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Sat, 27 Aug 2022 13:12:10 GMT</pubDate>
            <atom:updated>2022-08-27T13:14:23.582Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>這個系列是在觀看李宏毅老師2021系列的筆記，希望能用更濃縮的方式將內容整理下來。</blockquote><blockquote>這次要介紹的是 Self-attention，影片有拆成上下兩集，但因為中間分開的地方有點突兀，所以我還是把筆記合併成一篇文章，有部分內容會省略，有興趣的人可以看影片，內容會更完整。</blockquote><p>此篇筆記來自此課程：<a href="https://www.youtube.com/watch?v=hYdO9CscNes&amp;t=1s">【機器學習2021】自注意力機制 (Self-attention) (上)</a> 、<br><a href="https://www.youtube.com/watch?v=gmsMY5kc-zw&amp;t=1381s">【機器學習2021】自注意力機制 (Self-attention) (下)</a></p><h3>前情提要</h3><p>Self-attention 是有名的 Transformer 裡面很重要的架構，影片會先從為什麼需要 self-attention 切入，介紹不同的任務類型，再帶到它的概念、架構與實際的算法。</p><p>後半段講解算法的地方，因為用文字不太好表達公式，可以看圖片或許更好理解。</p><h3>輸入是一堆向量</h3><p>前幾堂課程的介紹，輸入都是固定形狀的 vector，而輸出可能是一個數值 (Regression)，或者一個類別 (Classification)。</p><p>但當我們遇到更複雜的問題時 (自然語言)，輸入可能會變成一排向量，而且每次輸入的長度不一樣。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/934/1*RILX7SNNT3JpeqEnppbZbA.png" /><figcaption>圖1— 截圖自李宏毅老師課程</figcaption></figure><h3>舉例</h3><p>文字處理：在做自然語言的任務時，我們需要先將文字轉換成向量 (word embedding)，才能輸入到 model 裡面。<br>每個字串都是一個向量，因此一句話就會變成一排向量。</p><p>語音：在語音上會先取一個 window (frame)，然後用一個向量去表示某段時間的聲音 (25ms)，window 每次往右移動 10ms 直到語音結束。</p><p>Graph：一個 socail network 或者分子的結構都是 graph 的形式，每個節點都是一個向量，很多節點就是一堆向量。</p><h3>輸出的形式</h3><h4>每個向量都會對應到一個 label：Sequence Labeling</h4><ul><li>POS tagging：在文字處理上，詞性標註 (POS tagging) 就是這種類別的任務。</li><li>Social network graph：預測每個節點 (使用者) 是否會購買商品，也是這種類別的任務。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/944/1*RkRSfEpQwR5PqwBCKk-NSg.png" /><figcaption>圖2— 截圖自李宏毅老師課程</figcaption></figure><h4>一整個 sequence 只需要產出一個 label</h4><ul><li>sentiment analysis：判斷一整句文字是正面負面…等。</li><li>輸入語音，判斷這句話是誰講的。</li><li>輸入一個分子 (等於一個 graph)，判斷分子的親水性。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/937/1*wTy4wxTOM6mdczn7bKakxQ.png" /><figcaption>圖3 — 截圖自李宏毅老師課程</figcaption></figure><h4>機器自己決定要輸出多少 label：Seq2Seq</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*reY7pNr-Z7bOubAU4jYchA.png" /><figcaption>圖4 — 截圖自李宏毅老師課程</figcaption></figure><p>以下介紹 self-attention 的例子，都是第一種類型的任務類型。</p><h3>Fully-connected 的問題</h3><p>假設是詞性標註的任務，若直接用 fully-connected 來處理，會發現同樣文字在句子的前後，label 是不同的詞性。</p><p>I saw a saw，第一個 saw 是動詞，第二個 saw 是名詞，但對 fully-connected 來說這兩個 saw 是完全一樣的。</p><h3>FC 考慮鄰近的 data</h3><p>我們可以開一個 window，將鄰近的資料都考慮進來，或是更極端，直接開一個 window 涵蓋所有資料。</p><p>這樣的方式也確實會比原本的 fc 來得好，但因為我們的輸入是有長有短的，因此如果真的要開一個 window 涵蓋所有資料，那麼除了運算量很大之外，也容易 overfitting。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/945/1*cR9PGWEHpJv59rsv2jryjA.png" /><figcaption>圖5 — 截圖自李宏毅老師課程</figcaption></figure><h3>Self-Attention</h3><h4>概念</h4><ul><li>以 sequence labeling 的任務為例，輸入4個向量，輸出4個向量。<br>輸入向量可以是整個模型的輸入，也可以是某層 hidden layer 輸出的向量。</li><li>每一個輸出的向量，都是考慮過所有輸入向量後才得到的結果。</li><li>深藍色的輸入，通過 self-attention 後，會得到一個深藍色的輸出，以此類推。</li><li>接著在把有考慮整個句子的向量，丟到 fully-connected 去輸出我們想要的數值、類別。</li><li>如此一來，fc 就可以考慮到整組句子的資訊。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/905/1*-EM3Ths3ki3DJxldbzptzg.png" /><figcaption>圖6 — 截圖自李宏毅老師課程</figcaption></figure><p>self-attention 跟 fully-connected 重疊使用</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*8TVgi3zyknG791JGiJ_xzQ.png" /><figcaption>圖7— 截圖自李宏毅老師課程</figcaption></figure><h3>Attention is all you need</h3><p>Google 提出 Transformer 的架構，裡面最重要的 module 就是 self-attention (就像變形金剛裡的火種源)</p><p>其實在更早的 paper 就有出現過類似的架構，但在這篇文章裡面，才將 self-attention 發揚光大。</p><h3>Self-Attention 計算方式</h3><h4>Sequence labeling 的輸出 b1 如何產生？</h4><p>α1：表示輸入的 a1跟其他輸入向量之間的相關性，它會去考慮其他向量裡面，有沒有哪些資訊是 α1 輸出到 b1 會用到的。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*zel4EcfFwilyhDN1do8qUg.png" /><figcaption>圖8 — 截圖自李宏毅老師課程</figcaption></figure><h4>相關性怎麼計算？</h4><p><strong><em>有很多不同種做法，最常見的是 dot product。</em></strong></p><h4>Dot Product</h4><p>假設要計算 a1, a4 的相關性，就會將這兩個向量，分別乘上兩個不同的矩陣（wq, wk），得到 q, k 之後，再對 q, k 做 dot product，得到一個數值（α）。</p><h4>Additive</h4><p>同樣乘上兩個不同的矩陣，得到 w, k，但這邊是將它們串起來，過了一個 activation function (tanh)，再乘上一個矩陣後，得到一個數值（α）。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/927/1*pciOm1LxjO76-BtxHeDkew.png" /><figcaption>圖9— 截圖自李宏毅老師課程</figcaption></figure><p>接下來的解釋都是以 dot product 為主，transformer 也是用這種方式去計算相關性。</p><h3>Self-Attention 流程</h3><p><strong><em>計算 Attention Score</em></strong></p><p>剛剛提到的 q 被稱作 query，k 被稱作 key。<br>實際要算出 α1 時，需要分別去計算 a1 跟 a2, a3, a4 的相關性。</p><ol><li>因此我們會將 a1 乘上一個矩陣，得到 q1，a2 乘上一個矩陣，得到 k2，a3, a4 也分別乘上矩陣得出 k3, k4。</li><li>對 q1, k2 做 dot product 就可以計算出 α1,2，這個數字被稱作 attention score。</li><li>接著分別對 q1, k3、q1, k4 做一樣的事情，就可以得到 α1,3、α1,4。<br>實作時也會讓 a1 跟自己做關聯性，因此也會得到一個 α1,1。<br>這時候我們就有了 α1,1、α1,2、α1,3、α1,4。</li><li>接著會在過一層 activation function，最常見的是 softmax，但也可以用其他 function 替代。</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/952/1*K2QFN9vmxmtdnBE4-kYdew.png" /><figcaption>圖10 — 截圖自李宏毅老師課程</figcaption></figure><p><strong><em>計算 a1 的輸出 b1</em></strong></p><p>根據計算出來的 α，我們已經知道哪些輸入的向量，跟 a1 最有關係，接著要透過 attention score 來抽取 sequence 中重要的資訊。</p><ol><li>將 a1, a2, a3, a4 乘上一組新的矩陣（Wk），得到 v1, v2, v3, v4。</li><li>接著將 α1,1 乘上 v1, α1,2 乘上 v2，以此類推，最後加總起來得到 b1。</li></ol><p>因此誰的 attention score 比較大，也就是哪個向量跟 a1 的相關性比較大，就更會影響到 b1，而這樣的結果也符合我們的預期。</p><p>到這邊就完成了計算輸入一排向量 a1, a2, a3, a4，得到輸出向量 b1 的過程。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/963/1*7c2H9pZ2rHfg0FrYT0jsPg.png" /><figcaption>圖11— 截圖自李宏毅老師課程</figcaption></figure><p><strong><em>計算 b2, b3, b4</em></strong></p><p>跟計算 b1 的方式一樣，計算過程這邊就略過。<br>另外實際在運算時，b1, b2, b3, b4 是平行地被計算的。</p><h3>矩陣乘法的角度</h3><p><strong><em>Query<br></em></strong>在計算每個向量的 query 時，都需要先乘上一個矩陣（Wq）。<br>q1 = Wq * a1<br>q2 = Wq * a2，以此類推。</p><p>但我們其實可以將 a1, a2, a3, a4 當作一個矩陣（I），這個矩陣乘以 Wq 得到 q1, q2, q3, q4 這個矩陣（Q）。</p><p>所以可以寫成 Q = Wq * I。</p><p>Wq 就是機器需要學出來的一組參數。</p><p><strong><em>Key<br></em></strong>K = Wk * I</p><p><strong><em>Value<br></em></strong>V = Wq * I</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/948/1*09waZ2c_bJRWRDHouiHLCw.png" /><figcaption>圖12— 截圖自李宏毅老師課程</figcaption></figure><p><strong><em>Attention Score (對 Query, Key 做 dot product)</em></strong></p><p>α1,1= kT * q¹（T 是 tranpose）<br>α1, 2 = kT * q²，以此類推。</p><p>我們其實可以將 k1, k2, k3, k4 當作一個矩陣（k, row 是 k1, k2, k3, k4），乘上 q1 這個向量，而得到 α1 這個矩陣（α1,1, α1,2, α1,3, α1,4），代表著 attention score。</p><p>α1 = K * q1<br>α2 = K * q2</p><p>Attention Score 就可以被當作成兩個矩陣的相乘。</p><p>A = KT * Q<br>K 的 row 是 k1, k2, k3, k4，Q 的 column 則是 q1, q2, q3 ,q4。</p><p>因為 A 還會通過一個 activation function，所以用 A’ 來代表通過後的輸出。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*yEDI10oIEERdbBTMh-xVXA.png" /><figcaption>圖13— 截圖自李宏毅老師課程</figcaption></figure><p><strong><em>self-attention 的輸出：b</em></strong></p><p>我們可以將 v1, v2, v3, v4 是做一個矩陣（V)。<br>將 V 乘上剛剛算出來的 attention score 的結果（A’）。<br>就可以得到 B 這個矩陣，它的 column 是 b1, b2, b3, b4。</p><p>O = V*A’</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/938/1*lhG3lES6Q2mP6wbJzsUAdA.png" /><figcaption>圖14 — 截圖自李宏毅老師課程</figcaption></figure><h3>統整</h3><p>我們有一堆輸入的向量（I）。</p><ol><li>計算 Query, Key, Value<br>輸入向量（I）分別乘以上三種不同的矩陣（Wq, Wk, Wv），得到 Q, K, V（Query, Key, Value）。</li><li>計算 Attention Score<br>透過 K 的 transpose 乘上矩陣 Q，得到 A，並且通過 activation function (softmax or others)，得到 A’（Attention Matrix）。</li><li>計算輸出向量（O）<br>最重將矩陣 V，乘上矩陣 A’，就可以得到輸出矩陣 O。</li></ol><blockquote>雖然好像做了很複雜的操作，但其實只有 Wq, Wk, Wk 是需要透過訓練資料找出來的。</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/917/1*Pib5rZzIMvHPnkEzuo4BwQ.png" /><figcaption>圖15 — 截圖自李宏毅老師課程</figcaption></figure><h3>變形：Multi-head Self-attention</h3><p><strong><em>為什麼要用 multi-head？</em></strong></p><p>相關這件事情可能有很多種形式，可以把它想像成，為了要找到資料中不同種類的相關性，所以才會設定多個 multi-head 的 self-attention。<br>而需要用多少個 head，是一個 hyperparameter。</p><p>在語音辨識、翻譯等任務中，可能會需要用到比較多個 head。</p><p>假設 multi-head 設定為2，代表想要找到的相關性的種類有兩個，<br>因此 query, key, value 這些要學的參數也會有兩種。</p><p>影片中有稍微講解算法，但我這邊就先省略。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*8sjCFh6rcG6S8nJF9LOgYA.png" /><figcaption>圖16 — 截圖自李宏毅老師課程</figcaption></figure><h3>Position Encoding</h3><p><strong><em>self-attention layer 並不會考慮輸入向量的位置資訊。</em></strong></p><p>對於 layer 來說，當 a1 出現在第一個位置和最後一個位置是一樣的，因為都只是去計算 a1 和其他輸入的相關性。</p><p>若要加上位置資訊，可以在 ai 輸入到 self-attention layer 之前，先加上 ei 這個向量，ei 就代表著位置的資訊。</p><p>而怎麼產生 ei 向量有很多種方式，可以是統計出來的，也可以是透過機器學出來的，但這些方法都稱作 position encoding。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/931/1*jk3_8P24ND_ViWfHisskBg.png" /><figcaption>圖17 — 截圖自李宏毅老師課程</figcaption></figure><h3>結語</h3><p>因為將兩個影片的內容放在同一篇文章中，所以後面介紹 multi-head self-attention、position encoding、self-attention 的應用、與 cnn 的比較…等等內容，這邊就都省略掉了。</p><p>以上就是這堂課的筆記了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4cf8f9ff7d9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【李宏毅老師2021系列】類神經網路訓練不起來怎麼辦 (五)：批次標準化（Batch Normalization）簡介]]></title>
            <link>https://fredrick84823.medium.com/%E6%9D%8E%E5%AE%8F%E6%AF%85%E8%80%81%E5%B8%AB2021%E7%B3%BB%E5%88%97-%E9%A1%9E%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF%E8%A8%93%E7%B7%B4%E4%B8%8D%E8%B5%B7%E4%BE%86%E6%80%8E%E9%BA%BC%E8%BE%A6-%E4%BA%94-%E6%89%B9%E6%AC%A1%E6%A8%99%E6%BA%96%E5%8C%96-batch-normalization-%E7%B0%A1%E4%BB%8B-70448a10c543?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/70448a10c543</guid>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[深度學習]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Fri, 17 Jun 2022 14:09:27 GMT</pubDate>
            <atom:updated>2022-06-17T14:09:27.639Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>這個系列是在觀看李宏毅老師2021系列的筆記，希望能用更濃縮的方式將內容整理下來。</em></blockquote><blockquote><em>此篇如題所示，是針對深度學習中很常聽到的 Batch Normalization 做一個簡單的介紹。</em></blockquote><p>此篇筆記來自此課程：<a href="https://www.youtube.com/watch?v=BABPWOkSbLE&amp;list=PLJV_el3uVTsMhtt7_Y6sgTHGHp1Vb2P2J&amp;index=8">【機器學習2021】類神經網路訓練不起來怎麼辦 (五)： 批次標準化 (Batch Normalization) 簡介</a></p><h3>前情提要</h3><p>前面幾堂課，講了很多關於怎麼在 error surface 中找到 local minima，也就是找到一個 loss 相對小的 function。</p><p>我們也從前面的課程中，理解到在實務上要找到 local minima 不是件簡單的事情，因此這堂課要介紹的 Batch Normaliztion，也是一種為了讓模型更容易在訓練過程中尋找 loss 相對小的點，所使用的方式。</p><h3>Changing Landscape: 把山剷平</h3><p>前幾堂課發現，當 error surface 很崎嶇時，模型很難走到 loss 最小的那個地方，因此如果我們將 error surface 剷平，讓它不要那麼陡峭和崎嶇，訓練的過程就會比較容易，而 Batch Normalization 就是其中一種把山剷平的方法。</p><p>舉例來說，如圖1，當我們今天有兩個參數，w1 和 w2，當我們的 error surface 是一個碗的形狀時，就不見得很好訓練，因為 w1 對 loss 的斜率很小，w2 對 loss 的斜率很大。</p><p>因此如果用固定的 learning rate 去 optimize 參數，那麼就會很難走到圖中間 loss 小的區域，這也是為什麼需要前幾堂課介紹的 adaptive learning rate。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*19juzU7CS2embjrAT5Ufow.png" /><figcaption>圖1 — 截圖自李宏毅老師課程</figcaption></figure><h4>為何會產生這種 error surface？</h4><p>延續上面的舉例，當我們今天有兩個 feature 是 x1, x2，它們的權重是 w1, w2，而且這是一個 linear 的模型，沒有 activation function，因此我們的 function 就會是 y = w1x1 + w2x2 + bias，而我們的 label 是 y hat，訓練過程就是去 minimize y 和 y hat 之間的差距。</p><p>因此我們會持續地更新 w1, w2，下圖更新的權重以 Δ 代表。</p><p>當今天 x1 的 input 很小的時候，Δw1 就算改變很大，對於 loss 也不會有太大的改變，當 x2 的 input 很大的時候，Δw2 就算只改變一點，對於 loss 就會有明顯的改變。</p><blockquote><strong>對於一個 linear 的模型來說，當輸入的 feature 之間的 scale 差距很大時，就會產生這樣的 error surface。</strong></blockquote><blockquote><strong>因此當我們將不同 dimension 的 feature 都調整到相同的範圍中，error surface 就會變成圖片右邊那樣，比較容易訓練。</strong></blockquote><p>聽到這邊也解答了我剛踏入資料科學就有的問題：<strong><em>為什麼要做 feature normalization？</em></strong>通常在網路上很常看到的解釋是，因為線性模型對於數字的 scale 比較敏感，因此做了 normalize 之後會比較好訓練，而樹模型就比較沒有這種問題。</p><p>雖然結論都是一樣的，但這堂課用清楚地用 error surface 說明了線性模型對於 feature scale 敏感性的問題。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jwpNneMZrlz68mj0oLwbrw.png" /><figcaption>圖2 — 截圖自李宏毅老師課程</figcaption></figure><h3>Feature Normalization</h3><p>Feature normalization 網路上也有很多資源和公式，這邊介紹的其實是標準化，但老師說就統稱 normalization。</p><p>方式是當我們有一個 vector，裡面有 x1, x2, …, x10 個數值，我們就把這10個數值的平均值（mean）、標準差（standard deviation）算出來，將每個數值都帶入圖中的公式（xi 減去平均數再除以標準差），就會讓新的 vector 的平均數接近0，標準差為1。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EB3f5Wy9eo4R-F77_rtCpw.png" /><figcaption>圖3— 截圖自李宏毅老師課程</figcaption></figure><h3>Normalization in Deep Learning</h3><p>當我們已經對 input 的 feature 做完 normalize 之後，把它們輸入進去模型，首先會先經過 w1 得到 z1，z1會再經過 activation function (這邊舉例用 sigmoid，它是一個s曲線的 activation function)，得到 a1，然後才會進入下一層 layer。</p><p>雖然我們已經對 input 做完 normalize，但通過 w1後，得到的 z1 這組 vector 在不同維度上也有不同的 scale，就等於沒有做 normalize了，那麼我們要訓練 w2 可能就會很困難了，因此我們需要對 z1 做 normalization。</p><p>但這邊老師有特別提到，應該要對 z1 還是 a1 做 normalization？</p><p>答案是實作上影響可能不大，而也要看 activation function 是選擇用什麼來決定，如果跟舉例一樣是 sigmoid 的話，那麼在 z1 做的效果可能會比較好，因為 sigmoid 是一個 s 取線的 function，在0附近的斜率會比較大，因此我們在把 z1 輸入到 sigmoid 之前，就先做 normalization，讓數值縮放到0附近，那麼在計算 gradient 時的數值也就比較大。</p><p>但實際上在 hidden layer 很少用 sigmoid，因此實作上在 activation function 之前或之後的 normalization 並沒有太大的差別。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QN2xYnqrPGFPBHliifG5Vw.png" /><figcaption>圖4 — 截圖自李宏毅老師課程</figcaption></figure><h4>Batch Normalization 實際怎麼計算？</h4><p>我們其實就是將 z 視為一組 vector，然後對它們做上面所說的 normalization，過程都一樣，這邊就不再多解釋了。</p><p>然而要計算出 z1, z2, z3 的平均數和標準差，以例子來看是可行的，但當我們的 data 有上百萬筆資料，實作上就不太可行了，因為記憶體會爆掉。</p><p>因此 Batch Normalization 就出現了！假設 batch size = 64，那麼我們就只計算這 64 筆資料的平均數和標準差，對它們做 normalization，也因此這種方式適用於 batch size 比較大的訓練方式，因為 batch size 比較大，裡面的資料才比較有可能足以表示整個訓練資料的分佈。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WiIw6im13V-qNOFq84lDRA.png" /><figcaption>圖5— 截圖自李宏毅老師課程</figcaption></figure><h4>平均數是0的影響？</h4><p>當我們對 z 做完 normalization 之後，這組 vector 的平均數會接近於0，而有些人認為這樣會對 network 產生負面的限制，因此在做完 normalization 之後，會再將 z*y + β。</p><p>而 z 和 β 這兩個參數，是 network 去學習出來的，是有 gradient 的資訊的，這樣就可以讓 hidden layer 的輸出的平均不會是0。</p><p>通常在剛開始訓練時，z 的初始值是1，β是0，目的是為了不要讓做完 normalization 的 vector 的 scale 又變得不一樣，因為這樣就失去做 normalization 的意義。</p><p>因此初始值是 z=1, β=0，而到訓練後期，當 loss 走到一個相對平緩的地方，network 可以再加上z, β。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y0MRjbFzBBSutlYjX1-IeA.png" /><figcaption>圖6— 截圖自李宏毅老師課程</figcaption></figure><h4>實驗</h4><p>這邊拿了之前的論文裡的實驗，來證明 batch normalization 的效果，黑色虛線是沒有用 batch norm 的原始模型（Inception），其餘依序是做了1, 5, 30次的 batch norm，而粉紅色虛線想要表示的是，就算是用 sigmoid 當做 hidden layer 的 activation function，加上 batch norm 後，還是訓練得起來的。（實驗前面有實驗過沒有加入 batch norm，是訓練不起來的）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VG8c6FSgY7eAhQJ96Jm0eQ.png" /><figcaption>圖7— 截圖自李宏毅老師課程</figcaption></figure><h3>結語</h3><p>這堂課雖然短短的半小時，但收穫滿滿，除了了解 batch normalization 的運作方式之外，也很清楚地了解這麼做的原因，以及為何要做 feature normalization。</p><p>之後打算做一個簡單的實驗，去比較加入 batch norm 後對於 nn 的差異，期待順利產出了！</p><p>以上就是這堂課的筆記了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=70448a10c543" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【實務系列】練習用 Tensorflow 打造一個神經網路！]]></title>
            <link>https://medium.com/%E7%A8%8B%E5%BC%8F%E6%84%9B%E5%A5%BD%E8%80%85/%E5%AF%A6%E5%8B%99%E7%B3%BB%E5%88%97-%E7%B7%B4%E7%BF%92%E7%94%A8-tensorflow-%E6%89%93%E9%80%A0%E4%B8%80%E5%80%8B%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF-9ca637c176a5?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ca637c176a5</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[深度學習]]></category>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[tensorflow]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Fri, 03 Jun 2022 06:12:14 GMT</pubDate>
            <atom:updated>2022-06-11T01:58:23.996Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>去年剛踏入機器學習的領域時，就有想分享實務相關的文章，然而原本的計畫是想先把李老師2021的影片看完，再來提升 coding 方面的經驗。但依照目前的進度來看，李老師的影片看完今年也過完了，所以就兩邊一起進行了。</blockquote><blockquote>目前工作上使用 keras 其實就很夠用了，但最近因為種種因素，讓我想試試看 tensorflow、pytorch…等等其他框架。</blockquote><blockquote>我把自己練習的過程分享出來，一方面自己釐清每個步驟，另一方面也希望可以幫助到剛要入門的人。因為在找範例時，不知道是不是關鍵字打得不夠精準，找不太到中文的文章，所以這篇的範例是直接拿國外的範例來練習。</blockquote><p>此篇範例是完全按照底下這篇文章所練習的，只是多了一些對於程式碼的解釋：<a href="https://adventuresinmachinelearning.com/python-tensorflow-tutorial/">https://adventuresinmachinelearning.com/python-tensorflow-tutorial/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*oshTttMvN2Qw6UAD.png" /><figcaption>TensorFlow Logo From Wikipedia</figcaption></figure><h3>前情提要</h3><p>因為是要打造一個神經網路，所以程式碼基本上就是將神經網路的基本運作實現出來，只是在框架底下，可以省略很多底層的運算，但對於神經網路還是需要有基礎的認識。</p><h3>練習開始</h3><h4>第一步：匯入套件跟資料集</h4><p>先匯入需要的套件以及資料集，tensorflow 內建有手寫資料集可以用。</p><p>x_train.shape = (60000, 28, 28)<br>y_train.shape= (10000, 28, 28)<br>x_test.shape = (60000,)<br>y_test.shape = (10000,)</p><p>訓練資料是黑白的手寫圖片，像素非常低，因此只需要用 (28, 28) 就可以代表一張圖片。<br>從上面的 shape 可以得知，我們的訓練資料有6萬筆，測試資料有1萬筆。</p><p>我們要的目標是要讓神經網路能夠分辨手寫數字 0~9，因此這是一個 label 有10個的 multi-classification 的任務。</p><pre>import tensorflow as tf<br>import numpy as np<br>from tensorflow.keras.datasets import mnist</pre><pre>(x_train, y_train), (x_test, y_test) = mnist.load_data()</pre><h4>第二部：參數設定</h4><p>再來將訓練的參數設定好，並且將 data 的數值縮放到 0~1 之間（正規化），並將 x_test 轉換成 tensor object（才能餵進神經網路）。</p><p>這個步驟不一定要在這時候做，我目前的步驟是順著參考的範例做下來。</p><pre>epochs = 10<br>batch_size = 100<br>x_train = x_train / 255.0 # scaler to 0~1<br>x_test = x_test / 255.0 # scaler to 0-1<br>x_test = tf.Variable(x_test)</pre><h4>第三部：切分 batch</h4><p>在訓練網路時將訓練資料切分成小資料集的 batch，在模型的綜合評估上是優於把一整包訓練集丟下去訓練的，因此這邊先定義了一個切分資料集的 function，兩者的比較可以參考<a href="https://fredrick84823.medium.com/%E6%9D%8E%E5%AE%8F%E6%AF%85%E8%80%81%E5%B8%AB2021%E7%B3%BB%E5%88%97-%E9%A1%9E%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF%E8%A8%93%E7%B7%B4%E4%B8%8D%E8%B5%B7%E4%BE%86%E6%80%8E%E9%BA%BC%E8%BE%A6-%E4%BA%8C-batch-d36e9e9757dc">這篇李老師的影片筆記</a>。</p><pre>def get_batch(x_data, y_data, batch_size):<br>    idxs = np.random.randint(0, len(y_data), batch_size)<br>    return x_data[idxs,:,:], y_data[idxs]</pre><pre>x_data, y_data = get_batch(x_train, y_train, batch_size=100)<br>print(y_data.shape)<br>print(x_data.shape)</pre><p>(100, 28, 28)<br>(100,)</p><h4>第四部：打造神經網路</h4><h4>架構</h4><p>我們要打造的神經網路架構如下，非常簡單，只有三層 layer。<br>input layer：784 (28x28) 個神經元。<br>hidden layer：300 個神經元，activation function 選擇用 relu。<br>output layer：10 個神經元，activation function 選擇用 softmax (會讓輸出的結果總和為1，通常用在 multi-classification 的任務輸出層)。</p><h4>參數量</h4><p>一個神經網路的的公式可以簡化成：y = (Wx + b) * activation function，透過公式可以了解我們接下來要設定的 weights 和 bias 的數量。<br>input layer：0<br>hidden layer：784x300(weights) + 300(bias) = 235500<br>output layer：300*10(weights) + 10(bias) = 3010</p><h4>Tensorflow</h4><p>我們可以透過 tf.random.normal 來隨機創造一個常態分佈的矩陣，並且可以自行設定平均數 (mean) 跟標準差 (stddev)。</p><p>根據上面 weights, bias 的數量，所有的 weights 和 bias 就可以透過下面的程式碼創建出來。</p><pre>W1 <strong>=</strong> tf<strong>.</strong>Variable(tf<strong>.</strong>random<strong>.</strong>normal([784,300], stddev<strong>=</strong>0.03), name<strong>=</strong>&#39;W1&#39;)<br>b1 <strong>=</strong> tf<strong>.</strong>Variable(tf<strong>.</strong>random<strong>.</strong>normal([300]), name<strong>=</strong>&#39;b1&#39;)<br>W2 <strong>=</strong> tf<strong>.</strong>Variable(tf<strong>.</strong>random<strong>.</strong>normal([300,10], stddev<strong>=</strong>0.03), name<strong>=</strong>&#39;W2&#39;)<br>b2 <strong>=</strong> tf<strong>.</strong>Variable(tf<strong>.</strong>random<strong>.</strong>normal([10]), name<strong>=</strong>&#39;b2&#39;)</pre><ol><li>再來是定義網路的架構，首先必須先把 input data 攤平成784的形狀才能餵進網路中。</li><li>tf.matmul(a, b) 是讓 a, b 兩個矩陣相乘，且 a, b 兩個矩陣的資料型態必須相同。<br>tf.add(a, b) 是讓 a, b 兩個矩陣相加。<br>因此第二行的程式碼就是在實現 y = Wx + b 這件事情。</li><li>接著計算出 Wx + b 後，我們需要再用一個 activation function 做轉換。</li><li>然後輸出層再做同樣的事情一次。</li></ol><pre><strong>def</strong> nn_model(x_input, W1, b1 ,W2, b2):<br>    x_input <strong>=</strong> tf<strong>.</strong>reshape(x_input, shape<strong>=</strong>(x_input<strong>.</strong>shape[0], <strong>-</strong>1))<br>    <em># y = (Wx + b) * activation function</em><br>    x <strong>=</strong> tf<strong>.</strong>add(tf<strong>.</strong>matmul(tf<strong>.</strong>cast(x_input, tf<strong>.</strong>float32), W1), b1)<br>    x <strong>=</strong> tf<strong>.</strong>nn<strong>.</strong>relu(x)<br>    outputs <strong>=</strong> tf<strong>.</strong>add(tf<strong>.</strong>matmul(x, W2), b2)<br>    <em>outputs = tf.nn.softmax(outputs)</em><br>    <strong>return</strong> outputs</pre><h4>Keras</h4><p>上述是以 Tensorflow 來架一個 nn 的步驟，為了確定參數量設定得正確，這邊用 Keras 架了一個相同架構的 nn，來比較一下。</p><pre>input_layer = Input(shape=(784,), name=&#39;input_layer&#39;)<br>dense = Dense(300, activation=&#39;relu&#39;, name=&#39;hidden_layer&#39;)(input_layer)<br>output_layer = Dense(10, activation=&#39;softmax&#39;, name=&#39;output_layer&#39;)(dense)<br>model_ = Model(inputs=input_layer, outputs=output_layer)<br>model_.summary()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jNTor4jyyhBkXBBtQiVGOQ.png" /><figcaption>model.summary()</figcaption></figure><p>看起來參數量設定正確！</p><h4>第五部：定義 loss function</h4><p>範例使用了 Tensorflow 內建的給手寫辨識任務的 loss function，參數就是 label 和 predict outputs，當然也可以選擇用其他 loss function。</p><pre><strong>def</strong> loss_fn(outputs, labels):<br>    cross_entropy <strong>=</strong> tf<strong>.</strong>reduce_mean(tf<strong>.</strong>nn<strong>.</strong>softmax_cross_entropy_with_logits(labels<strong>=</strong>labels, logits<strong>=</strong>outputs))<br>    <strong>return</strong> cross_entropy</pre><h4>第六部：定義 optimizer</h4><p>上一篇分享李老師的文章，正好就是在介紹各種 optimizer，但這邊是直接用 keras 內建好的 Adam，省去一些功。若要自己寫出來，網路上也有蠻多中文的文章。</p><pre>optimizer <strong>=</strong> tf<strong>.</strong>keras<strong>.</strong>optimizers<strong>.</strong>Adam()</pre><h4>第七部：訓練網路</h4><p>訓練的過程是我認為範例所有步驟裡比較需要花時間理解的，如果覺得觀看範例還是有點抽象，可以把變數印出來觀察，對於理解或許會有幫助。</p><h4>前處理</h4><ul><li>total_batch 是在計算在一個 epoch 中需要跑幾次 iteration。</li><li>先將 avg_loss 在進行batch 的 iteration 開始前設定成0。</li><li>開始進行一次 batch 的訓練，首先先把資料集用先前定義的 function 切分成 batch。（get_gatch(x_train, y_train, batch_size=batch_size)）</li><li>再來需要將 batch_x, batch_y (ndarray) 轉換成 tensor 的物件才能順利餵進網路中。</li><li>並且需要將 batch_y (shape=(100,)) 做 one-hot (shape=(100, 10)) 才會符合網路輸出層的形狀。</li></ul><h4>餵進神經網路</h4><ul><li>GraidentTape 是一個能夠紀錄神經網路正向傳播的物件，輸入 loss 跟網路參數後，也能夠計算出梯度（gradient）。因為我基本上也是前幾天第一次看到這個東西，所以想了解的人建議可以看看<a href="https://www.tensorflow.org/api_docs/python/tf/GradientTape">說明文件</a>，或者網路上<a href="https://ithelp.ithome.com.tw/articles/10223779">其他文章</a>。</li><li>首先我們把 batch_x（100, 28, 28） 作為 input 輸入到 nn_model 中，可以得到 prediction(100, 10) 再把 prediction 跟 batch_y (100, 10) 放入 loss_fn 中，又可以計算出這個 batch 的 loss（一個數值）。</li><li>接著透過 tape.gradient，將 loss, weights, bias 數入進去，就可以得到 gradients，這行 code 是在計算 ∂L/∂W, ∂L/∂b（對 loss 和參數做微分）。</li><li>透過 optimizer.apply_gradients 可以直接透過反向傳播法（Backpropagation）來更新參數。</li><li>最後將 avg_loss 加上這次的 loss / total_batch。</li><li>到這邊一個 batch 就跑完了，總共跑了 total_batch 個 iteration 後，1個 epoch 就算完成。</li></ul><h4>驗證測試資料</h4><ul><li>在進行了 total_batch 個 iteration 後，我們再來驗證測試資料。</li><li>原本的範例僅計算測試資料的 accuracy，但我想模擬 keras 的訓練過程，因此也計算了訓練資料的 accuracy，以及測試資料的 loss。</li><li>計算 accuracy 的方式，兩種資料集我都用同樣方式進行。雖然再前面已經訓練過所有的訓練資料，到這個步驟再去預測一次不是好的做法，但目前我先這種方式來計算。</li><li>train_pred 是將測試資料全部餵進網路後所得到的輸出。</li><li>我們透過 tf.argmax 取得每一筆資料在10個種類中最大值的 index（用法跟 np.argmax 相同）。</li><li>train_max_idxs 是 tf.argax 輸出後的 tensor，因此需要轉換成 ndarray，才能跟 y_train 去比對。</li><li>當 a, b 都是形狀相同的 ndarray 時，a==b 會回傳一個相同形狀的 boolean 的矩陣，再用 np.sum 包起來後就可以得到所有 true 的 value。</li><li>測試資料也是用相同的方式來驗證。</li></ul><pre>total_batch <strong>=</strong> int(len(y_train) <strong>/</strong> batch_size)<br><strong>for</strong> epoch <strong>in</strong> range(epochs):<br>    avg_loss <strong>=</strong> 0<br>    <strong>for</strong> i <strong>in</strong> range(total_batch):<br>        batch_x, batch_y <strong>=</strong> get_batch(x_train, y_train,    batch_size<strong>=</strong>batch_size)<br>        batch_x <strong>=</strong> tf<strong>.</strong>Variable(batch_x)<br>        <em># batch_y.shape = (100,)</em><br>        batch_y <strong>=</strong> tf<strong>.</strong>Variable(batch_y)<br>        batch_y <strong>=</strong> tf<strong>.</strong>one_hot(batch_y, 10)<br>        <strong>with</strong> tf<strong>.</strong>GradientTape() <strong>as</strong> tape:<br>            pred <strong>=</strong> nn_model(batch_x, W1, b1, W2, b2)<br>            loss <strong>=</strong> loss_fn(outputs<strong>=</strong>pred, labels<strong>=</strong>batch_y)<br>        gradients <strong>=</strong> tape<strong>.</strong>gradient(loss, [W1, b1, W2, b2])<br>        optimizer<strong>.</strong>apply_gradients(zip(gradients, [W1, b1, W2, b2]))<br>        avg_loss <strong>+=</strong> loss <strong>/</strong> total_batch<br>    <em># validate training data</em><br>    train_pred <strong>=</strong> nn_model(x_train, W1, b1, W2, b2)<br>    train_max_idxs <strong>=</strong> tf<strong>.</strong>argmax(train_pred, axis<strong>=</strong>1)<br>    acc <strong>=</strong> np<strong>.</strong>sum(train_max_idxs<strong>.</strong>numpy()<strong>==</strong>y_train) <strong>/</strong> len(y_train)<br>    <em># validate testing data</em><br>    test_pred <strong>=</strong> nn_model(x_test, W1, b1, W2, b2)<br>    y_test_one_hot <strong>=</strong> tf<strong>.</strong>one_hot(y_test, 10)<br>    test_loss <strong>=</strong> loss_fn(outputs<strong>=</strong>test_pred, labels<strong>=</strong>y_test_one_hot)<br>    max_idxs <strong>=</strong> tf<strong>.</strong>argmax(test_pred, axis<strong>=</strong>1)<br>    test_acc <strong>=</strong> np<strong>.</strong>sum(max_idxs<strong>.</strong>numpy()<strong>==</strong>y_test) <strong>/</strong> len(y_test)<br>    print(f&quot;Epoch: {epoch<strong>+</strong>1}, loss={avg_loss:.3f}, , acc={acc:.3f}, val_loss={test_loss:.3f}, val_acc:{test_acc<strong>*</strong>100:.3f}&quot;)<br>print(&quot;Training complete!&quot;)</pre><ul><li>印出訓練結果</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*exYteemjLoLm-R20JV4Exg.png" /><figcaption>訓練結果</figcaption></figure><h4>附上完整程式碼</h4><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b90417e234d94ae5da9bbc3b6bdec3c3/href">https://medium.com/media/b90417e234d94ae5da9bbc3b6bdec3c3/href</a></iframe><h3>結論</h3><p>在練習的過程中，感覺其實是更踏實的，因為相較於 Keras 幾行程式碼就寫完建模跟訓練的步驟，這種方式讓人有種踏實感，也感覺是在實現之前課堂上看到的數學公式。</p><p>當然 Tensorflow 的優勢當然不只是這樣，因為較 Keras 更底層，因此在運算上也會更快速。而關於客製化的特性，我個人不認為 Keras 就沒辦法客製化神經網路，搭配 Tensorflow 來運用，反而更具有靈活性，但前提肯定是得熟悉兩項工具才有辦法用得靈巧。</p><p>若程式碼或觀念有錯誤歡迎告知，也希望這篇文章有幫助到想要入門 Tensorflow 的人！如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ca637c176a5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/%E7%A8%8B%E5%BC%8F%E6%84%9B%E5%A5%BD%E8%80%85/%E5%AF%A6%E5%8B%99%E7%B3%BB%E5%88%97-%E7%B7%B4%E7%BF%92%E7%94%A8-tensorflow-%E6%89%93%E9%80%A0%E4%B8%80%E5%80%8B%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF-9ca637c176a5">【實務系列】練習用 Tensorflow 打造一個神經網路！</a> was originally published in <a href="https://medium.com/%E7%A8%8B%E5%BC%8F%E6%84%9B%E5%A5%BD%E8%80%85">程式愛好者</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【李宏毅老師2021系列】類神經網路訓練不起來怎麼辦 (四)：自動調整學習速率 (Learning Rate)]]></title>
            <link>https://fredrick84823.medium.com/%E6%A9%9F%E5%99%A8%E5%AD%B8%E7%BF%922021-%E9%A1%9E%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF%E8%A8%93%E7%B7%B4%E4%B8%8D%E8%B5%B7%E4%BE%86%E6%80%8E%E9%BA%BC%E8%BE%A6-%E5%9B%9B-%E8%87%AA%E5%8B%95%E8%AA%BF%E6%95%B4%E5%AD%B8%E7%BF%92%E9%80%9F%E7%8E%87-learning-rate-ea673c2c45b3?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ea673c2c45b3</guid>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[深度學習]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Thu, 19 May 2022 13:16:35 GMT</pubDate>
            <atom:updated>2022-06-03T06:19:44.809Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>這個系列是在觀看李宏毅老師2021系列的筆記，希望能用更濃縮的方式將內容整理下來。</blockquote><blockquote>此篇主要會延續類神經網路訓練不起來怎麼辦（ 一）、（二）的課程內容，介紹過去到現在常見的 Optimizer。</blockquote><p>此篇筆記來自此課程：<a href="https://www.youtube.com/watch?v=HYUXEeh3kwY">【機器學習2021】類神經網路訓練不起來怎麼辦 (三)：自動調整學習速率 (Learning Rate) — YouTube</a></p><h4>前情提要</h4><p>在（一）的課程中，老師介紹了在訓練神經網路的過程中，當 loss 不再下降，參數不再更新時，稱之為 critical point。</p><p>Critical point 又可以區分成 local minima 以及 saddle point。<br>Local minima：局部 loss 最小值。<br>Saddle point：非 local minima 也非 local maxima。</p><p>當我們處於 local minima 時，或許能夠接受訓練結果。但當我們處於 saddle point 時，代表我們的 loss 還有很多優化空間。</p><p>而 Hessian 是一種能夠判斷我們所在的 critical point 是屬於 local minima 還是 saddle point 的方式，並且也能夠作為逃離 saddle point 的方式，可是計算 Hessian 的運算量太大，因此並不是最好的方式。</p><p>在（二）的課程中，老師介紹了 Momentum 這種 optimizer，它是另一種能夠逃離 saddle point 的方式。</p><p>這堂課則是要來介紹除了 Momentum 以外的其他 optimizer，接著就開始進入課程筆記吧！</p><h3>Error Surface is rugged …</h3><p>前言：Critical Point 不一定是實際在訓練 network 時，會遇到的最大的障礙。 <br>今天要介紹的 Adaptive Learning Rate，是要給予每一個參數不同的 learning rate 的更新方式。</p><h3>Training Stuck = Small Gradient ?</h3><ul><li>loss 不再下降的時候，我們會以為走到了 critical point，然而去確認 gradient 卻發現 gradient 並沒有等於0。（norm of gradient = g 向量的長度）</li><li>當我們卡在下圖左方的山谷中，而我們的 learning rate 沒辦法讓我們逃離山谷，gradient 就會在山谷中不斷地震盪，loss 則不會再下降，因此這種情況就不是走到了 critical point（critical point 的 gradient = 0）。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/643/1*ZZpw_XuBPXj7nyDm9iRHZg.png" /><figcaption>圖1 — 截圖自李宏毅老師課程</figcaption></figure><h3>Wait a minute …</h3><ul><li>前幾堂課在介紹 critical point 時，有用下圖作為介紹，但其實這張圖的 network 並不是用 gradient descent 的優化方式去更新參數的，因為通常用 gradient descent 會遇到的問題，並不是 critical point。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*OVMm7ogvElUePV16wwS-SA.png" /><figcaption>圖2 — 截圖自李宏毅老師課程</figcaption></figure><h3>Training can be difficult even without critical points</h3><ul><li>接著用只有兩個參數（w, b）的 model training 的 error surface 來舉例，黃色叉叉是 loss 的最低點，黑點是參數的起始位置。</li><li>當 learning rate = 10的-2次方，gradient 會在山谷中間不斷震盪，gradient 實際上還是有在更新，但 loss 這時候不會再下降了。</li><li>learning rate 決定更新參數時的步伐有多大，因此再將 learning rate 調小。</li><li>當 learning rate = 10的-7次方，gradient 終於不再震盪，但卻永遠也走不到 loss 最低點的位置，因為 learning rate 已經太小了。</li></ul><blockquote><strong>因此我們需要更好的 gradient descent 的版本：客製化 learning rate。</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*Is1a52-PDxvsY5KuyXPcBg.png" /><figcaption>圖3— 截圖自李宏毅老師課程</figcaption></figure><h3>客製化：Different parameters needs different learning rate</h3><h4>怎麼客製化？</h4><ul><li>從 error surface 可以知道，當我們往某個方向，處在在平坦的區域，會希望 learning rate 設定得大一點，往另一個方向，處在在陡峭的區域，會希望 learning rate 設定得小一點。</li><li>公式 (以時間點 t、第 i 個 iteration 的參數 θ 為例)</li><li>原本的在時間點 t+1 的參數等於下方圖片的公式</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/100/1*O9O5499dBQEsBGxJ2se4CQ.png" /></figure><ul><li>為了要客製化，我們讓 η 除以另一個參數 σ（下圖最下方紅框的參數），這個參數會依賴於 i，也會依賴於 t。</li></ul><blockquote><strong>而後續的 optimizer 也是調整計算 σ 的方式而有所不同。</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/844/1*Su8o4iCykLHvFWwkulXGEA.png" /><figcaption>圖4— 截圖自李宏毅老師課程</figcaption></figure><h3>σ 常見的計算方式</h3><h4>Root Mean Square (RMS)</h4><ul><li>先上參數更新的公式</li><li>在這種方式底下， σ = gi⁰ 的絕對值，因此第一次參數的更新其實是看 learning rate 是多少。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/205/1*N9kEDC7aHOO5ble4gFvUbQ.png" /><figcaption>計算第一個 iteration 後的參數更新</figcaption></figure><ul><li>重點在於，第二次的參數更新，是加總過去 gradient 的平方再開根號。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/499/1*scPPF5PyNbrTHX8GJa19ag.png" /><figcaption>計算第二個 iteration 後的參數更新</figcaption></figure><ul><li>以此類推。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*Khxc-ONdBF9x3Yjabg2SJQ.png" /><figcaption>圖5— 截圖自李宏毅老師課程</figcaption></figure><h4>Adagrad</h4><p>RMS 計算 learning rate 的方式，被用在 Adagrad 這種 optimizer 上。</p><ul><li>當我們遇到平坦的區域，gradient 會比較小，也因此 σ 就會比較小，而因此 σ 在分母，因此整體 learning rate 就會變大。</li><li>當我們遇到陡峭的區域，gradient 大，σ 大，learning rate就會變小。</li></ul><h3>但是！</h3><blockquote><strong>我們有時候還是會希望，即使參數是往同樣的方向更新，learning rate 也是能夠動態地調整，因此 RMSProp 就出現了。</strong></blockquote><h3>RMSProp</h3><p>參數更新方式與 Adagrad 類似，不同的是 σ 的計算方式。</p><ul><li>第一步與 RMS 相同，如下圖。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/157/1*1raSGTVKdmD2tOsXDJzpQA.png" /><figcaption>第一個 iteration 更新參數</figcaption></figure><ul><li>第二步 σ 公式，如下圖</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/307/1*Kc3YGttT--lCVwVKDI8-Ew.png" /><figcaption>第二個 iteration 更新參數</figcaption></figure><pre>* 第二步，我們可以自行決定 gradient 有多重要，α 是一個 hyperparameter，如果覺得第二次的 gradient 比第一次重要，那麼 α 就設定得小一點 (0 &lt; alpha &lt; 1)。</pre><pre>* 第二步 σ 公式：α 先乘上上一次的 σ 的平方，再加上 1 — α 乘以這次 gradient 的平方，再開根號。</pre><pre>* 以此類推。</pre><pre>* 因此就像給予上一次 gradient 和這一次 gradient 權重一樣，σ 設定得越小，這次 gradient 的權重就越大。</pre><ul><li>完整公式可參考下圖</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/710/1*Ix4QSybzLmDAbUAcK8mzmw.png" /><figcaption>圖6 — 截圖自李宏毅老師課程</figcaption></figure><h4>RMSProp 的優勢</h4><ul><li>以 error surface 來解釋的話，我們會沿著下圖黑線（error surface）更新參數。</li><li>處在下坡前，這時候的 gradient 很小，而計算出來的 σi 也會很小， 因此下一步要更新的步伐就會很大（ σi 是分母）。</li><li>在下坡中，如果以 Adagrad 來更新參數的話，它的反應會比較慢，但如果我們用 RMSProp，把 α 設定得小一點，也就是讓剛看到的 gradient 權重較重，就可以很快地讓 σ 的值變大，讓更新的步伐變小，才不會導致更新步伐太大，整個噴出去。</li><li>沒有 α 的話（Adagrad），更新的步伐就是一個值很大的 σ 乘上一個值很大的 gradient，更新的步伐就飛出去了。</li></ul><blockquote><strong>RMSProp 在下坡時的優勢，在於可以透過調整 α 來踩煞車，讓更新的步伐不至於噴出去。</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/593/1*05-s9WZonPxZllJMyIZsGw.png" /><figcaption>圖7— 截圖自李宏毅老師課程</figcaption></figure><h3>Adam: RMSProp + Momentum</h3><p>對於現在最常用的 Adam，老師先是說明它是 RMSProp 和 Momentum 的綜合版，以及通常用預設的 hyperparameter 效果通常會比較好，其他並沒有再多做介紹。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/857/1*zM6egweVzonoft0r3HqfMg.png" /><figcaption>圖8— 截圖自李宏毅老師課程</figcaption></figure><h3>比較有沒有使用 Adaptive Learning Rate 的差異</h3><ul><li>下圖的上面兩張圖是純粹用 gradient descent 來優化參數，且 learning rate 分別是 10的-2次方跟10的-7次方。</li><li>下圖的最下面那張圖則是用 Adagrad 作為 optimizer 來更新參數。</li><li><strong>當參數更新到右上角的黑色點時</strong>，因為這時候左右兩旁的 gradient 很小，因此 Adagrad 會自動調大 learning rate，讓參數可以繼續往右更新。</li><li><strong>但當我們繼續往左邊更新參數</strong>，會發現 gradient 一直都很小，而 α 就是根據過去的 gradient 加總的平方再開根號，而 α 又是位在分母，因此累積到一定的程度後，learning rate 就會變得很大，導致參數更新的幅度太大，黑色點才會劇烈地上下晃動。</li><li>同樣道理，當參數噴出去之後，又會修正回來，然後再累積一陣子，又會再噴出去一次，然後再修正，直到走到 local minima。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/561/1*iuaoiiXgRJxiu2rbsxDN7A.png" /><figcaption>圖9— 截圖自李宏毅老師課程</figcaption></figure><h3>如何解決參數噴來噴去的問題：Learning Rate Scheduling</h3><p>下一步要更新的 θ 公式如下圖。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/153/1*huMsPyFQ-D5tm-x5yACJmQ.png" /></figure><p>剛剛介紹的 optimizer 都是變換 σ 的計算方式，來解決更新參數會遇到的問題。</p><blockquote><strong>但在這邊，我們則是讓原本是一個固定的數值 η ，變成一個會隨著時間而改變的參數。</strong></blockquote><h4>Learning Rate Decay</h4><ul><li>是 Learning Rate Scheduling 最常見的方式，顧名思義是一種隨著時間減少 learning rate 的方式。</li><li>這種方式是合理的，因為隨著我們越接近想要的終點，讓更新參數的速度慢下來，踩一個煞車。</li><li>套用到剛剛的例子中，就不會有 loss 亂噴的情況了，訓練過程也就更加穩定。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/852/1*iFCd4c6Bq8vQgFHpxTXFUA.png" /><figcaption>圖10 — 截圖自李宏毅老師課程</figcaption></figure><h4>Warm Up</h4><ul><li>Learning Rate 先變大再變小。（訓練 Bert 會被拿來用，但並不是有 Bert 之後才有 Warm Up，其實在2015年的 Residual Network 中就出現過了）</li><li>黑科技：會在一些 network 中發現 optimizer 會加入 warm up 來訓練，但論文並沒有解釋為什麼，包含知名的 Transformer。至於為麼麼在某些 network 中需要使用這種技術，老師認為還沒有被完全地解釋清楚。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*LL56VizaVWxmc3qAXUzyfQ.png" /><figcaption>圖11— 截圖自李宏毅老師課程</figcaption></figure><h4>為什麼 warm up 要這樣設計的一種解釋</h4><ul><li>在使用 Adam, RMSProp, Adagrad 的時候，<strong>公式中的 σ 是一個統計的結果</strong>，這個參數告訴我們某個方向有多陡峭或多平滑，但它看得資料要夠多，這個統計才會足夠精準。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/149/1*isBwG4OwBfU-3PGlLNxYmA.png" /><figcaption>參數更新公式</figcaption></figure><ul><li>因此剛開始更新參數時，統計是不精準的，所以我們不能讓我們的參數走的離初始的地方太遠，因此 η<strong> </strong>才會先從小變大，讓前期的優化比較像是在探索或蒐集 error surface 的情報，等到 σ 資料看得夠多，足夠精準後，我們再將 η 調大。</li><li>關於 warm up 的更多解釋，可以參考 RAdam 這個 optimizer。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/686/1*BnfeqQB_ebio7xZ1R-gzzw.png" /><figcaption>圖12— 截圖自李宏毅老師課程</figcaption></figure><h3>Summary of Optimization</h3><ul><li>(Vanilla) Gradient Descent (一般版本)</li><li>這一步的參數減去 gradient 乘上 learning rate，就會得到下一步的參數。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/101/1*dtfws0K4etQrp0sJ2FquMA.png" /><figcaption>Vanilla Gradient Descent</figcaption></figure><ul><li>Various Improvements</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/125/1*NFl9J32qiO9HJGtPkBIlbw.png" /><figcaption>Various Improvements</figcaption></figure><ul><li>m (Momentum)：就是加上 m 這個參數，m 是將過去的 gradient 加總起來，因此有考慮到參數更新的方向性。</li><li>σ (Adagrad)：除了 m 之外，還會加上 σ 這個參數， σ 同樣會考慮過去所有的 gradient，但因為它使用 RMS (Root Mean Square) 的方式去計算，因此只考慮 gradient 的大小，但沒有考慮方向性（會先將過去所有的 gradient 乘以二次方，也就是平方和，除以 gradient 的數量）。</li><li>η ：最後是將調整 η 這個參數，讓它隨著時間而改變。</li></ul><h4><strong>現今最常用的 optimizer 是 Adam，但其實也有很多變形，而變形的方式，就是去調整 m, σ, η，這三個參數的計算方式。</strong></h4><h3>結語</h3><p>這堂課程的影片雖然時間很短，但把常見的 optimizer 都仔細地介紹完畢，內容非常地充實。</p><p>以上就是這堂課的筆記了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ea673c2c45b3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【李宏毅老師2021系列】類神經網路訓練不起來怎麼辦（三）：Batch]]></title>
            <link>https://fredrick84823.medium.com/%E6%9D%8E%E5%AE%8F%E6%AF%85%E8%80%81%E5%B8%AB2021%E7%B3%BB%E5%88%97-%E9%A1%9E%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF%E8%A8%93%E7%B7%B4%E4%B8%8D%E8%B5%B7%E4%BE%86%E6%80%8E%E9%BA%BC%E8%BE%A6-%E4%BA%8C-batch-d36e9e9757dc?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/d36e9e9757dc</guid>
            <category><![CDATA[深度學習]]></category>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Sat, 30 Apr 2022 11:54:08 GMT</pubDate>
            <atom:updated>2022-04-30T12:05:03.044Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>這個系列是在觀看李宏毅老師 2021系列的筆記，希望能用更濃縮的方式將內容整理下來。</em></blockquote><blockquote><em>此篇講解的概念是在訓練深度學習網路中，可以調整的一種參數 (hyperparameter)：batch size，也是我覺得實務上很有價值的一個觀念。</em></blockquote><blockquote><em>若對於實驗的過程沒有興趣，可以直接跳到總結看 large batch 跟 small batch 在各個面向比較的結論。</em></blockquote><p>此篇筆記來自課程的前半段：<a href="https://www.youtube.com/watch?v=zzbr1h9sF54">【機器學習2021】類神經網路訓練不起來怎麼辦 (二)： 批次 (batch) 與動量 (momentum) — YouTube</a>。</p><p>同樣因為 notation 的關係，如果想看比較美觀的版本也可以直接看 notion 的筆記版本：<a href="https://quixotic-revolve-92a.notion.site/Tips-for-training-Batch-and-Momentum-cfcbead0a7a040dab13a5802f3ed2e05">https://quixotic-revolve-92a.notion.site/Tips-for-training-Batch-and-Momentum-cfcbead0a7a040dab13a5802f3ed2e05</a></p><h3>Review: Optimization with Batch</h3><p>開頭老師先介紹 batch 實際上是怎麼樣計算 gradient，並沒有先說明為什麼要使用 batch 來訓練 network。</p><ul><li>我們實際上在算 gradient 的時候，並不是對所有 data 算出來的 loss 做微分，而是將整個 data 拆分成一組一組的 B (batch or mini batch)，然後對每一組的 data 重複做以下動作。</li></ul><pre>* 圖中 θ = theta、g = gradient、L = loss</pre><pre>* pick initial values theta⁰：選定特定一組參數 theta⁰計算。</pre><pre>* 計算 g⁰：把 theta⁰ 這組參數放入 L 中得出 L¹，對 L¹ 做微分，就會得到 g⁰。</pre><pre>* 計算 g¹ , g², …。</pre><ul><li>1 epoch：把所有的 batch 都看過一遍</li><li>實際上在 training 時，每一個 epoch 我們會做 shuffle (有不同方式)，助教在作業做的shuffle，是讓每個 epoch 的每組 batch 的 data 都不一樣。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/894/1*nozFrhHw3ZMaqWOlUMbIJw.png" /><figcaption>圖1 — 截圖自李宏毅老師課程</figcaption></figure><h3>Why should we use Batch?</h3><blockquote><strong>Small Batch v.s. Large Batch</strong></blockquote><h4><strong>Error Surface</strong></h4><ul><li>以 Error Surface 來觀察 training 時 L 的變化 (藍色 loss 小，紅色 loss 大)</li><li>假設 training data 有20筆</li><li>左側 Batch size = Full Batch，因此 model 要看完20筆 data 才會更新參數。</li><li>右側 Batch size = 1，因此 model 每看完1筆 data 就會更新一次參數，在一個 epoch 中總共會更新20次，更新速度快但雜訊較多。</li></ul><blockquote><em>小結 (一)：Large Batch 的技能cd長，但威力較大，Small Batch 的技能cd短，但雜訊較多。</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z8cZPB5Nloq-48au4GS0KQ.png" /><figcaption>圖2— 截圖自李宏毅老師課程</figcaption></figure><h4>But Actually …</h4><p>打臉剛剛的小結，平行運算時，Batch size 較大不一定需要比較長的時間去計算 gradient。</p><ul><li>圖3 用 MNIST 的手寫圖片的任務來測試</li><li>當 Batch size 小於1000時，所需要的時間幾乎是一樣的，但超過1000時，還是會有它的限制。（此情況是使用 Tesla V100 GPU 的測試結果）</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S9X4BwI_Elp_xWNlCIfc3Q.png" /><figcaption>圖3 — 截圖自李宏毅老師課程</figcaption></figure><ul><li>圖4 左側講的是更新一次參數所需要花費的時間，右側是跑完一個 epoch 所需要的時間，可以看到 batch size 越大，跑一次 epoch 的時間越少。</li></ul><blockquote><em>小結 (二)：在使用GPU的情況下，大的 batch size 速度快而且學習得夠穩定，完勝小的 batch size。打臉小結 (一)</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P8R-2dg3A0tcswcMC5b1Qg.png" /><figcaption>圖4 — 截圖自李宏毅老師課程</figcaption></figure><h4>Small Batch Advantage</h4><p>課程看到看到這邊會覺得，只要硬體規格足夠，batch size 調得越大越好，但這時老師又接著介紹 small batch 有什麼優勢。</p><p><strong>優勢 (一)：Accuracy 表現較好 (參考圖5)</strong></p><ul><li>如前面所提到的，使用小的 batch size 時訓練的 $L$ 看起來雜訊比較多，然而這些雜訊竟然可以提升 model 預測的準度。（MNIST、CIFAR-10 都是圖片辨識的任務）</li><li>因為是在同一種 model 下測試不同 batch size 的結果，因此不會是 model bias 的問題，這是 optimization 的問題。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a3bqbiVpJb3xgOsa2v1QOA.png" /><figcaption>圖5 — 截圖自李宏毅老師課程</figcaption></figure><p><strong>解釋優勢 (一)：為什麼 small batch size 訓練出來的 model 準度比較高呢？</strong></p><p>一種解釋的方式 (參考圖6)</p><ul><li>Full Batch 的 training，會根據 loss 透過 gradient descent 優化，當我們遇到 critical point 時，gradient = 0，參數不再更新，若不透過 Hessian 或其他方式，optimization 就會卡住。</li><li>Small Batch 的 training，同樣也會卡在 critical point，但因為 small batch 有多組不同的 loss，因此訓練出來的準度反而比較高。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7v0dEx5HGde9uqmNum_lcQ.png" /><figcaption>圖6 — 截圖自李宏毅老師課程</figcaption></figure><p><strong>優勢 (二)：Small Batch 在 testing data 表現更好 (參考圖7)</strong></p><ul><li>這篇論文的實驗結果是，不管是 small batch 或 large batch 的 training accuracy 都表現得一樣好，但是在 small batch 在 testing accuracy 的表現優於 large batch。</li><li>也就是說 large batch 會有 overfitting 的問題。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ak3q5YybnyNOa0Na-nCXiA.png" /><figcaption>圖7 — 截圖自李宏毅老師課程</figcaption></figure><p><strong>解釋優勢 (二)：為什麼 small batch 比較不容易 overfitting？(參考圖8)</strong></p><p>Flat Minima (good minima) and Sharp Minima (bad minima)</p><ul><li>一個 training 的 loss 可能會有很多 local minima，有分好或壞的，平坦的比較好，陡峭的比較不好。</li><li>假設今天的 testing data 的 loss 是 training data 的 loss 往右偏一點，那麼平坦的 minima 在 testing data 的表現會跟 training data 差不多，而陡峭的表現則會差距很大。（實際上的testing data 可能因為 label 的分佈跟 training data 不同，導致兩者的 loss 也不相同）</li></ul><p>一種解釋方式（並非每個人都認同，尚待研究）</p><ul><li>Small Batch 比較容易卡在 Flat Minima，Large Batch 容易卡在 Sharp Minima</li><li>直覺的想法是，small batch 參數更新的方向很多又很快，因此當 small batch 遇到小的峽谷 (sharp) ，可能會一下子就跳出去了，無法找到 sharp minima，所以通常會卡在 flat minima，而 large batch 的情況就是相反。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/859/1*OYjMyTI6EmwWFoy4sRDqWw.png" /><figcaption>圖8 — 截圖自李宏毅老師課程</figcaption></figure><h3>總結</h3><ul><li>更新一次參數的速度（沒有平行運算）：small batch 勝</li><li>更新一次參數的速度（平行運算）：相同</li><li>訓練一次 epoch 所需要的時間：large batch 勝</li><li>Gradient：small batch (雜訊多)、large batch (穩定)</li><li>Optimization：small batch 勝</li><li>綜合評價：small batch 勝</li></ul><blockquote>結語：最後綜合評價以 small batch 勝出，因此也回答了 why should we use batch 的問題，因為若不使用 batch 就等於是用 full batch (large batch) 來訓練 network。</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e3X6UHWDMBVUm5GddS4znw.png" /><figcaption>圖9 — 截圖自李宏毅老師課程</figcaption></figure><blockquote>發想：魚與熊掌可否兼得？</blockquote><blockquote>有些人想要實現 Large Batch 的運算速度 + gradient 的穩定度 + Small Batch 的 Optimization 的訓練方式。</blockquote><p>以上就是這堂課程關於 Momentum 這個部分的筆記了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d36e9e9757dc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【李宏毅老師2021系列】類神經網路訓練不起來怎麼辦（二）：Momentum]]></title>
            <link>https://fredrick84823.medium.com/%E6%9D%8E%E5%AE%8F%E6%AF%85%E8%80%81%E5%B8%AB2021%E7%B3%BB%E5%88%97-%E9%A1%9E%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF%E8%A8%93%E7%B7%B4%E4%B8%8D%E8%B5%B7%E4%BE%86%E6%80%8E%E9%BA%BC%E8%BE%A6-%E4%BA%8C-momentum-343a6ed19c5d?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/343a6ed19c5d</guid>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[深度學習]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Sat, 23 Apr 2022 12:32:17 GMT</pubDate>
            <atom:updated>2022-04-30T11:13:30.641Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>這個系列是在觀看李宏毅老師 2021系列的筆記，希望能用更濃縮的方式將內容整理下來。</blockquote><blockquote>延續上篇【李宏毅老師2021系列】類神經網路訓練不起來怎麼辦（一）：Local Minima and Saddle Point 裡面所介紹的 saddle point，這一堂課會介紹的 Momentum 是一種結合 Gradient Descent 的更新參數的方式，也是可以逃離 saddle point 的方式。</blockquote><p>此篇筆記來自課程：<a href="https://www.youtube.com/watch?v=zzbr1h9sF54">【機器學習2021】類神經網路訓練不起來怎麼辦 (二)： 批次 (batch) 與動量 (momentum) — YouTube</a>，Momentum 是在這個影片的最後才介紹的，但為了接續上一篇課程的 saddle point，我拆成兩篇文章來紀錄。</p><p>同樣因為 notation 的關係，如果想看比較美觀的版本也可以直接看 notion 的筆記版本：<a href="https://quixotic-revolve-92a.notion.site/Tips-for-training-Batch-and-Momentum-cfcbead0a7a040dab13a5802f3ed2e05">https://quixotic-revolve-92a.notion.site/Tips-for-training-Batch-and-Momentum-cfcbead0a7a040dab13a5802f3ed2e05</a></p><h3>Momentum</h3><blockquote><strong><em>Momentum 是除了 Gradient Descent 之外，另一種更新並優化 function 參數的方式，也是除了透過 Hessian 以外，能夠逃離 Saddle Point 的另一種方式。</em></strong></blockquote><h4>圖表解釋概念</h4><ul><li>在物理世界中，如圖1假設 error surface 就是二維的斜坡（實際上不是，因為 feature 的維度非常多）。</li><li>而參數是一個球。</li><li>如果是用 gradient descent 的方式優化 loss 並更新參數，那麼球會卡在平坦的 saddle point（中間的球），到不了 local minima（最右邊的球）。</li><li>而在物理世界中，球因為斜坡往下的速度，並不會卡在 saddle point，反而會繼續往前到 local minima，甚至斜坡夠陡峭，會翻過 local minima 繼續往右走。</li><li>這種模擬物理世界中球體的前進方式，就是 momentum 的概念。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9zOMDIL5W2My9RwG5yKtZQ.png" /><figcaption>圖1 - 截圖自李宏毅老師課程</figcaption></figure><h4>公式解</h4><ul><li>Vanilla Gradient Descent （一般的 gradient descent）</li></ul><pre>* 初始參數 theta⁰。</pre><pre>* 計算 g⁰。</pre><pre>* 往 g⁰ 的反方向更新參數 theta¹（公式： theta¹ = theta⁰ - eta g⁰）。</pre><pre>* 有了 theta¹ 再計算 g¹。</pre><pre>* …</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ErliOeTLyVgeizAFtIfXww.png" /><figcaption>圖2— 截圖自李宏毅老師課程</figcaption></figure><h4>Gradient Descent + Momentum</h4><ul><li>這次更新的方向與距離 = 上一個步驟的 m (momentum) 加上這次的 g (gradient)。</li></ul><pre>* 初始參數 theta⁰、初始 m⁰ = 0。</pre><pre>* 計算 g⁰。</pre><pre>* 計算 m¹ = lambda * m⁰ - eta * g⁰。<br>* theta⁰ 根據 g⁰ 的反方向加上 m¹ 移動到 theta¹（公式： theta¹ = theta⁰ + m¹）。</pre><pre>* 有了 theta¹ 之後再計算 g¹。</pre><pre>* 計算 m² = lambda * m¹ - eta * g¹。</pre><pre>* theta² = theta¹ + m²， theta² 不只會往 g¹ 的反方向前進（紅色虛線），也會考慮 $m¹$ 的方向（藍色虛線）。</pre><pre>* ...</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rXwg9h4NXFHzEjwCOdtHPQ.png" /><figcaption>圖3— 截圖自李宏毅老師課程</figcaption></figure><ul><li>m 其實可以被寫作是 g⁰, g¹,…,g^i-1 的 weighted sum。</li></ul><pre>* 因為 m⁰ = 0，因此 m¹ = — eta g⁰。</pre><pre>* 接著再繼續帶入 m²。</pre><pre>* m² = -lambda * eta * g⁰ — eta * g¹。</pre><pre>* ...</pre><ul><li>因此對於 momentum 的解讀：</li></ul><ol><li>一種是 g 的負的反方向 + 前一次的方向。</li><li>另一種是，參數更新的方向，是對過去所有 g 的總和。</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/844/1*kiX_AWxAbZ2sRB55ORmxIA.png" /><figcaption>圖4— 截圖自李宏毅老師課程</figcaption></figure><h4>圖解逃離 saddle point</h4><ul><li>跟上一張 Small Gradient 的圖一樣，這次用 Gradient Descent + Momentum 的方式來更新參數。</li><li>參數更新的方向（藍色實線） = 負的 g （紅線）+ 上一次參數更新的方向（藍色虛線）</li><li>因此可以清楚地看見，參數並不會卡在 saddle point，儘管 g = 0，但因為還考慮了上一次參數更新的方向，因次還有辦法繼續往右走。</li><li>而到了最右邊的高峰時，儘管負的 g 要參數往左更新，但若上一次的更新方向的力道大於往左的力道，那麼參數甚至會往右更新。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TT19Kd6E9L8T4pWqFFl8Uw.png" /><figcaption>圖5— 截圖自李宏毅老師課程</figcaption></figure><h3>結語</h3><p>除了 Momentum 以外，訓練的 Optimizer 還有很多其他種類，常聽到的還有 AdaGrad、RMSProp、Adam（實務上常用），這篇筆記就是紀錄 Momentum 這種 Optimizer 概念與實際上是如何更新參數的。</p><p>以上就是這堂課程關於 Momentum 這個部分的筆記了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=343a6ed19c5d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[【李宏毅老師2021系列】類神經網路訓練不起來怎麼辦（一）：Local Minima and Saddle Point]]></title>
            <link>https://fredrick84823.medium.com/%E6%9D%8E%E5%AE%8F%E6%AF%85%E8%80%81%E5%B8%AB2021%E7%B3%BB%E5%88%97-%E9%A1%9E%E7%A5%9E%E7%B6%93%E7%B6%B2%E8%B7%AF%E8%A8%93%E7%B7%B4%E4%B8%8D%E8%B5%B7%E4%BE%86%E6%80%8E%E9%BA%BC%E8%BE%A6-%E4%B8%80-local-minima-and-saddle-point-773727fa93ee?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/773727fa93ee</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[機器學習]]></category>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[深度學習]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Fri, 15 Apr 2022 14:25:57 GMT</pubDate>
            <atom:updated>2022-04-15T14:25:57.689Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>這個系列是在觀看李宏毅老師2021系列的筆記，希望能用更濃縮的方式將內容整理下來。</em></blockquote><blockquote><em>這篇如標題所示，主要先講解概念定義，再透過公式推導和實際例子來解釋 Local Minima 與 Saddle Point 這兩個概念。</em></blockquote><p>此篇筆記來自此課程：<a href="https://www.youtube.com/watch?v=QW6uINn7uGk&amp;t=1382s">【機器學習2021】類神經網路訓練不起來怎麼辦 (一)： 局部最小值 (local minima) 與鞍點 (saddle point) — YouTube</a></p><p>在開始之前，想先跟大家說聲抱歉，因為我的筆記是紀錄在 notion，可以直接使用 Latex 的 notation（好用又美觀）。</p><p>但因為我還沒找到可以在 medium 直接使用 notation 的方式，因此直接複製過來，很多數學符號和變數可能會不太好懂。</p><p>如果想看比較美觀的版本也可以直接看 notion 的筆記版本：<a href="https://quixotic-revolve-92a.notion.site/Local-Minima-and-Saddle-Point-29367f7bd3f3414186477729106a0647">https://quixotic-revolve-92a.notion.site/Local-Minima-and-Saddle-Point-29367f7bd3f3414186477729106a0647</a></p><h3>When gradient is small…</h3><h4>Optimization Fails because…</h4><pre>* 參數對loss的微分等於0 (gradient=0)，因此參數不再更新，我們稱之為critical point。<br>* critical point 有兩種情況。<br>* local minima：局部loss的最小值。<br>* saddle point：非local minima也不是local maxima，但gradient為0。<br>* 處於local minima代表loss已經位於相對低點，但處於saddle point則代表我們的loss仍有很多優化空間。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5f8Q9ssgX5-lXsEDZNiukA.png" /><figcaption>圖1 — 截圖自李宏毅老師課程</figcaption></figure><h3>How to find out we stuck at local minima or saddle point?</h3><p><strong>Tayler Series Approximation</strong></p><pre>* 直接講結論就是，我們無法知道 L(θ) 確切的樣子，但我們可以透過 L(θ’) 大約算出來。 (公式如下左圖)<br>* L(θ’) ：給 L(θ) 訂某一組參數，而 L(θ’) 附近的參數是有辦法被寫出來的，就是Tayler Series Approximation。<br>* 當g (gradient)等於0時，就只剩下公式右半邊的數值，我們就可以透過這個 L(θ’) 來畫出 error surface，藉此了解我們是處於 local minima 還是 saddle point，這種方式稱之為 Hessian。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xqRTR-PvMcB6SpTY_PF3EA.png" /><figcaption>圖2 — 截圖自李宏毅老師課程</figcaption></figure><h3>Hessian</h3><ul><li>判斷</li></ul><pre>* [(θ-θ’)^T * H(θ-θ’)]/2，縮寫成v^T*Hv</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/714/1*KnVaL2ckyzm1YTdybGdGgQ.png" /><figcaption>上方區塊的公式</figcaption></figure><pre>* 對於任何 v 而言，只要 v^T*Hv &gt; 0，那麼 L(\theta) &gt; L(\theta’)，代表 L(\theta’)是附近最低點 (local minma)。<br>* 若 L(\theta) &lt; L(\theta’)，那就是local maxima。<br>* 有時大於0，有時小於0，那就是處於saddle point。<br>* 我們不可能帶入所有有可能的 $v$ ，透過線性代數理論有更簡單的方式去判斷。<br>* local minima：v^THv，Hessian是positive definite的矩陣，這種矩陣的特性是所有eigen跟values都是正的，那麼 v^THv &gt; 0 就會成立。<br>* local maxima：反之亦然。<br>saddle point：eigen 跟 values 有正有負。</pre><ul><li>結論</li></ul><pre>* 我們會算出一個 H 的矩陣叫做 hessian，裡面會有 eigen 跟 values，只需要去判斷它們是正或負，就可以知道目前的 function 處於哪一種 critical point。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WXNKINTgmqKwd0KY3_meLw.png" /><figcaption>圖3 — 截圖自李宏毅老師課程</figcaption></figure><h3>Example</h3><p><em>圖片解釋</em></p><pre>* 假設我們有個史上最爛的function， $y = w1w2x$，和史上最爛的training data，只有一筆data (input=1, label=1)。<br>* 當我們爆量蒐集各種 $w1 w2$，所畫出來的 error surface 就如下圖。<br>* saddle point: 非 local minima，也非 local maxima。<br>* 因此最中間的點就是 saddle point，因為往左上或右下 loss 會增加，往左下或右上 loss 會減少。<br>* local minima: 山溝裡面有好幾個點代表局部最小值。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_tg5PVGioTd5lzKU3kJn2w.png" /><figcaption>圖4— 截圖自李宏毅老師課程</figcaption></figure><p><em>公式推導</em></p><pre>* L = (\hat y — w1w2)² = (1 — w1w2)²<br>* 接著把 loss function 的 gradient 求出來（loss function 分別對 w1, w2 做微分），gradient 用 g 表示。<br>* Critical point 就是當 g = 0，而我們可以發現 w1=0, w2=0 時， g =0 成立。<br>* 而要了解這個 critical point 是 saddle point 或 local minima，則需要看 hessian (H)。<br>* H 是一個矩陣，而裡面的值就是收集了 L 的二次微分，接著把 w1=0, w2=0 帶入， H 算出來就會是 [[0, -2], [-2, 0]]，這四個值有正有負，因此代表這個 critical point 就是 saddle point。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vRQY9FfXnBNXxZ6gYiwgRA.png" /><figcaption>圖5— 截圖自李宏毅老師課程</figcaption></figure><h3>Don’t afraid of saddle point</h3><ul><li>如果今天 function 卡在的 critical point 是 saddle point，其實 H 不但顯示我們卡在 saddle point，更指引了參數更新的方向。</li></ul><p><strong>回顧在 critical point</strong></p><pre>1. $L(\theta)\approx L(\theta’)+ \frac{1}{2}(\theta-\theta’)^TH(\theta-\theta’)$，我們將其中的 $\frac{1}{2}(\theta-\theta’)^TH(\theta-\theta’)$ 表示為 $v^THv$。</pre><pre>2. 當 v^THv 有正有負就代表我們處在 saddle point，而且 H 會告訴我們參數更新的方向。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PhmlD2ojeaRd8ZXQZZD5KQ.png" /><figcaption>上方區塊的公式 — 1.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F2lV9XOW40nzo7Vm53TAWw.png" /><figcaption>上方區塊的公式 — 2.</figcaption></figure><p><strong>參數如何更新 — 1</strong></p><ul><li>假設一</li></ul><pre>* u 是 H 的 eigen vector。<br>* \lambda 是 u 的 eigen value。</pre><ul><li>如果我們將 v^THv 中的 v 替換成 u，就可以推導出</li></ul><pre>* u^THu = u^T(\lambda u) = \lambda ||u||²<br>* 因此可以說 \frac{1}{2}(\theta-\theta’)^TH(\theta-\theta’) 就是 \lambda ||u||²<br>* 當 \lambda &lt; 0 時， u^THu 就會 &lt; 0，而 L(\theta) &lt; L(\theta’) 就會成立。</pre><ul><li>將 v 替換成 u</li></ul><pre>* 回顧上面 \frac{1}{2}(\theta-\theta’)^TH(\theta-\theta’) = v^THv<br>* 我們又將 v 替換成 u，就代表 \theta — \theta’ = u，等於 \theta = \theta’ + u。<br>* 把本來參數在 \theta’ 的位置加上 u，沿著 u 的方向更新，就會讓 L 變小。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NFSLu8uLoeRo9moVhPBP2w.png" /><figcaption>圖6— 截圖自李宏毅老師課程</figcaption></figure><p><strong>參數如何更新 — 2</strong></p><ul><li>同樣是剛剛的例子，我們處在中間黑點的 critical point。</li></ul><pre>* 這時候 gradient = 0，因此需要透過 Hessian 來判斷接下來參數如何更新。<br>* 此時的 $w1=0, w2=0, \lambda_1=2, \lambda_2=-2$。（ $\lambda$ 就是 eigen value）<br>* 此時的 $H$ 是一個 $[[0, -2],[-2, 0]]$ 的矩陣。（ $H$ = Hessian ）</pre><ul><li>上面公式的推導，說明了當 $\lambda &lt; 0$ 時，參數只要沿著 $u$ 的方向更新， $L$ 就會變小</li></ul><pre>* 因此當 $\lambda_2 = -2$， $\lambda_2$ 有一個 eigenvector $u = [[1],[1]]$<br>* 這時候只需要跟著 $u$ 這個矩陣的方向更新參數，就會減少 $L$ 了。</pre><h3>小結</h3><blockquote><em>從這個角度來看，training 時卡在 saddle point 並不可怕。 然而實際上，並不會把 Hessian 算出來，因為「二次微分」跟「要找出 eigen value」的計算量太大了，後面還會講解其他計算量較小的解法。</em></blockquote><h3>Saddle Point v.s. Local Minima</h3><p><strong>魔法師狄奧倫娜：如何從封閉的石棺中偷出聖杯</strong></p><ul><li>從3維的空間石棺是封閉的，但在更高維度的空間中並不是封閉的。</li></ul><p><strong>當我們在視覺化 Training 的 error surface 時</strong></p><ul><li>從2維看，以為是 local minima，但從3維看，其實是 saddle point。</li><li>有沒有可能我們從3維看，以為是 local minima，從無法視覺化的更高維度看，其實是 saddle point。（右半邊）</li><li>因此當參數量很多時，會不會根本沒有 local minima。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pOTbtBao17n1YJSbR8s5fA.png" /><figcaption>圖7 — 截圖自李宏毅老師課程</figcaption></figure><p><strong>實驗支持假設</strong></p><ul><li>假設</li></ul><pre>* 當 function 參數量很多時，沒有 local minima，其實實務上都是卡在 saddle point。</pre><ul><li>實驗</li></ul><pre>* 訓練很多 functions，圖中每一點都是一個 function。<br>* 縱軸代表 training loss，橫軸代表 minimum ratio。<br>* minimum ratio = Number of Positive Eigen values / Number of Eigen values。<br>* 當 Eigen values 都是正值時，critical point 才會是 local minima，因此 ratio =1 才是 local minima。</pre><ul><li>結果</li></ul><pre>* minimum ratio 頂多超過0.5一些，越往右邊越像 local minima，但仍然不是真正的 local minima，因此假設成立。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D29EaFAj1m5rEguHurNEpg.png" /><figcaption>圖8— 截圖自李宏毅老師課程</figcaption></figure><h4>下集預告</h4><p>接下來會講解當我們卡在 local minima、saddle point、或者接近 saddle point 的 plateau 時，實務上的解法。</p><h3>懶人包</h3><ul><li>Critical Point：當我們在訓練的過程中，當 gradient = 0 時，參數不再更新的狀況。</li></ul><pre>* 有兩種狀況 gradient = 0<br>* Local Minima：局部 loss 的最小值。<br>* Saddle Point：非 local minima 也不是 local maxima。<br>* 處於local minima代表loss已經位於相對低點，但處於saddle point則代表我們的loss仍有很多優化空間。</pre><ul><li>怎麼判斷我們是在 Local Minima 還是 Saddle Point</li></ul><pre>* 我們可以透過 Hessian 判斷。<br>* Hessian 是一個矩陣，其中包含 eigen values。</pre><ul><li>處在 Saddle Point 怎麼辦</li></ul><pre>* 除了可以透過 Hessian 判斷我們處於哪種 Critical Point 之外，也能透過 Hessian 判斷參數更新的方向。<br>* 但實務上因為 Hessian 的計算量太大，因此會用其他方法來逃離 Saddle Point。</pre><ul><li>Local Minima 跟 Saddle Point 在不同維度空間中的誤解</li></ul><pre>* 當我們處在更高維度觀察 Local Minima時，看起來會像是 Saddle Point。</pre><p>以上就是這堂課程的筆記了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=773727fa93ee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ensemble Learning 集成學習(下)]]></title>
            <link>https://fredrick84823.medium.com/ensemble-learning-%E9%9B%86%E6%88%90%E5%AD%B8%E7%BF%92-%E4%B8%8B-6abc687eb394?source=rss-ef7f750e5ef6------2</link>
            <guid isPermaLink="false">https://medium.com/p/6abc687eb394</guid>
            <category><![CDATA[data-science]]></category>
            <category><![CDATA[資料科學]]></category>
            <category><![CDATA[ensemble-learning]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[追客 Fredrick Hong]]></dc:creator>
            <pubDate>Thu, 14 Apr 2022 13:54:48 GMT</pubDate>
            <atom:updated>2022-04-14T13:58:41.713Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>最近工作上有碰到「簡易版 feature用 gradient boosting」的成效 train的比「詳細版 feature用深度學習」的成效還好的情況，於是就把李宏毅老師2015年講 ensemble的課程拿出來看，想好好理解一下集成學習在做什麼，順邊把筆記記錄起來。</em></blockquote><blockquote><em>因為這次影片的內容較多，所以我把ensemble分成上中下篇來紀錄，最後這篇要介紹的是Boosting 中的 Gradient Boosting 跟 Ensemble: Stacking 的概念。</em></blockquote><p>此篇筆記來自此課程：<a href="https://www.youtube.com/watch?v=tH9FH1DH5n0">https://www.youtube.com/watch?v=tH9FH1DH5n0</a></p><p>上一篇介紹完AdaBoost的原理，這篇來介紹同樣是Boosting的學習方式：Gradient Boosting，前半段幾乎都是跟著公式推導的筆記，想知道結論的可以直接看後半段的小結語。</p><h3>Gradient Boosting</h3><ul><li>可以想像是比Bossting中比較general的版本</li></ul><p><strong>圖1 解釋 <em>(General Formulation of Boosting)</em></strong></p><pre>* 最初的function g0(x)=0</pre><pre>* 在T個iteration中，以t=1為例子。</pre><pre>* 我們需要找到一個ft(x)和α來讓gt-1(x)更好，也就是說ft(x)跟ft-1(x)有互補作用。 (α = weight)</pre><pre>* gt-1(x) = 根據ft(x)和 α weighted sum的結果。</pre><pre>* gt(x) = gt-1(x) + αt*ft(x)</pre><pre>* H(x) = sign(gt(x))</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/863/1*Jlq56DOXsVLfWNrvG0tbcA.png" /><figcaption>圖1 (截圖自課程 — ML Lecture 22: Ensemble)</figcaption></figure><ul><li>問題是要怎麼讓機器學習到g(x)呢？</li><li>我們需要一個loss function：</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/244/1*VgHto_7FAY_D8R3p_dceXA.png" /><figcaption>loss function</figcaption></figure><ul><li>l 是 loss function，可以是binary cross entropy 或 MSE，用來計算 g 和 y hat 之間的差異，而這邊我們先用下圖表示。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/292/1*TdqdKmeh4bec08mUb5MfMw.png" /><figcaption>這邊範例用的loss function</figcaption></figure><ul><li>這樣的 loss function 合不合理？因為我們會希望 minimize 這個 loss function 時，y hat 跟 g(x) 要同號，且越大越好，因此是合理的。</li></ul><p><strong>圖2 解釋</strong></p><pre>* 我們要把function g(x)，對L做微分，算出它的gradient，再用gradient去更新gt-1，變成gt，使得gt的loss function比gt-1還要小。</pre><pre>* 對一個 function 做偏微分有點抽象，因為L(g)又不是參數，這邊老師解釋，可以把function想像成無窮多維的vector (無窮多個參數)，既然是參數，就比較容易想像可以對 L(g)做微分。</pre><pre>* 下圖中間是以Gradient Descent的角度去計算出gt，最下方是以Boosting的角度計算出gt，而我們會希望αt*ft跟gradient的方向相同。（η是learning rate）</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fgzuULStOU4VR91EJWK89w.png" /><figcaption>圖2 (截圖自課程 — ML Lecture 22: Ensemble)</figcaption></figure><p><strong>圖3 解釋</strong></p><ul><li>經過一連串的推導，會得到「圖3藍線底」這個 weight 就是AdaBoost的weight。</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZakevzCRztvvHO3OgeqiVw.png" /><figcaption>圖3 (截圖自課程 — ML Lecture 22: Ensemble)</figcaption></figure><p><strong>圖4 解釋</strong></p><ul><li>gt(x) = gt-1(x) + αt*ft(x)</li></ul><pre><em>ft(x)</em><br>* 這邊的ft(x)就是AdaBoost找出來的ft(x)。</pre><pre>* 可以想像成找到一個weak classifier：ft(x)，然後對這個ft(x)做gradient descent。<br></pre><pre><em>αt<br></em>* 這邊的αt就有點像是learning rate，我們的目標是要找到一個αt，可以讓L(g)最小，而因為ft(x)本身可能就是一個weak classifier (可能是nn)，所以要很謹慎地設定learning rate，因為用暴力解法太花時間 (窮舉各種不同的α)。</pre><pre>* 因此用快速的方式，就是計算αt跟L(g)的微分，然後看看αt是多少的時候，微分的結果等於0。</pre><pre>* 巧妙的是找到的αt剛好就等於AdaBoost裡面的那個weight (同樣的αt)。</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QKdYSdXbJYzJO7Ipq8YReA.png" /><figcaption>圖4 (截圖自課程 — ML Lecture 22: Ensemble)</figcaption></figure><p>我們可以把AdaBoost想像成，它是對一個loss function做gradient descent，而learning rate有一個很好的方法可以決定。</p><p>Gradient Boosting巧妙的地方，是我們永遠可以創造其他的objective function，就可以創造出其他Boosting的方法。（AdaBoost的loss function是 exp(-y^* g(x))）</p><h4>小結語</h4><p>因為影片看到這邊有點混淆，會覺得按照公式推導，Gradient Boosting就等於AdaBoost，但其實是當GB的loss function選擇使用exp(-y^* g(x))，這種情況下才會等於AdaBoost，否則GB可以選擇其他loss function或objective function，因此我認為GB的好壞跟loss function的選擇有很大的關係。</p><p>按照上面AdaBoost的介紹，AdaBoost是透過提升上一個function錯分資料的權重，來提升上一個function的不足，而GB則是透過gradient descent來提升模型的不足。</p><p><strong>網路上其他人解釋AdaBoost和GB的不同</strong></p><blockquote>和AdaBoost一樣，Gradient Boosting也是重複選擇一個表現一般的模型並且每次基於先前模型的表現進行調整。不同的是，AdaBoost是通過提升錯分資料點的權重來定位模型的不足而Gradient Boosting是通過算梯度（gradient）來定位模型的不足。因此相比AdaBoost, Gradient Boosting可以使用更多種類的目標函式,而當目標函式是均方誤差時，計算損失函式的負梯度值在當前模型的值即為殘差。 引述來自：<a href="https://www.itread01.com/content/1550642058.html">https://www.itread01.com/content/1550642058.html</a></blockquote><p>最後來介紹最後一種Ensemble的方式，也是老師提到實務上最實用的方式。</p><h3>Ensemble: Stacking</h3><h4>Voting</h4><p>圖5 解釋</p><pre>* 假設我們有好幾個model，就直接把input丟到所有model中產出output，然後再去voting。</pre><pre>* 但在所有的model當中，我們會遇到某些model是很差的，又不好意思將它的權重設定得很低（老師這邊舉例是說每個model是由不同同學訓練出來的），因此我們就將每個model預測出來的結果，變成一組新的feature，再input進去一個final classifier裡（若前面的model已經夠複雜，final就不需要太複雜）。</pre><pre>* 在訓練model，我們需要將training data拆分成兩組，一組用來train大家的model，一組用來train final model，就是要避免overfitting。因為如果第一層某個人的model已經overfitting，那後面final的就會覺得這個model很強，但其實它在testing data上的表現很差。</pre><pre>* 到這邊一樣還是會給每個model一個權重，一樣會傷害到它的自尊心，但至少他是被機器傷害的XD</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*Lq5W6DE1_YpP1__lh9bzxQ.png" /><figcaption>圖5 (截圖自課程 — ML Lecture 22: Ensemble)</figcaption></figure><blockquote>老師這邊雖然說不好意思人工設定權重，因此交由機器判斷，但我認為有個好處，就是我們不需要人工先去驗證每個model的好壞，可以直接讓機器判斷，可以省去驗證的時間。</blockquote><p>Ensemble的筆記到這邊已經結束了，如果喜歡我的筆記，歡迎給個clap或留下留言！</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6abc687eb394" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>