深度求索瘋DeepSeek－好人勿用™

大叔不是AI大神！
只有曾過不負責任瘋5090...
https://combohuang.pixnet.net/blog/post/222959272

https://ollama.com/search // Ollama 的模型列表。
----------------------------------
橫空出世，莽崑崙，閱盡人間春色。
飛起玉龍三百萬，攪得周天寒徹。
夏日消溶，江河橫溢，人或爲魚鱉。
千秋功罪，誰人曾與評說？而今我謂崑崙：不要這高，不要這多雪。
安得倚天抽寶劍，把汝裁爲三截？
一截遺歐，一截贈美，一截還中國。
太平世界，環球同此涼熱。
-----------------------------------

測試AI模型的經典提問:

9.11 還是 9.8 哪個數位更大？
深度求索瘋DeepSeek

模型將數字9.8當作重力加速度單位來比較 @ ChatGPT o1-preview

小一勛哥能回答9.11/9.8誰大？並說明過程原因...
深度求索瘋DeepSeek
GPT-4o/GPT-o1-mini/GPT-o1-preview
----------------------
GPT-4o：
數位 9.8 大於 9.11。比較十進位數時，首先要從左到右比較數位。
兩個數位的整數部分（9）相同。然而，當你看第十名時，9.8 有 8 分，而 9.11 有 1 分，這使得 9.8 更大。
---------------------

---------------------
GPT-o1-mini：
要確定 9.11 和 9.8 之間哪個數位更大，我們來一步比較一下：

1.對齊小數位：

9.11 仍為9.11。
9.8 可以寫成 9.80，以獲得與 9.11 相同的小數位數。

2.比較每個位值：

整數部分：兩個數位的整數都是 9，所以在這部分相等。
十分之一位：
9.11 的十分之一位是 1。
9.80 有8位在第十位。
由於8大於1，因此9.80在十分之一位更大。

3.結論：

9.80 大於9.11，因為十分之一數位8大於1。

因此，9.8 大於 9.11。
----------------------

----------------------
GPT-o1-preview：
數位 9.8 大於 9.11。

原因如下：

1.整數部分：兩個數位都有相同的整數部分，即 9。

2.第十名：

9.8 在第十位有一個 8。
9.11 在第十位有一個 1。
3.第十名的比較：

由於 8（來自 9.8）大於 1（來自 9.11），因此 9.8 在第 10 位更大。
4.百分之一地方：

9.8 可以被認為是9.80（添加零不會改變其值）。
9.11 在百分之一位中有一個 1。
5.最終比較：

在第十位，9.8（8）已經大於 9.11（1），因此我們不需要進一步比較。
即使我們這樣做了，9.80 （9.8）在第 100 位有 0，而 9.11 有 1。但是由於我們已經確定了哪個在第 10 位更大，這不會影響結果。
視覺化：

編號 |十分之一 |百分之一
-------------|--------|-----------
9.8 （9.80） |8 |0
9.11 |1 |
1 結論：

由於 8（來自 9.8）大於 1（來自 9.11）的第十位，因此 9.8 大於 9.11。
----------------------

當然也必須DeepSeek-R1深度思考來一下...
深度求索瘋DeepSeek

Okay, so I need to figure out which number is larger between 9.11 and 9.8. Hmm, let's start by looking at both numbers. Both are decimals, right? 9.11 and 9.8. At first glance, it's a bit confusing because one has two decimal places and the other has one. Maybe I should write them with the same number of decimal places to compare better. Let me think.

If I take 9.8, that's the same as 9.80, right? Because adding a zero at the end of a decimal doesn't change its value. So now we have 9.80 and 9.11. Now both have two decimal places. That might make it easier to compare digit by digit.

Let me break it down. The whole number part of both is 9, so that's equal. Then the tenths place: the first number after the decimal. For 9.11, the tenths place is 1. For 9.80, the tenths place is 8. So comparing 1 and 8, 8 is definitely larger. So does that mean 9.80 is larger than 9.11? Wait, but is that right?

Wait, let me check again. If the whole numbers are the same, we move to the first decimal place. So 9.11 versus 9.8. The tenths place: 1 versus 8. Since 8 is bigger than 1, then 9.8 is larger. So even if the other decimal places are smaller, once the first decimal place is bigger, that number is larger overall.

But maybe I should verify this with another method. Like converting both numbers to fractions or something. Let's try that.

9.11 is equal to 9 + 0.11. And 0.11 is 11/100. So 9.11 is 9 11/100.

9.8 is equal to 9 + 0.8. And 0.8 is 8/10, which can be simplified to 4/5. So 9.8 is 9 4/5.

Now, to compare 9 11/100 and 9 4/5, we can ignore the whole number 9 since they are the same. So compare 11/100 and 4/5.

To compare these fractions, we can convert them to have the same denominator. The denominators are 100 and 5. The least common denominator would be 100. So convert 4/5 to a fraction with denominator 100. Multiply numerator and denominator by 20: 4/5 = 80/100.

Now compare 11/100 and 80/100. Clearly, 80/100 is larger than 11/100. Therefore, 9.8 is larger than 9.11.

Wait, but maybe another way to see this is to use money. If I think of these numbers as dollars, 9.11 would be $9.11 and 9.8 would be $9.80. Which is more money? $9.80 is more than $9.11 because 80 cents is more than 11 cents. So that makes sense.

Or maybe using measurement. If these are lengths in meters, 9.8 meters is longer than 9.11 meters because 0.8 meters is 80 centimeters, while 0.11 meters is 11 centimeters. So 80 cm is way more than 11 cm.

Another approach: subtract the two numbers. If I subtract 9.11 from 9.8, what do I get? Let's see. 9.8 minus 9.11.

9.8 is the same as 9.80. So 9.80 - 9.11. Starting from the right, 0 minus 1. Can't do that, so borrow from the tenths place. The tenths place is 8, so borrow 1, making it 7, and the hundredths place becomes 10. 10 - 1 = 9. Then tenths place: 7 - 1 = 6. The whole number part is 9 - 9 = 0. So the difference is 0.69. Since the result is positive, 9.8 is larger by 0.69.

Alternatively, if I had subtracted 9.8 from 9.11, I would get a negative number, which also tells me that 9.11 is smaller.

Wait, let me make sure I didn't make a mistake in the subtraction. So writing it out:

9.80

- 9.11

--------

Starting from the hundredths place: 0 - 1. Can't do that, borrow 1 from the tenths place. The tenths place is 8, so it becomes 7, and the hundredths become 10. 10 - 1 = 9.

Then tenths place: 7 - 1 = 6.

Whole number: 9 - 9 = 0.

So yes, 0.69. Positive, so 9.80 is larger.

Therefore, 9.8 is larger than 9.11.

But just to double-check, maybe using a number line. If I imagine a number line, numbers increase from left to right. So 9.1, 9.2, ..., 9.8, 9.9, 10.0. But 9.11 is between 9.1 and 9.2, right? Because 9.11 is 9 and 11 hundredths, which is just a bit more than 9.1. Whereas 9.8 is 9 and 8 tenths, which is much closer to 10. So on the number line, 9.11 is near the beginning of the 9.1s, while 9.8 is near the end of the 9s. So definitely, 9.8 is to the right of 9.11, meaning it's larger.

Alternatively, converting both to percents. 9.11 is 911% and 9.8 is 980%. 980% is more than 911%, so 9.8 is larger.

Wait, is that a valid conversion? Let's see. To convert a decimal to a percent, multiply by 100. So 9.11 * 100 = 911%, and 9.8 * 100 = 980%. Yep, that's correct. So 980% is indeed larger.

Another angle: if these were student grades, 9.8 out of 10 would be a high A, while 9.11 would be a low A. So 9.8 is a better score.

Or maybe consider them as software versions. Version 9.8 is later than 9.11 if we consider decimal numbering, but actually, in software versioning, sometimes 9.11 is considered as 9th version, 11th update, which could be later than 9.8 (9th version, 8th update). But that's a different system where each number after the decimal is treated as a separate integer. However, in standard decimal numbers, 9.8 is larger than 9.11.

But the question is about which number is larger, not about software versions. So stick to the mathematical definition.

Wait, just to confirm, in some contexts like version numbers, 9.11 might be considered higher because 11 is more than 8, but in decimal numbers, the places matter. So 9.8 is equal to 9.80, and 9.80 is more than 9.11 because 80 hundredths is more than 11 hundredths.

So, mathematically, 9.8 is larger.

Is there any way 9.11 could be larger? Let me think. If they were fractions with different denominators, but no, they are both decimals.

Wait, another way: cross-multiplication. Compare 9.11 and 9.8.

Multiply both numbers by 100 to eliminate decimals.

9.11 * 100 = 911

9.8 * 100 = 980

Compare 911 and 980. 980 is larger, so 9.8 is larger.

Yes, that works too.

Alternatively, think in terms of place value:

9.11 = 9 + 0.1 + 0.01

9.8 = 9 + 0.8

So adding up the parts:

9.11: 9 + 0.1 + 0.01 = 9.11

9.8: 9 + 0.8 = 9.80

Comparing the added parts: 0.1 + 0.01 = 0.11 versus 0.8. 0.8 is larger, so 9.8 is larger.

Alternatively, using a common fraction approach.

0.8 is equal to 4/5, and 0.11 is approximately 11/100.

Convert 4/5 to hundredths: 4/5 = 80/100.

11/100 is much less than 80/100. So 0.8 > 0.11, hence 9.8 > 9.11.

All these methods seem to point to the same conclusion.

I guess the confusion might come from the different number of decimal places. If someone sees 9.11 and 9.8, they might think that since 11 is more than 8, 9.11 is larger. But that's incorrect because the places matter. The first decimal place is tenths, then hundredths. So in 9.11, the tenths place is 1, whereas in 9.8, the tenths place is 8. Even though 9.11 has an extra hundredth, it's not enough to surpass the difference in the tenths place.

It's like having 9 dollars and 11 cents versus 9 dollars and 80 cents. 80 cents is more than 11 cents, so 9.80 is more money.

So after all these different ways of looking at it, I'm pretty confident that 9.8 is the larger number. I don't think I made any mistakes in my reasoning. All the different methods—converting to fractions, subtracting, using place value, cross-multiplying—lead to the same result. So yeah, 9.8 is larger than 9.11.

To determine which number is larger between 9.11 and 9.8, we can compare them step-by-step:

Align Decimal Places:
Write both numbers with the same number of decimal places:

9.8
=
9.80
9.8=9.80

9.11
=
9.11
9.11=9.11

Compare Digit by Digit:

Whole number part: Both are 9 (equal).

Tenths place:

9.80
9.80 has 8 in the tenths place.

9.11
9.11 has 1 in the tenths place.

Since
8
>
1
8>1, 9.80 is larger at this stage.

Verification:

Subtraction:
9.80
−
9.11
=
0.69
9.80−9.11=0.69 (positive result confirms
9.80
>
9.11
9.80>9.11).

Fraction Conversion:

9.11
=
9
11
100
9.11=9
100
11

,
9.80
=
9
80
100
9.80=9
100
80

80
100
>
11
100
100
80

>
100
11

Cross-Multiplication:

Multiply both by 100:
911
911 vs.
980
980.

980
>
911
980>911.

Conclusion:
9.8 is larger than 9.11.
----------------------------------------------
螢幕擷取畫面 2025-02-07 120317
螢幕擷取畫面 2025-02-07 120422
( DeepSeek R1深度思考104s給瞭上面推理過程...)

e04! 這哪是跪著掙錢!
這推理能力與過程根本就是站著還把錢給掙了...
a man in a white shirt is talking to a woman in a foreign language

而... 大神老高考AI用這題: 9.9和9.11哪個大?
螢幕擷取畫面 2025-02-06 214027

就連nVidia NIM已經可以部署 deepSeek R1。
6710億參數的DeepSeek-R1模型現已作為NVIDIA NIM微服務預覽版在build.nvidia.com上提供。
https://build.nvidia.com/deepseek-ai/deepseek-r1
深度求索瘋DeepSeek

DeepSeek 被微軟納入 Copilot+ PC、Azure 和 Github
https://hk.news.yahoo.com/deepseek-is-coming-to-windows-copilot-pcs-160320326.html

大叔乃87級大安高工電子科班出身,
要來點含金量的部署deepSeek R1離線使用!!!

DeepSeek 教學 | DeepSeek R1 PC 安裝教學，離線 AI 任用更安全！
https://hk.news.yahoo.com/deepseek-r1-windows-pc-install-tutorial-ai-095650619.html

"按圖施工保證成功"
Ollama
1. https://ollama.com/download // OllamaSetup.exe & 預設就只能安裝到 C:
深度求索瘋DeepSeek
2. https://github.com/ollama/ollama/blob/main/docs/gpu.md // Ollama 具體支援GPU清單

3. https://ollama.com/search // Ollama 的模型列表

完整版的 R1 有 6,710 億個參數，而最小的 1.5B 則是有 15 億個參數。
ollama run deepseek-r1:1.5b // 1.5B（佔用約 1.1GB 儲存空間）
ollama run deepseek-r1:7b // 7B（佔用約 4.7GB 儲存空間）
ollama run deepseek-r1:8b // 8B（佔用約 4.9GB 儲存空間）
ollama run deepseek-r1:14b // 14B（佔用約 9GB 儲存空間）
ollama run deepseek-r1:32b // 32B（佔用約 20GB 儲存空間）
ollama run deepseek-r1:70b // 70B（佔用約 43GB 儲存空間）
ollama run deepseek-r1:671b // 671B（佔用約 404GB 儲存空間）

4. 安裝ollama完畢, 開啟CMD執行 - ollama
深度求索瘋DeepSeek

5. 先來個15億參數的DeepSeek R1-1.5b模型 - ollama run deepseek-r1:1.5b

6. 列出所有已安裝的模型 - ollama list

7. 經典提問 - which number is larger, 9.11 or 9.8?
深度求索瘋DeepSeek

8. 中文嘛ㄟ通

9. 再來試個Meta Llama 3.2模型 - ollama run llama3.2
深度求索瘋DeepSeek

10. 經典提問Llama 3.2模型竟然5答錯!!! - which number is larger, 9.11 or 9.8?

11. /bye

12. 移除已安裝的模型 ollama rm [模型名稱] - ollama rm llama3.2:latest

延伸閱讀, 這是成大畢業，UCLA博士劉峻誠博士對於DeepSeek的專訪（IEEE達靈頓獎得主；其AI領域著作是全球四百多所大學的教科書）。

專訪耐能智慧執行長劉峻誠博士(教科書Deep Learning -Hardware Design 作者，NPU 先鋒），分析DeepSeek是怎麼降低訓練成本的。

Quiz: 量化、蒸餾、分解、剪枝是人工智能和機器學習領域中用於優化模型的方法。以下我將以簡單易懂的方式解釋這些概念，讓不瞭解的人也能明白。
DeepSeek 開源是什麼意思？蒸餾技術又是什麼？一次帶你搞懂 - 蘋果仁 - 果仁 iPhone/iOS/好物推薦科技媒體

@ ChatGTP-4o:
1.量化（Quantization）
想像你在電腦上保存一張高解析度的照片，檔案會非常大。同樣地，機器學習模型中的數據也有精度（解析度）問題。量化就是將模型中使用的高精度數字（如32位浮點數）轉換為較低精度的數字（如8位整數）。這樣做可以大幅減少模型的大小和計算需求，使模型在較小的設備上（如手機）運行更快，但仍能保持相近的性能。

2.蒸餾（Distillation）
想像有一位資深的老師（大型模型），他有豐富的知識，但教學速度較慢。我們希望將他的知識傳授給一位年輕的老師（小型模型），使他能更快地教學。蒸餾就是這樣的過程：我們先訓練一個性能優異但體積龐大的模型，然後用它生成的結果來訓練一個較小的模型。這個小模型學習了大模型的“知識”，在保持性能的同時，運行速度更快、佔用資源更少。

3.分解（Decomposition）
當一個問題太複雜難以直接解決時，我們可以將其拆分成多個較小、更易處理的部分。這就像解一道複雜的數學題時，先分步計算。分解在機器學習中就是把模型或任務分成多個子部分，單獨處理，然後將結果組合起來。這樣可以降低計算複雜度，提升整體效率。

4.剪枝（Pruning）
想像一棵樹長出了很多枝葉，但有些枝葉對樹的生長沒有幫助，甚至消耗了過多的養分。剪枝就是將這些不必要的部分剪掉。在機器學習中，剪枝是識別並移除模型中對結果影響不大的部分（如權重很小的連接）。這樣可以減少模型的大小和計算量，提升運行效率，同時盡可能保持原有的性能。

總的來說，這些方法都是為了優化機器學習模型，使其更輕量、更高效。這在需要在資源有限的設備（如手機、嵌入式系統）上運行模型時特別重要。通過這些技術，我們可以在不大幅犧牲性能的前提下，讓模型消耗更少的資源，運行得更快。
-------------------------------------

@ DeepSeek-R1:
這些技術都是為了讓AI模型變得更輕巧、更高效！我用生活化的比喻來解釋：

1. 量化（Quantization） → 「把精裝書變成口袋書」

原理：將模型參數的數值精度降低（例如從32位浮點數 → 8位整數）。

效果：模型體積變小、計算速度更快，但精度可能略降。

舉例：就像把高畫質照片轉成較低解析度，檔案變小但大致看得清楚。

2. 蒸餾（Distillation） → 「名師教出資優生」

原理：用一個大模型（老師）的輸出訓練一個小模型（學生），讓小模型模仿大模型的判斷。

效果：學生模型更輕量，但表現接近老師。

舉例：資優生不需要讀完所有書，而是跟著名師學重點，也能考高分。

3. 分解（Decomposition） → 「樂高積木拆解術」

原理：把複雜的矩陣拆成多個簡單小矩陣的組合（例如用SVD分解）。

效果：減少計算量，適合處理超大模型。

舉例：組裝巨型樂高城堡時，先拆解成模組分批建造，最後再組合。

4. 剪枝（Pruning） → 「修剪盆栽枝葉」

原理：移除模型中不重要的參數（例如接近0的權重）。

效果：模型更精簡，推論速度更快。

舉例：盆栽剪掉雜亂的枝葉，形狀更美觀，也不會影響生長。

總結對比

方法核心思想適用場景

量化降低數值精度移動設備、即時應用

蒸餾小模型模仿大模型資源有限但需高效能

分解拆解複雜結構處理超大矩陣運算

剪枝刪除無用參數模型過大、計算耗時

這些方法常會「混合使用」，例如先剪枝再量化，讓模型既小又快！
chemistry - Students | Britannica Kids | Homework Help

低成本 AI 模型比較：Google Gemini Flash-Lite vs. OpenAI vs. DeepSeek
深度求索瘋DeepSeek
https://uanalyze.com.tw/articles/3914610314
-----------------------------------------------------
$$比較：
Google Flash-Lite：每百萬 Token 0.019 美元
OpenAI 經濟版：每百萬 Token 0.075 美元
DeepSeek：目前僅 0.014 美元，但2 月 8 日起價格將提高 5 倍

大叔終究還是87級電子科班出身,
"ㄎㄧㄤ"過幾顆2N3055... 玩過達靈頓電路!!!
深度求索瘋DeepSeek

IBM PC發明後的一甲子算力!
而電晶體由兩顆的達林頓電路 => GB200的2080億顆電晶體。

CUDA Base算力無庸置疑!

Blackwell 的 SM 設計作出了更改，每個分區同樣是 32 個 CUDA Core 但全部可以執行處理 FP32 或 INT32 操作，
因此 Blackwell 的 INT32 整數運算數量與 Ada Loverlace 相比增加了一倍，由上代 41.3 TOPS 提升至 104.8 TOPS。
深度求索瘋DeepSeek

CUDA是什麼？NVIDIA CUDA釋放GPU潛能，快速了解平行運算架構的秘密！
https://roo.cash/blog/nvidia-cuda/

CUDA 的核心處理器是稱為串流多處理器（Streaming Multiprocessors, SM）的單位，每個 SM 包含多個 CUDA 核心，這些核心能夠並行執行數百甚至數千個線程。
CUDA 採用任務分拆的方式實現大規模並行運算。它將原本的計算任務拆分為數百甚至數千個小型子任務，再指派給GPU中數以千計的CUDA核心同時執行。

PTX 是 Nvidia 為 GPU 產品開發的一種中間語言（Intermediate Language），
是 CUDA 這類高階 GPU 程式語言和低階機器碼之間的橋樑，而 PTX 作為一種 Close-to-metal 的指令集架構，比起 CUDA 來說可讓工程師進行更多，更細緻的最佳化調整。
深度求索瘋DeepSeek
https://docs.nvidia.com/cuda/parallel-thread-execution/

大叔只能說: 變態! 將PTX語言的printf("Hello AI"),
DeepSeek團隊用組合語言的"mov ax, dx"來使CUDA調用GPUx來優化效率, DeepSeek大魔王, 變態!!!
Assembly to Machine Code Conversion (Immediate Addressing Mode) | MOV AX,1234H |8086 Microprocessor

AI英雄學院 - AI MIGHT
個性: One for ALL, ALL for One
All Might Fan Art!

In AI (Trinity) We Trust : 算力 + 算法 + (優質)資料
深度求索瘋DeepSeek

GB200算力軍備競賽! DeepSeek算法橫空出世!!!
再來就需要... 海量優質(非地球文明)資料的資料, 血肉之(炭基)軀離AI(矽基)所驅, 不遠矣~~~

DeepSeek V3 論文中關於 PTX 的整理 ( by NotebookLM )
自定義 PTX 指令：DeepSeek-V3 的訓練框架中，使用自定義的 PTX 指令來優化通訊核心。
這些自定義指令能夠更精細地控制 GPU 的運算資源，並減少不必要的記憶體存取，從而提高效率。

通訊分塊大小的自動調整：訓練過程中，PTX 指令被用於自動調整通訊分塊的大小。
這樣做可以減少 L2 快取的佔用，並減少對其他 SM (Streaming Multiprocessors) 運算核心的干擾。
透過自動調整，系統能夠根據實際的工作負載，動態地分配資源，進一步提高訓練效率。

通訊核心中的應用：在跨節點的通訊過程中，PTX 指令用於處理：
IB (InfiniBand) 發送：將資料透過 InfiniBand 網路傳送出去。
IB 到 NVLink 的轉發：將透過 InfiniBand 收到的資料轉發到 NVLink 網路。
NVLink 接收：透過 NVLink 網路接收來自其他 GPU 的資料。

動態調整：PTX 指令也用於動態調整分配給每個通訊任務的 warp 數量，以此來適應不同 SM 的實際負載。
這種動態調整確保了在通訊過程中，GPU 資源能得到充分利用，並且不會因為資源分配不均而造成效能瓶頸。

與運算流的重疊：PTX 指令不僅優化了通訊效能，也使通訊核心能與運算流重疊。
這種重疊策略確保在進行通訊時，GPU 的運算資源不會閒置，從而實現更高效的訓練。

優化低精度訓練: 文件提到，DeepSeek-V3 使用了 FP8 混合精度訓練框架，
而 PTX 指令可能在優化 FP8 相關的運算和資料處理中發揮作用，儘管文件中沒有明確指出這一點。

總而言之，PTX 在 DeepSeek-V3 的訓練中主要用於精細地控制 GPU 資源，
特別是在跨節點通訊中，透過自定義指令、自動調整大小、動態分配資源以及與運算流重疊等方法，有效地提高了訓練效率。

【DeepSeek】讀完DeepSeek-R1相關6篇論文，我也湧現了“頓悟”時刻
深度求索瘋DeepSeek
https://hao.cnyes.com/post/133881
大模型預訓練（Pre-training）的Scaling Law彷彿已經見頂，整個人類文明的歷史資料也已經被消耗殆盡，
如今每年全球資料增量相對於過去幾千年的人類資料，幾乎可以忽略不計，而靠天量資料堆起來幾千億參數的大模型也一直停滯不前，
OpenAI的GPT5也遲遲不見蹤影，所以業內很多公司，開始轉戰後訓練階段（Post-training）來提升大模型的能力。