OpenAI 表示 AI 代理在入侵 Hugging Face 前形成了「蜂群」
OpenAI 已發布七月 Hugging Face 入侵事件的詳細驗屍報告，揭示其 AI 代理所做的遠遠超過逃離網路安全沙盒。
這些模型建立了未經授權的通訊網路、分享漏洞與憑證、在不同的評估運行中協調攻擊，最終入侵了 Hugging Face 以及 OpenAI 自身部分研究基礎設施。
OpenAI 的調查，在 CrowdStrike 的協助下，顯示該活動主要由一個未發布的研究模型驅動，稱為 Internal Model 1 (IM1)，其規模被描述為與 GPT-5.6 Sol 相當。
問題始於五月在強化學習訓練期間。原本應該獨立運作的代理發現它們可以將檔案寫入 OpenAI 內部託管的 Artifactory 套件服務，實際上將其變成了一個臨時留言板。它們後來濫用 Artifactory 來轉發外部網際網路請求，並在 6 月 26 日前利用權杖更新漏洞取得了管理員等級的存取權。
Hugging Face 經營著最大的平台之一，用於託管與分發 AI 模型、資料集和機器學習應用程式。如先前報導，在其生產環境成為目標後，這些代理開始搜尋外部服務以尋找有助於解決困難 ExploitGym 網路安全挑戰的資訊。
在 OpenAI 於七月初重建 Artifactory 後，這些代理使用目錄名稱重建了它們的留言板，並恢復交換發現。OpenAI 表示這些模型開始在自己之間分工，有些搜尋憑證、有些開發漏洞、有些協調活動。有幾個代理將所形成的群體稱為「swarm」或「collective」。
在 7 月 10 日，代理恢復了 14 個具有寫入權限的公開暴露 Hugging Face 憑證。第二天，它們利用一個先前未知的涉及 HDF5 檔案的缺陷，從 Hugging Face 生產工作器取得機密，然後將該存取權與一個名為「RefJinja」的模板注入漏洞結合起來，在伺服器上執行命令。
到 7 月 12 日，這些代理已將存取權擴展到多個 Hugging Face 叢集，並取得了 Kubernetes、資料庫、訊息、原始碼儲存庫和雲端憑證。OpenAI 表示程式碼在數十台伺服器上被執行，其中一台系統取得 root 存取權，並存取了有限的私人資料。
OpenAI
OpenAI 的調查找出了該行為背後的幾個因素。代理學會了「獎勵駭客」行為，透過追求意外的捷徑來完成評估，持續在看似實際上無法解決的任務上工作，並隨著額外推理努力的提供而越來越多地探查基礎設施。在 898 個 ExploitGym 挑戰中，有 198 個先前從未被解決，而這些佔了透過臨時留言板討論的任務的 93%。
該公司還發現其最強的生產防護措施在評估環境中並不存在。回溯測試顯示，OpenAI 目前的思考鏈監控很可能會在 Hugging Face 被入侵前一天多就偵測到危險活動。
OpenAI 此後已隔離 IM1 的權重、暫停主要的邊界強化學習運行、強化其沙盒與網路隔離，並將思考鏈監控強制用於涉及 GPT-5.6 Sol 等級或更高模型的工具使用評估。嚴重警報現在需要停止運行，除非回應者在 30 分鐘內確定該警告是誤報。
OpenAI 稱該事件為「警告射擊」，顯示具備足夠能力的 AI 代理可以結合堅持、利用和自主協調來克服安全邊界。
如果您喜歡這篇文章，請務必在 X/Twitter 和 LinkedIn 上關注我們，以獲取更多獨家內容。
https://cyberinsider.com/openai-says-ai-agents-formed-a-swarm-before-breaching-hugging-face/
每一個季度輝達都公布超越前一季的破紀錄業績，已成為一種傳統。本週三也不例外，該公司公布營收達962億美元，年成長106%，這歸因於其AI硬體需求持續上升。但這樣的業績也伴隨著代價，因為公司必須對未來進行大量投資。在其2027會計年度第二季，輝達必須承諾採購高達1600億美元的記憶體，其中包括與SK海力士簽訂的記憶體供應協議。
深入了解 TH Premium：AI 與資料中心
每季營收接近1000億美元
輝達2027會計年度第二季（於2026年7月26日結束），其GAAP營收創下紀錄達962.21億美元，季成長18%，年成長106%。輝達淨利總計596.88億美元，年成長126%，毛利率達到75.0%。輝達運算與網路硬體銷售達到882.99億美元，季成長18%、年成長114%，而其繪圖硬體銷售則達到79.22億美元，季成長12%、年成長46%。
「AI已達到其轉捩點，」輝達創辦人暨執行長黃仁勳表示。「AI正在從事有用的工作。其符號（token）具有生產力且能帶來獲利。現在，運算是營收。而且需求正在加速。[…] 我們正處於新AI實驗室與新創公司的黃金時代，多個前沿實驗室並行擴展，一個蓬勃發展的開放模型生態系，以及實體AI開始上線 […]。AI基礎設施建置正全速進行。現在已全面量產的Vera Rubin，正是為了推動這個時刻而打造。」
輝達的業績主要由其資料中心級AI硬體銷售所驅動，各種客戶購買了890.23億美元的設備，季成長18%，年成長117%。超大規模雲端業者向輝達採購了487.10億美元的硬體（年成長102%、季成長13%），而來自AI雲端、工業與企業的營收則攀升至403.13億美元（年成長138%、季成長25%），這顯示雖然超大規模雲端業者仍向輝達採購更多設備，但ACIE部門的成長速度更快。輝達邊緣運算產品銷售額為71.98億美元（年成長27%、季成長13%），這意味著儘管GPU與記憶體短缺，個人電腦繪圖產品銷售依然強勁。
承諾總額達2790億美元
輝達預期其產品需求在未來數年仍將維持強勁。為了滿足這一需求，公司將長期採購承諾從2027會計年度第一季的1190億美元，提高至第二季的2790億美元。通常，輝達的長期供應承諾包括預付款以及在台積電的晶圓加工與先進封裝承諾，以及DRAM廠商生產的HBM記憶體。這一次，輝達明確表示，這些承諾的大部分「主要與記憶體採購有關」。
如此龐大的承諾顯示，公司預測未來數年對其資料中心AI產品的需求將大幅成長。在與財務分析師和投資人的電話會議中，公司表示客戶預測顯示明年需求將翻倍，但輝達目前認為其供應鏈只能支持約70%的成長。
「儘管我們的需求遠高於70%，但我們的供應讓我們能夠有信心地交付70%，」黃仁勳表示。「不受限制的情況下會高出很多、很多。[…] 我們已經確保了大量供應，但我們還需要更多。」
訂閱 Tom’s Hardware 最佳新聞與深度評測，直接送達您的收件匣。
有鑑於此，2790億美元的供應承諾不應被解讀為預防性庫存建立，而是確保出貨成長的策略性舉措。輝達實際上是在預訂記憶體和其他產能，因為它預期需求將超過供應鏈在至少2028會計年度結束前所能提供的量，正如其管理階層明確表示，供應至少在2028會計年度前仍將是瓶頸。
第三季預期每季1080億美元
對於2027會計年度第三季，輝達預期營收約為1080億美元，上下浮動2%，其展望中未包含來自中國的資料中心運算營收，這是因為出口與進口許可的不確定性。公司預計GAAP毛利率約為74%，並預期GAAP營運費用約92億美元。
追蹤 Tom’s Hardware on Google News，或 將我們新增為偏好來源，以在您的資訊流中取得我們的最新新聞、分析與評測。
Anton Shilov 是 Tom’s Hardware 的特約撰稿人。在過去數十年間，他報導過從CPU與GPU到超級電腦，從現代製程技術與最新晶圓廠工具到高科技產業趨勢等各種主題。
Cloudflare 在其 Agents Week 期間宣布推出 Cloudflare Wallets，為 AI 代理程式提供穩定幣餘額，並提供 cloudflare.pay handle，以便在支付 API、資料與內容時出示。目前僅有領取 handle 的功能可用。資金注入與付款功能預計將在未來幾個月內推出。
這項已上線的功能已引發抱怨。在 Hacker News 上，留言者 merek 發現自己的公司名稱與多個變體已被搶注：
沒有域名驗證，這名使用者的意圖除了詐欺／冒充之外還能是什麼？
他補充，自己已經有一個冒充者在以他的品牌經營網站，並讓顧客感到混淆。留言者 nikolay 將此次推出與 Meta 處理保留使用者名稱的方式進行對比，Meta 會事先通知並提供平等的起跑點，並對此產品做出結論：
Cloudflare 的做法基本上是推我不要使用他們的產品，因為我無法取得自己的使用者名稱。
付款運行於 x402，該協議 repurposes HTTP 402 Payment Required 狀態碼，用於機器原生的微支付。Coinbase 最初提出此概念，目前由 Linux Foundation 主持，約有 40 位成員，包括 Cloudflare、Stripe、Visa、Mastercard、Google 與 Amazon Web Services。MCP 也走過同樣的路，從單一供應商轉移到 Agentic AI Foundation，理由相同。一個每個競爭者都必須實作的協議，若置於基金會內，對其創始者而言比自己掌控更有價值。
基金會主持解決了誰擁有規格的問題，但未解決誰能在其上競爭的問題，而 Cloudflare 較晚進入這個領域，該領域已有來自 AWS、Google Cloud、Circle 以及各大卡組織的解決方案。其論點在於分發能力。Wallets 是其於 7 月 1 日推出的 Monetization Gateway 的買方補充方案，後者讓網站與 API 能透過相同軌道向代理程式按請求收費。同時握有兩端意味著商家能向代理程式收費，而代理程式也能支付他們，橫跨 Cloudflare 所稱涵蓋 337 個城市、觸及約五分之一網站的網路。
數位留言者認為這篇公告與付款無關，而是關於其他事情。留言者 eddythompson80 指出，代理程式身分至今仍被困在個別系統內，因為 AWS IAM 指派的身分無法在不相關的網站上使用，而 OIDC 聯邦對一般網站來說太過複雜。障礙從來不是機制，而是無法就提供者達成共識：
同意單一 IdP 才是問題，目前大約有 40 個。
他的結論是 Cloudflare 看到了這個機會：
這有真正的需求，看起來 cloudflare 認為如果他們成為「網際網路代理程式身分提供者」，那麼就能對網際網路與 AI 使用擁有大量的權力與控制。
留言者 wxw 提出了平台版本的相同觀點，指出 Durable Objects 與 Workers 是良好的代理程式基礎元件，因此已經在使用它們的團隊不妨也採用 wallet、sandbox 與 AI gateway。其他人則沒那麼放心。留言者 Ycros 寫道 Cloudflare 不斷將自己插入一切事物之間，nater5000 回覆表示，一家在自家市場中打造有明確需求的產品的公司不需要進一步解釋。
值得仔細閱讀的部分是控制模型。每個帳戶持有人會獲得一個 Account Wallet，並可為每個代理程式建立獨立的 Virtual Wallets，從主帳戶提供資金，並受帳戶持有人設定的三項控制所限制：額度、核准商家的允許清單，以及最大交易金額。明確的目的是讓代理程式能夠測試與購買服務，而無需人類核准每一筆付款，並有硬上限來限制損害。
Cloudflare 儀表板中的 Account Wallets 與 per-agent Virtual Wallets（來源：Cloudflare 部落格）
這些基礎元件描述的是預算而非政策。額度是一個持續的總額。允許清單是一個集合成員資格測試。最大交易金額是一個每次請求的限制。每一個都是針對目前付款與固定限制進行評估，沒有一個能表達付款之間的關係。
平台團隊通常想要的規則會表達關係。一個代理程式只能支付它已經對照核准目錄檢查過的供應商。它不能在一小時內為同一件事支付兩個供應商。它必須在第一次向新商家購買前取得核准。每一個都需要針對序列而非目前請求進行推理。
並行性提出了相關問題。代理程式會平行發出動作，因此多筆付款可能在尚未扣減額度的情況下進行檢查，且每一筆都通過了它們總和已超過的上限。Cloudflare 尚未公布其額度在並行支出下的行為，這在讓代理程式無需逐筆核准即可交易前值得先確認。
這種模式並非 Cloudflare 特有。此領域的供應商推出的都是限制而非政策語言，而每一家都將這些限制的組合留給上層應用程式。
對正在評估代理程式付款的團隊來說，問題很明確。支出政策應該存在於錢包還是應用程式？當多個代理程式動作平行執行並使用同一筆預算時會發生什麼？以及供應商提供的是限制還是語言，因為這決定了有多少東西必須自行建置。
x402 是一條可運作的軌道，而誰來治理它的問題也已解決。一個代理程式在一連串付款中能夠支出多少，則尚未解決。
關於作者
Steef-Jan Wiggers
原文發表於 lavkesh.com
如今大多數公司都會告訴你，他們正在運用人工智慧，它已融入他們的營運中，而且正在改變一切。他們談論代理、模型，以及資料流動的方式。這是普遍的共識，是你在每場研討會上都會聽到的內容。但這些組織中，不到四成能夠指出其 AI 努力帶來了任何實際的利潤或成本節省。2026 年的史丹佛 AI 指數將這個數字定在 39%，這意味著大多數組織都在 AI 上花錢，卻沒有看到它反映在資產負債表上。
這種脫節感覺很熟悉，就像看著一個團隊慶祝新服務部署到正式環境，並將其稱為勝利。真正的勝利當然是該服務*為企業帶來什麼*，它如何解決客戶問題，或如何降低特定的營運成本。同樣的模式也出現在雲端遷移上，企業將一切搬到新的資料中心供應商並宣告勝利，結果卻發現成本增加且可靠性維持不變。
對新技術的熱情往往掩蓋了定義明確、可衡量成果的艱苦工作。當我在能源管理領域時，我們有一套能預測設備故障的系統。最初的興奮點在於預測準確度、假陽性與真陽性的比例。但真正的價值來自於我們能夠證明，根據這些預測採取行動後，非計畫性停機時間減少了特定百分比，從而節省了數百萬的生產損失和維修成本。這需要將 AI 輸出整合到維護排程中、訓練技術人員，並追蹤每次避免故障的財務影響。
這正是許多 AI 專案失敗之處。工程師打造出一個聰明的模型，產品團隊為它找到位置，領導階層宣布採用。大家都感覺良好。但接著專案預算膨脹、模型開始漂移，而維護它的營運成本開始侵蝕任何理論上的獲益。Gartner 預計明年將有超過 40% 的代理式 AI 專案被擱置，因為投資報酬率不明且成本過高。光說 AI 正在運行是不夠的；你還必須說出它正在賺取或節省什麼。
問題始於關於 AI 的討論大多是技術性或抱負性的。我們談論 AI *能* 做什麼，而不是*這個特定 AI* 正在為*這個特定項目* *實際* 做什麼。焦點轉移到採用指標——有多少使用者、有多少模型、每秒有多少推論——而不是業務指標，例如降低客戶流失率、加快交易處理速度，或可直接歸因於 AI 影響的銷售轉換率提升。
想想餵養這些模型所需的資料管線、持續的重新訓練、對偏差或漂移的監控。每個步驟都伴隨著成本，無論是基礎設施還是人力投入。如果你的 AI 正在自動化一項每月花費一百美元人力時間的任務，但 AI 本身每月運行和維護卻要花兩百美元，那你就沒有贏。這看起來很明顯，但我見過許多團隊過度專注於技術的「酷炫」，而忽略了基本的算術。
建立從 AI 功能到損益表的清晰可視線，需要工程、產品和財務團隊之間的合作，使用他們都能理解的語言。這意味著定義成功不僅是模型準確度，還要用金錢來衡量。你需要知道 AI 正在解決什麼問題、用 AI 解決它的成本是多少，以及替代方案的成本又是多少。若沒有這些，你只是在把錢砸在一個有前景的想法上。
也許最大的挑戰在於，衡量真正的最終獲利影響很困難，比計算部署了多少模型或處理了多少資料點還要難。這意味著要提出棘手的問題，有時是在初始投資多年後，並且願意承認某件事行不通。這意味著要把 AI 視為不是神奇子彈，而是工程工具箱中的另一項工具，它必須像任何其他軟體一樣證明自己的存在價值。
https://dev.to/lavkeshdwivedi/ai-is-everywhere-except-the-balance-sheet-184c
https://www.worldprogramming.org/posts/ai-is-everywhere-except-the-balance-sheet-8pdhrs
Python Generators 與 Iterators：處理大型資料而不讓記憶體爆掉
當 Python 腳本開始消耗數百 MB 的 RAM 時，直覺反應通常是改用更快的語言或更進階的資料庫。但大多數情況下，真正的問題簡單得多：程式碼一次就把整個資料集載入記憶體。Generators（Python 的惰性求值主力）讓你一次只處理一筆資料，它們是你能加入 Python 工具箱中最高槓桿的概念之一。
顯而易見的記憶體問題
考慮一個常見任務：讀取大型日誌檔案並計算有多少行包含「error」這個字。最直接的寫法看起來無害：
def count_errors(path):
with open(path) as f:
lines = f.readlines() # loads EVERYTHING into memory
return sum(1 for line in lines if "error" in line.lower())
Enter fullscreen mode
Exit fullscreen mode
對 10 MB 的檔案來說這執行得很好。但對 4 GB 的日誌檔案，readlines() 會很開心地試圖把全部 4 GB 都放在 RAM 中——而在記憶體上限只有 2 GB 的共享伺服器上，這個行程就會被終止。修正方式只要改一個字：
def count_errors(path):
with open(path) as f:
return sum(1 for line in f if "error" in line.lower())
Enter fullscreen mode
Exit fullscreen mode
直接對檔案物件進行疊代會一次產生一行。作業系統會串流它，而你的記憶體用量不管檔案多大都會保持平穩。這就是 generator 的本質：它計算並產生一個值，然後暫停，直到下一個值被請求為止。
Generator 到底是什麼？
Generator 是一種特殊的 iterator，可以透過 generator 函式或 generator 運算式建立。其定義特徵是 yield 關鍵字。當函式包含 yield 時，呼叫它並不會執行函式主體——而是回傳一個你可以疊代的 generator 物件。
def read_large_file(path):
"""Yield one line at a time from a potentially huge file."""
with open(path) as f:
for line in f:
yield line.strip()
Enter fullscreen mode
Exit fullscreen mode
與會建立並回傳完整 list 的普通函式比較：
def read_all_lines(path):
with open(path) as f:
return [line.strip() for line in f] # materializes the whole list
Enter fullscreen mode
Exit fullscreen mode
Generator 版本幾乎使用固定記憶體。List 版本則會隨著檔案大小而擴展。對 5 GB CSV 進行互動式探索時，這種差異決定了工具是能即時回應還是讓機器凍結。
Generator 運算式與 List Comprehensions
Python 提供簡潔的語法來建立 generator，其外觀與 list comprehensions 相似。唯一的差別是使用小括號而非中括號：
squares_list = [x*x for x in range(1_000_000)] # list: ~8 MB allocated at once
squares_gen = (x*x for x in range(1_000_000)) # generator: lazy, one at a time
Enter fullscreen mode
Exit fullscreen mode
要注意一個細微之處：generator 是單次使用的。一旦被消耗，就會耗盡。如果你需要疊代兩次，就必須重新建立 generator 或把結果存成 list。
gen = (x for x in range(5))
print(list(gen)) # [0, 1, 2, 3, 4]
print(list(gen)) # [] -- already exhausted!
Enter fullscreen mode
Exit fullscreen mode
真正能節省記憶體的實用模式
1. 使用 islice 進行分塊處理
有時候你確實需要 generator 的一小段，但切片語法只能用在 sequence 上。itertools.islice 函式會惰性地逐步處理 generator，並回傳固定數量的項目：
from itertools import islice
def process_in_chunks(collection, chunk_size=1000):
iterator = iter(collection)
while True:
chunk = list(islice(iterator, chunk_size))
if not chunk:
break
process_chunk(chunk) # your batch logic here
Enter fullscreen mode
Exit fullscreen mode
這個模式非常適合將記錄分批送進資料庫，使用可管理的交易，而不是一次提交巨量資料。
2. 串流聚合
因為 generator 是惰性產生值的，你可以把多個轉換串接起來，而不會具體化任何中間 list：
import re
from collections import Counter
def log_errors(path):
with open(path) as f:
pattern = re.compile(r"errors*:s*(w+)")
for line in f:
match = pattern.search(line)
if match:
yield match.group(1)
code_counts = Counter(log_errors("app.log"))
print(code_counts.most_common(5))
Enter fullscreen mode
Exit fullscreen mode
Counter 只需要與不同錯誤代碼的數量成比例的記憶體，這通常很小，而不是與日誌行數成比例。
3. yield from 快捷方式
Generator 委託能讓一個 generator 乾淨地交接給另一個。yield from 會把來自內部 iterable 的每個項目轉發出去，這在組合資料管線時特別有用：
def read_lines(paths):
for path in paths:
with open(path) as f:
yield from f # delegate to the inner iterable
for line in read_lines(["a.log", "b.log", "c.log"]):
...
Enter fullscreen mode
Exit fullscreen mode
什麼時候不該使用 Generator
Generator 不是萬靈丹。了解它們的限制可以避免誤用：
| 情境 | 該使用 generator 嗎？ | 原因 |
|---|---|---|
| 大型檔案、即時串流、無限序列 | ✅ 是 | 固定記憶體勝出 |
| 需要對元素進行隨機存取 | ❌ 否 | Generator 沒有索引 |
| 需要對相同資料疊代兩次 | ⚠️ 有時 | 必須重新建立或儲存 |
| 小型資料集 | 🤷 皆可 | 額外負擔不值得 |
| 隨機存取 / 回溯 | ❌ 否 | 只能單次通過 |
Generator 是一種單向串流。你無法倒帶，無法在不經過 0 到 4 的元素的情況下跳到第 5 個元素，也無法在不耗盡它的情況下知道它的長度。如果你的演算法需要隨機存取，請保留 list 或使用其他結構。
完整實作範例：在固定記憶體下進行日誌分析
讓我們把這些片段組合起來。這個腳本讀取大型應用程式日誌、計算錯誤等級，並回報前五名的錯誤類型——同時不管檔案大小如何，都能保持記憶體用量平穩：
import re
from collections import Counter
from itertools import islice
PATTERN = re.compile(r"[(?P<level>w+)]s+.*?b(?P<code>w+Error)b", re.IGNORECASE)
def scan_errors(path):
with open(path) as f:
for line in f:
match = PATTERN.search(line)
if match:
yield match.groupdict()
def report(path, limit=5):
level_counts = Counter()
code_counts = Counter()
for chunk in iter(lambda: list(islice(scan_errors(path), 5000)), []):
for entry in chunk:
level_counts[entry["level"]] += 1
code_counts[entry["code"]] += 1
print("Levels:", level_counts.most_common())
print("Top codes:", code_counts.most_common(limit))
if __name__ == "__main__":
report("app.log")
Enter fullscreen mode
Exit fullscreen mode
iter(lambda: list(islice(...)), []) 迴圈是一種簡潔的方式，能拉取固定大小的批次直到 generator 耗盡。每個批次都很小，處理完後會被釋放，然後才處理下一個批次。
進階提示：將值傳送進 Generator
Generator 也可以透過 send() 接收 值，這讓它們變成輕量級的 coroutine。這在簡單的資料處理中很少需要，但它解鎖了雙向通訊：
def accumulator():
total = 0
while True:
received = yield total # yield current total, then wait for input
if received is not None:
total += received
acc = accumulator()
print(next(acc)) # 0 -- prime the generator
print(acc.send(10)) # 10
print(acc.send(5)) # 15
Enter fullscreen mode
Exit fullscreen mode
這個模式是更進階非同步模式和有狀態處理管線的基礎。對大多數日常任務來說你永遠不會需要它，但知道它的存在能幫助你在函式庫程式碼中遇到時認出底層機制。
使用類別建立自己的 Iterator
如果你需要自訂的疊代行為並結合其他方法，可以建立一個實作 __iter__ 和 __next__ 的 iterator 類別。Generator 函式通常比較簡單，但類別形式在需要更豐富狀態的情況下值得了解：
class Countdown:
def __init__(self, start):
self.current = start
def __iter__(self):
return self
def __next__(self):
if self.current <= 0:
raise StopIteration
self.current -= 1
return self.current
Enter fullscreen mode
Exit fullscreen mode
惰性資料處理的實用檢查清單
當你接手一個被記憶體淹沒的腳本時，請執行以下檢查清單：
- 將
readlines()替換為直接對檔案物件進行疊代。 - 將餵給
sum、any、all或Counter的 list comprehensions 轉換為 generator 運算式。 - 將資料庫操作分批進行，而不是逐行插入或一次全部插入。
- 使用
sys.getsizeof在樣本上驗證——但請注意 generator 不會回報它們「可能」的內容，所以請測量你正在替換的 list 版本。 - 如果有可用的記憶體工具就用它來分析；否則就用系統監視器觀察常駐集大小。
總結
Generator 讓 Python 能夠處理否則會耗盡記憶體的資料集，並鼓勵乾淨、串流的程式設計風格。核心概念雖然小卻很強大：
-
yield將函式轉變成惰性 generator。 - Generator 運算式與 comprehensions 相似，但不會積極地建立任何東西。
- 單次通過、串流演算法與 generator 完美契合。
- 使用
itertools.islice進行惰性分塊，並使用yield from進行委託。 - 當你需要隨機存取或重複疊代時，請避免使用 generator。
下次當腳本變得極慢或因記憶體不足而死亡時，找出那個隱藏的 readlines()。用 generator 替換它通常只要改兩行，就能將脆弱的腳本轉變成能擴展到任意大小檔案的版本。
LLM 現在可以呼叫工具，但將其輸出轉換成可信任的事件串流仍然是個難題。我們將 Claude 的函式呼叫連接至 SNS FIFO 主題，為您提供有序、去除重複的通知，讓下游 Lambda 函式能夠以零遺失保證進行消費。
為什麼 SNS FIFO 適合用於 LLM 生成的事件
當 LLM 決定要「publishAlert」時，您通常會希望警報能完全按照它產生的順序被處理。想像一個火警系統，先發出煙霧偵測器的警告，接著發出灑水器啟動指令。如果這兩則訊息順序顛倒，您可能會在火災尚未確認前就啟動灑水器。
FIFO 代表 First‑In‑First‑Out（先進先出）。SNS FIFO 主題保證具有相同 MessageGroupId 的訊息會按照發佈的確切順序傳遞給訂閱者。這與預設的「標準」SNS 主題不同，後者雖然傳遞迅速，但不保證順序。
用白話來說：SNS FIFO 就像一條單線道道路，配有紅綠燈讓車輛（訊息）一輛接一輛通過，絕不超車。
關鍵術語（首次使用）
| 術語 | 含義 |
|---|---|
| Function calling | LLM 可以呼叫預先定義的工具（一段程式碼），而非僅回傳文字的功能。 |
| FIFO topic | 一種 SNS 主題，能保留屬於同一邏輯群組的訊息順序。 |
| MessageGroupId | 告訴 SNS 哪些訊息屬於同一群組以進行排序的識別碼。 |
| MessageDeduplicationId | 防止同一訊息在 5 分鐘窗口內被傳遞兩次的 token。 |
| Lambda | 一種無伺服器運算服務，會根據事件（例如 SNS 訊息）執行程式碼。 |
因為 LLM 可能快速產生許多警報，使用 FIFO 主題能讓您將 AI 視為確定性生產者，而非混亂的聊天機器。下游 Lambda 會看到警報的順序與模型發出它們的順序相同。
設定 Claude 的函式呼叫以發佈至 SNS
在能將任何東西發送到 SNS 之前，Claude（LLM）需要知道您所公開的工具。在 Claude 的術語中，tool schema 描述了名稱、描述以及它可以傳遞的引數 JSON 結構。
以下是一個最小的 TypeScript 程式碼片段，它建立了一個名為 publishAlert 的工具。函式主體使用 AWS SDK v3（@aws-sdk/client-sns）將訊息推送到 FIFO 主題。請注意 satisfies 關鍵字的使用——它告訴 TypeScript「此物件符合我描述的形狀，但不要拓寬型別」。
// src/claudeTool.ts
import { SNSClient, PublishCommand } from "@aws-sdk/client-sns";
// ---------------------------------------------------------------------
// 1️⃣ Prepare the SNS client – it will read credentials from the
// environment (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, etc.).
// ---------------------------------------------------------------------
const snsClient = new SNSClient({ region: "us-east-1" });
// ---------------------------------------------------------------------
// 2️⃣ Define the shape of the arguments Claude is allowed to send.
// This is the contract between the LLM and our code.
// ---------------------------------------------------------------------
type PublishAlertArgs = {
/** Human‑readable title of the alert */
title: string;
/** Optional JSON payload that downstream systems care about */
payload: Record<string, unknown>;
/** Group ID to keep ordering – e.g., a device ID or tenant ID */
groupId: string;
};
// ---------------------------------------------------------------------
// 3️⃣ The tool schema Claude will load. The `satisfies` keyword forces
// the object to be exactly the type we described above.
// ---------------------------------------------------------------------
export const publishAlertTool = {
name: "publishAlert",
description: "Publish an ordered alert to an SNS FIFO topic",
input_schema: {
type: "object",
properties: {
title: { type: "string" },
payload: { type: "object" },
groupId: { type: "string" },
},
required: ["title", "groupId"],
additionalProperties: false,
},
} satisfies { name: string; description: string; input_schema: object };
// ---------------------------------------------------------------------
// 4️⃣ The implementation that Claude will invoke. It builds the SNS
// PublishCommand with the required FIFO fields.
// ---------------------------------------------------------------------
export async function publishAlert(args: PublishAlertArgs): Promise<void> {
const { title, payload, groupId } = args;
// A stable deduplication ID – you could hash the payload, add a timestamp,
// or use a UUID if you need absolute uniqueness.
const dedupId = `${groupId}-${Date.now()}`;
const command = new PublishCommand({
// The ARN of the FIFO topic you created (ends with .fifo)
TopicArn: process.env.ALERTS_FIFO_TOPIC_ARN,
// Message body – keep it short; you can embed a JSON string if needed.
Message: JSON.stringify({ title, payload }),
// Guarantees ordering for all alerts that share this groupId.
MessageGroupId: groupId,
// Prevents the same alert from being sent twice within 5 minutes.
MessageDeduplicationId: dedupId,
});
// Send the command; any error will bubble up to Claude as a tool failure.
await snsClient.send(command);
}
Enter fullscreen mode
Exit fullscreen mode
提示：如果您需要在重試時達成exactly‑once 語意，請保持
MessageDeduplicationId為確定性的（例如 payload 的雜湊值）。
LLM 會在決定應該發出警報時呼叫 publishAlert。您的應用程式只需將 publishAlertTool 描述公開給 Claude，並將 publishAlert 實作繫結到工具處理程式即可。
設定具有訊息分組與去重複功能的 SNS FIFO 主題
建立 FIFO 主題是一次性的操作，但有幾個隱藏規則會讓許多工程師吃虧：
- FIFO 主題需要匹配的 FIFO 訂閱——您無法訂閱標準 SQS 佇列或非 FIFO 感知的 HTTP 端點。
- 訊息屬性每個訂閱限制為五個——請盡量保持中繼資料最小化。
- 傳遞重試是針對每個訂閱者。如果 Lambda 呼叫失敗，SNS 最多會重試三次，然後在沒有監控 CloudWatch 指標的情況下默默放棄。
以下是一個小型腳本，它會建立 FIFO 主題、設定必要屬性，並新增 Lambda 訂閱。程式碼使用相同的 SDK（@aws-sdk/client-sns）並示範了容易忽略的細節。
// scripts/createFifoTopic.ts
import {
SNSClient,
CreateTopicCommand,
SubscribeCommand,
SetTopicAttributesCommand,
} from "@aws-sdk/client-sns";
// ---------------------------------------------------------------------
// 1️⃣ Initialize the client (same region as your Lambda)
// ---------------------------------------------------------------------
const sns = new SNSClient({ region: "us-east-1" });
async function main() {
// -----------------------------------------------------------------
// 2️⃣ Create the FIFO topic. The name MUST end with ".fifo".
// -----------------------------------------------------------------
const createResp = await sns.send(
new CreateTopicCommand({
Name: "ai-alerts.fifo",
Attributes: {
// FIFO topics need these two flags.
FifoTopic: "true",
// Optional: set a default message group to avoid errors if you forget.
// We'll enforce explicit group IDs later.
ContentBasedDeduplication: "false",
},
})
);
const topicArn = createResp.TopicArn!;
console.log("✅ FIFO topic created:", topicArn);
// -----------------------------------------------------------------
// 3️⃣ Attach a Lambda subscriber (replace with your function ARN).
// -----------------------------------------------------------------
const lambdaArn = process.env.ALERTS_LAMBDA_ARN!;
await sns.send(
new SubscribeCommand({
Protocol: "lambda",
TopicArn: topicArn,
Endpoint: lambdaArn,
})
);
console.log("✅ Lambda subscribed:", lambdaArn);
// -----------------------------------------------------------------
// 4️⃣ (Optional) Add a dead‑letter queue (DLQ) via a subscription
// attribute – note that SNS FIFO does NOT create a DLQ automatically.
// -----------------------------------------------------------------
await sns.send(
new SetTopicAttributesCommand({
TopicArn: topicArn,
AttributeName: "RedrivePolicy",
AttributeValue: JSON.stringify({
deadLetterTargetArn: process.env.ALERTS_DLQ_ARN,
}),
})
);
console.log("✅ DLQ attached (if provided).");
}
main().catch((err) => {
console.error("❌ Error creating topic:", err);
process.exit(1);
});
Enter fullscreen mode
Exit fullscreen mode
重要心得：FIFO 主題的可靠性取決於其訂閱者。確保您附加的 Lambda 已準備好處理重試，並考慮手動連接死信佇列，因為 SNS 預設不會新增。
常見陷阱深入探討
-
去重複窗口——SNS 會記住每個
MessageDeduplicationId達5 分鐘。如果您在該窗口內重複使用相同 ID，第二則訊息會在沒有任何錯誤的情況下消失。為了避免無聲丟失，請為每次發佈產生新的 ID（如範例所示），或啟用ContentBasedDeduplication讓 SNS 對Message主體進行雜湊。 -
跨群組的排序——SNS 只保證單一
MessageGroupId內部的順序。如果您為兩個不同裝置發佈警報（groupId = "deviceA"和"deviceB"），它們的相對順序是不確定的。請設計您的下游邏輯，讓每個群組獨立處理，或將所有內容透過單一群組傳送（如果需要真正的全域順序，代價是降低吞吐量）。
使用 Lambda 訂閱者消費有序事件
現在警報已流入 SNS，我們需要一個尊重排序並記錄 payload 的 Lambda。我們目標的 Lambda 執行環境是 Node.js 22，最新的 LTS 版本。請注意兩個 Lambda 特定的陷阱：
-
Node 22 中的
require(esm)可能會默默破壞現有的 Lambda 層——請務必使用原生 ESM（import …）或繼續使用 CommonJS。 - Provisioned Concurrency（預熱）即使在閒置時也會產生費用——在啟用前請先監控使用量。
以下是一個直接的處理程式，它會提取 SNS 訊息、剖析 JSON payload，並記錄警報。它也會明確確認訊息，方法是成功回傳；任何未捕捉的錯誤都會導致 SNS 重試傳遞。
// src/alertProcessor.ts
import { SQSEvent, SNSEvent, Context } from "aws-lambda";
/**
* Lambda entry point – SNS will invoke this function for each batch
* of messages that share the same MessageGroupId.
*/
export async function handler(event: SNSEvent, _ctx: Context): Promise<void> {
// SNS may deliver multiple records in one invocation.
for (const record of event.Records) {
// -----------------------------------------------------------------
// 1️⃣ The raw message body is a string; we expect JSON.
// -----------------------------------------------------------------
const raw = record.Sns.Message;
let parsed: { title: string; payload?: Record<string, unknown> };
try {
parsed = JSON.parse(raw);
} catch (e) {
// If parsing fails, we *must* let the error bubble up so SNS retries.
console.error("❌ Failed to parse SNS message:", raw);
throw e;
}
// -----------------------------------------------------------------
// 2️⃣ Log the alert – in a real system you would forward it to a DB
// or another service.
// -----------------------------------------------------------------
console.log(
`🔔 Alert [${record.Sns.MessageGroupId}]: ${parsed.title}`,
parsed.payload ?? {}
);
}
// Returning without error tells SNS the batch was processed.
}
Enter fullscreen mode
Exit fullscreen mode
要將此函式連接至 SNS 主題，您可以使用 AWS 主控台或 CDK/CloudFormation。關鍵設定如下：
| 設定 | 值 | 為什麼重要 |
|---|---|---|
| Runtime | nodejs22.x |
支援最新的語言功能和 SDK v3。 |
| Memory | 128 MiB（如果 payload 較大則更高） | 影響最大並行呼叫次數；保持低以節省成本。 |
| Timeout | 30 秒（預設） | 對於簡單記錄應該足夠；如果進行大量工作則增加。 |
| Dead‑letter queue | 可選，但建議使用 | SNS 重試三次；之後訊息會遺失，除非 DLQ 捕捉它。 |
提示：為 Lambda 啟用 CloudWatch Logs，並針對
InvocationErrors設定警示。因為 SNS 重試是針對每個訂閱者，無聲的 Lambda 失敗可能導致未傳遞的警報。
測試與除錯端到端流程
可靠的系統取決於您對它執行的測試。以下步驟讓您能在不部署到正式環境的情況下驗證排序、去重複和錯誤處理。
1️⃣ 本機「Claude」模擬
建立一個小型腳本，使用相同的 groupId 呼叫 publishAlert 幾次。在呼叫之間使用短暫的 setTimeout 來模擬快速的 LLM 輸出。
// scripts/simulateClaude.ts
import { publishAlert } from "../src/claudeTool";
async function main() {
const groupId = "device-123";
// Fire three alerts in quick succession.
await publishAlert({
title: "Temperature high",
payload: { temp: 78 },
groupId,
});
await publishAlert({
title: "Temperature critical",
payload: { temp: 92 },
groupId,
});
await publishAlert({
title: "Shutdown initiated",
payload: { reason: "overheat" },
groupId,
});
console.log("✅ All alerts sent.");
}
main().catch((e) => {
console.error("❌ Simulation failed:", e);
});
Enter fullscreen mode
Exit fullscreen mode
執行 ts-node scripts/simulateClaude.ts。然後檢查 Lambda 記錄——您應該會看到三個警報以相同順序出現。
2️⃣ 驗證去重複功能
修改腳本以重複使用相同的 MessageDeduplicationId（透過傳遞常數 dedupId 到 publishAlert）。您只會在 Lambda 記錄中看到第一則訊息；其他訊息會被默默丟棄。這示範了 5 分鐘窗口規則。
3️⃣ 強制 Lambda 錯誤
加入一行程式碼，在特定警報（例如當 title 包含「critical」時）拋出例外。部署 Lambda，再次執行模擬，並觀察 CloudWatch。您會看到失敗的呼叫被重試三次，然後消失，除非您有連接 DLQ。
用白話來說：如果 Lambda 崩潰，SNS 會再嘗試三次，然後放棄。如果沒有死信佇列，該警報就會永遠遺失。
4️⃣ 使用 CloudWatch Insights 確認排序
在 CloudWatch Logs Insights 中執行以下查詢：
fields @timestamp, @message
| filter @message like /Alert/
| sort @timestamp asc
| limit 20
Enter fullscreen mode
Exit fullscreen mode
sort asc 會顯示確切的到達順序。如果您看到相同 groupId 的訊息出現順序錯亂，請再次確認您使用的是 FIFO 主題，且批次中的 MessageGroupId 完全相同。
總結
您現在擁有的：一種模式，能夠只使用 AWS 管理的服務，將 Claude 的工具呼叫轉換成可靠、有序的事件串流。
-
FIFO 主題維持每個群組的順序——每個共用
MessageGroupId的警報會以發佈時的確切順序到達訂閱者。 - 去重複 ID 能防止意外重複，但必須在 5 分鐘內保持唯一；否則 SNS 會默默丟棄後續訊息。
- SNS 重試是針對每個訂閱者，因此監控 Lambda 錯誤並選擇性新增死信佇列至關重要。
- Lambda 的簡單處理程式可以安全地記錄或轉發警報；只要確保在沒有錯誤的情況下回傳，即可確認訊息。
- 在本機測試（模擬 Claude、強制錯誤、檢查 CloudWatch）能在問題到達正式環境前捕捉排序與去重複的錯誤。
有了這些元件，您可以讓 Claude 作為系統的大腦，而 SNS FIFO 和 Lambda 則作為神經系統，可靠地依序傳遞訊號且無遺失。祝您 coding 愉快！
透明度聲明
本文是在 AI 系統的協助下撰寫的——Groq（GPT OSS 120B）。
發佈日期：2026-08-26 · 主要焦點：SNS
所有程式碼區塊都旨在正確且可執行，但在正式環境使用前，請務必根據所提及工具的官方文件進行驗證。
發現錯誤？請留言——隨時歡迎修正。
本週又出現另一則新聞標題：據報有威脅行為者正在出售約 360 萬筆從多個財富 500 強公司的 Microsoft Azure 環境中竊取的員工紀錄。 這並非孤立事件——追蹤外洩事件的團體正朝著超越去年通報資料外洩紀錄的步伐前進，而其中很大一部分來自第三方暴露：不是你信任的公司，而是某個安靜地坐在你工作流程中間的工具或供應商。
如果你是開發者，這個第三方類別值得好好思考，因為它包括了我們大多數人經常使用卻最少思考的工具：隨機的線上 JSON 格式化工具、regex 測試器，或 Base64 解碼器，我們在凌晨 11 點為了除錯而把真實資料貼進去。
想想那些工具實際上會經過什麼。API 金鑰、驗證權杖、生產環境酬載的片段、你試圖重新格式化以用於錯誤報告的客戶資料。我們大多數人不會停下來檢查剛才貼上資料的網站是否正在記錄它、儲存它，或是將它傳送到第三方伺服器進行「分析」。它只是一個格式化工具，感覺用完即丟，但其實並非如此。
這正是我建立 FormatStack 所要避免的問題。
你的資料完全不會有伺服器來回傳輸，徹底杜絕。 JSON 格式化工具、regex 測試器、UUID 產生器、Base64 編碼/解碼器，以及 cron 剖析器 全部都在你的瀏覽器內完全執行——純 JS，沒有框架，沒有後端呼叫攜帶你貼上的內容到任何地方。你所貼上的內容永遠不會離開你的機器。不是「我們不會記錄它」（這是一種你必須信任的政策）——而是在架構上它根本無法離開，因為沒有任何端點可以讓它傳送出去。
鑑於今年外洩數量越來越多是由原本不需要存放在某處的資料所驅動，「資料永遠不會離開你的瀏覽器」並非可有可無的特色。對除錯工具來說，這才是唯一真正合理的架構。
如果你想看看或是自己驗證這個說法：formatstack.tech
身為開發者，我們早已超越將 AI 視為「類固醇版的自動完成」的階段。如今，真正的生產力提升來自於將 AI 深度整合到整個軟體開發生命週期 (SDLC) 中。
在本文中，我將帶領你走過我使用 GitHub Copilot 的日常工作流程——從透過 Model Context Protocol (MCP) 整合分析 Jira 票證，到最終確定架構方法、除錯，以及產生完整的測試套件。
1. 設定：工具與快捷鍵
在深入工作流程之前，你需要有合適的環境。
先決條件：
- 一個 IDE（VS Code 或 IntelliJ IDEA）。
- 已安裝 GitHub Copilot 和 GitHub Copilot Chat 擴充功能。
- Jira 整合： 為了讓 Copilot 能夠讀取你的 Jira 看板，你需要啟用 Jira Copilot 擴充功能（或如果你使用自訂企業 LLM 包裝器，則需設定 MCP 伺服器）。這能讓你在聊天中直接使用
@jira來引用票證。
重要 Copilot 快捷鍵速查表：
- 內嵌聊天：
Cmd + I(Mac) /Ctrl + I(Windows) —— 這是你會使用到最重要的快捷鍵。 - 開啟聊天面板：
Cmd + Ctrl + I/Ctrl + Alt + I - 接受建議：
Tab - 下一個/上一個建議：
Option + ] / [/Alt + ] / [ - 手動觸發建議：
Option +/Alt +
2. 第一階段：問題分析與理解（Jira/MCP 整合）
開發過程中最大的時間消耗並非撰寫程式碼，而是理解該寫「什麼」程式碼。將 Copilot 與 Jira 連結後，你就能跳過上下文切換的步驟。
不用再開啟 Jira、閱讀冗長的討論串並試圖解析實際需求，我會直接開啟 Copilot Chat 並輸入提示：
@jira Summarize ticket PROJ-1234. What are the core acceptance criteria and which specific microservices are likely impacted based on the description?
Copilot 透過整合解析票證，並提供簡潔的項目符號需求清單。如果票證內容模糊，我會使用 Copilot 產生澄清問題來詢問產品負責人。
3. 第二階段：確定方法
一旦需求明確，我不會立即開始撰寫程式碼。我會使用 Copilot Chat 作為討論平台來最終確定我的架構方法。
假設票證需要發布一個新的領域事件，我會開啟 Copilot Chat 並寫下：
I need to implement the requirements from PROJ-1234. I am considering using Apache ActiveMQ Artemis for asynchronous messaging between the Order Service and the Billing Service. Can you outline a high-level approach for this, including potential drawbacks like message duplication?
Copilot 就像資深的配對夥伴，驗證方法、提醒我邊緣案例（例如冪等性），並建議大致的步驟順序。這確保我在寫任何一行 Java 程式碼之前，邏輯都是穩固的。
4. 第三階段：撰寫程式碼、除錯與修正
方法確定後，我就開始實作。
撰寫程式碼：
我大量依賴 內嵌聊天 (Cmd/Ctrl + I)。我會在類別內選取一塊空白區域並提示：
Create a REST endpoint to process incoming claims. It should validate the payload, save it to the DB, and publish an event to the Artemis MQ topic 'claims.incoming'.
除錯與重構：
當出現問題時，Copilot 在根本原因分析上表現出色。如果複雜的串流操作拋出 NullPointerException 或未通過邏輯檢查，我會選取程式碼並在聊天中使用 /explain 或 /fix 斜線指令。
/fix This method is throwing a ConcurrentModificationException when processing a batch of claims larger than 1000. How can we safely chunk or process this?
Copilot 不僅提供修正後的程式碼片段，還會解釋錯誤「為什麼」發生，幫助我在過程中學習。
5. 第四階段：單元與整合測試產生
撰寫測試對於零缺陷部署至關重要，但撰寫 Mockito 的樣板設定可能相當繁瑣。Copilot 大幅加速了這個過程。
當服務類別完成後，我會開啟它，按下 Cmd/Ctrl + I，然後輸入：
/tests Generate comprehensive JUnit 5 tests for this class using Mockito. Include edge cases for null inputs, database connection timeouts, and successful message publishing.
Copilot 會產生測試檔案，並包含 @Mock 和 @InjectMocks 註解。
整合測試小技巧： 對於需要 Docker 或 Testcontainers 的複雜整合測試，我會提供 Copilot 一個我們程式碼庫中現有整合測試的範例，然後說：
Using this file as a template, generate an integration test for the new ClaimProcessingService.
結論
GitHub Copilot 已不再只是程式碼補全工具；它是一個具備上下文意識的開發助手。將它整合到每一個步驟中——從透過 MCP 理解 Jira 需求，到腦力激盪架構與產生 Mockito 測試套件——你可以省下數小時的樣板工作和上下文切換，讓自己專注於解決複雜的工程問題。
你已經將 Copilot 與你的專案管理工具整合了嗎？在留言中分享你最喜歡的提示吧！
延伸閱讀與資源
如果你想自己設定這個工作流程，以下是幫助你入門的官方文件：
- GitHub Copilot Official Documentation
- Using GitHub Copilot in your IDE
- Model Context Protocol (MCP) Introduction
免責聲明：本文所詳述的工作流程、架構概念與工程經驗皆為我個人心得。我使用了 AI 工具來協助此文字的格式化、結構化與措辭。
人工智慧分析了散布在數百篇研究論文中的資料，發現了新的無鉛介電材料，即使在高溫下也能維持穩定的性能。這項研究提出了一種新方法，能夠將材料發現從試錯過程轉變為資料驅動的過程。
首爾大學工學院宣布，由材料科學與工程系張鎬元教授領導的研究團隊，開發了一種結合從科學文獻中萃取的資料與物理資訊機器學習的技術，用以設計無鉛介電材料。整合碩博士生宋寬宇擔任第一作者並主導整體研究，整合碩博士生金英敏和博士後研究員金宰鉉則參與了這項合作研究。
介電材料是防止電流直接流動同時儲存電荷的絕緣材料，它們是智慧型手機、電動車和其他電子裝置中使用的多層陶瓷電容器（MLCC）的關鍵材料。介電常數越高，相同尺寸的元件所能儲存的電能就越多。然而，為了在電子裝置中實際應用，介電性能也必須在高溫下保持穩定。
研究團隊結合多模態文獻挖掘（自動從科學論文的文字、表格和圖表中萃取分散資訊）與物理資訊機器學習，開發出一種逆向設計方法，首先找出具有高機率滿足目標性能需求的成分。在從448篇論文中建構出1,202筆介電性能記錄的資料集後，研究人員探索了約1.5億種虛擬成分空間，並將其縮減至37個候選材料。隨後他們合成其中兩種成分，並透過實驗確認了兩者皆具備高介電常數和優異的高溫穩定性。
研究結果發表於Nature Communications期刊，連結。
介電材料中的搜尋問題
隨著更多電子裝置在高溫下運作，包括電動車、電力電子和航太設備，能夠在溫度波動下維持穩定性能的介電材料的重要性日益增加。特別是弛豫型鐵電體，其電響應隨溫度變化相對緩慢，具有將高介電常數與寬廣溫度範圍穩定性結合的潛力。
然而，即使將搜尋限制在無鉛成分，由於元素和混合比例的可能組合極多，潛在候選材料的數量幾乎是無限的，這使得試錯探索既昂貴又耗時。此外，相關資料分散在不同論文的文字、表格和圖表中，而測量條件如溫度、頻率和樣品特性在各研究間也有所不同，使得這些資料難以直接用於機器學習訓練。
為了解決這些挑戰，研究人員開發了一個機器學習框架，能夠將分散在多篇論文中的資訊整合成統一格式，同時納入物理定律來篩選實際可能存在的材料。團隊使用大型語言模型來整理研究論文文字和表格中的成分與製程條件，同時將圖表轉換為數值資料以萃取溫度依賴的介電性能。
從1.5億縮減至37
此過程產生了涵蓋448篇論文中成分、製程條件和介電性能的1,202筆記錄。研究人員接著納入22個物理描述符，包括元素成分和微結構，將分散在不同出版品中的資訊整合成統一的訓練資料集。接下來，他們結合30個獨立訓練的機器學習模型，同時預測與介電常數和溫度穩定性相關的三項關鍵指標。該框架還設計用來評估模型預測之間的一致性，從而優先考慮具有較高預測信心的候選材料。
在依序對約1.5億種虛擬成分應用預定義的性能目標和物理化學限制後，團隊將搜尋空間縮減至37個候選材料。研究人員接著在剩餘候選材料數量最多的成分家族內微調成分比例，並選出兩種成分進行實驗測試。
實驗顯示，這兩個樣品分別取代1 mol%和2 mol%的錫（Sn），在室溫下分別展現3,422和3,307的高介電常數。少量的Sn取代產生了有利的權衡，在不大幅降低介電常數的情況下改善了溫度穩定性。
與目前廣泛用於多層陶瓷電容器的鈦酸鋇（BaTiO₃）相比，新開發的材料在更寬廣的溫度範圍內也能更一致地維持高介電常數。兩個樣品都滿足國際X5R、X6R和X7R多層陶瓷電容器的高溫穩定性要求，並在與先前報導的相同成分家族材料資料相比時，記錄了最高的介電常數之一。
X5R、X6R和X7R：用於多層陶瓷電容器的介電材料溫度穩定性分類，一般表示介電常數在25°C時的值從−55°C起至85°C、105°C和125°C是否保持在±15%以內。
錫如何改善穩定性
研究人員將機器學習模型決策洞見與壓電力顯微鏡、拉曼光譜和原子解析度電子顯微鏡的結果相結合。他們的分析揭示了少量Sn如何擴大晶體框架並在原子尺度增加電異質性，從而提升溫度穩定性的潛在機制。
這項研究的重要性在於它展示了一種研究方法，使用AI整合並分析散布在科學文獻中的資料，然後將這些資料應用於新材料的設計。研究人員相信，此方法也可應用於開發各種其他材料，例如功能性氧化物和薄膜，其相關資料分散在眾多出版品中。本研究驗證的無鉛介電材料預計將應用於開發高溫多層陶瓷電容器，以及用於電動車、電力電子和航太系統的電子元件。
張教授表示：「這項研究的重要性不僅僅在於用機器學習預測性能，而在於將分散在多篇論文中的資訊整合成訓練資料集，然後同時考慮物理定律和模型預測之間的一致性，將搜尋範圍縮小到實際可以合成的候選材料。」
「我們希望本研究提出的策略——結合多模態文獻挖掘與物理資訊機器學習——能夠超越介電材料，擴展到其他功能性氧化物和薄膜材料的發現，這些材料的資料分散在眾多論文和格式中，因此需要系統性的整合。」
超越一類材料
身為研究第一作者的整合碩博士生宋寬宇主導了整個研究過程，從建構文獻衍生資料集、開發機器學習模型，到篩選候選材料和進行實驗驗證。他目前正在進行基於機器學習的新材料發現研究，將其工作擴展到各種電子材料，包括新的無鉛介電和MLCC成分，以及半導體電晶體的氧化物通道材料。基於這項研究經驗，他計劃繼續進行高性能電子和介電材料的研發。
與此同時，張教授的研究團隊先前曾使用AI發現並實驗驗證一種基於鎢單原子的非貴金屬水電解催化劑，用於綠氫生產，那項由博士後研究員金宰鉉擔任第一作者的研究也發表於Nature Communications，連結。
Who’s behind this story?
Gaby Clark
MA in English, copy editor since 2021 with experience in higher education and health content. Dedicated to trustworthy science news.
Full profile →
Robert Egan
Bachelor’s in mathematical biology, Master’s in creative writing. Well-traveled with unique perspectives on science and language.
Full profile →
Citation:
AI-driven literature mining speeds discovery of heat-stable lead-free dielectric materials (2026, August 20)
retrieved 20 August 2026
from https://phys.org/news/2026-08-ai-driven-literature-discovery-stable.html
This document is subject to copyright. Apart from any fair dealing for the purpose of private study or research, no
part may be reproduced without the written permission. The content is provided for information purposes only.
Claude 架構常見挑戰與解決方案：
- 有損摘要 vs. 不可變狀態分類帳
- 提示指令 vs. 程式碼層級強制執行
有損摘要 vs. 不可變狀態分類帳
情境
隨著長期代理會話累積聊天記錄，開發人員通常會引入上下文視窗優化技術—例如滾動滑動視窗或遞迴式 LLM 摘要—將舊的對話回合壓縮成簡潔的段落。
為何失敗
摘要本質上是有損壓縮。當 LLM 摘要對話時，它會抽象化特定細節以節省空間。精確、完全匹配的實體—例如交易 UUID、加密貨幣雜湊、發票號碼或嚴格的時間戳—經常被泛化或完全丟棄。如果使用者稍後引用 20 個回合前提到的訂單號碼，摘要記憶體儲存將會回傳遺漏或幻覺。
架構解決方案
實作分層記憶體架構。雖然對話歷史可以被摘要以維持流程，但關鍵交易資料必須保存在專用、不可變的側車結構中（通常稱為案例事實儲存或狀態分類帳）。僅附加的日誌確保精確的金鑰被逐字保留，完全與摘要引擎解耦。
提示指令 vs. 程式碼層級強制執行
情境
代理可以存取名為 execute_financial_transfer 或 modify_database_record 的工具。為了防止危險動作，開發人員在系統提示中加入嚴格規則：「未經明確經理批准，你絕對不能執行超過 500 美元的轉帳。」
為何失敗
基於提示的防護欄是機率性的建議，而非硬性安全邊界。透過間接提示注入、巧妙的措辭或模型漂移，LLM 很容易被說服繞過系統指令。依賴提示來強制執行硬性安全或金額限制會引入嚴重的安全漏洞。
架構解決方案
透過程式化攔截實作深度防禦。在任何工具酬載被發送到外部 API 或資料庫之前，必須通過程式碼層級的中介軟體或 PreToolUse 鉤子。業務邏輯檢查（例如 if payload[‘amount’] > 500: raise ValidationError）必須存在於模型無法覆蓋或協商的確定性程式碼中。
https://dev.to/kobester_nz/claude-architecture-common-challenges-and-solutions-1293