DEV Community: Jambo

在 Jetson 運行 Live VLM WebUI

Jambo — Tue, 30 Dec 2025 11:42:44 +0000

Live VLM WebUI

Live VLM WebUI 是一個方便的介面,用於即時評估視覺語言模型:

🎥 多來源視訊輸入
- WebRTC 網路攝影機串流(穩定)
- 🧪 RTSP IP 攝影機支援(測試版)
🔌 OpenAI 相容 API - 與 Ollama、vLLM、NIM 或任何視覺 API 相容
- 🔧 靈活部署 - VLM 後端:本地推理或雲端 API
✍️ 互動式提示編輯器 - 8 個預設提示 + 自訂提示
⚡ 非同步處理 - 影片流暢播放,同時 VLM 在背景處理影格

先決條件

支援的設備:

Jetson AGX Thor 開發者套件
Jetson AGX Orin (64GB)
Jetson AGX Orin (32GB)
Jetson Orin Nano (8GB)

JetPack 版本:

JetPack 6 (L4T r36.x)
JetPack 7 (L4T r38.x)

儲存空間: 強烈建議使用 NVMe SSD

live-vlm-webui 容器約需 4 GB
在 Ollama 上拉取(下載)模型所需的空間(如果在本地運行)

概述

視覺語言模型現在可以在適合邊緣部署的大小中使用,從 4b 到 90b+ 參數。開放權重模型包括 Qwen 2.5/3 VL、Gemma 3、Llama 3.2/4 Vision、Phi-3.5-vision,以及 NVIDIA 的 Cosmos-Reason1 和 Nemotron Nano VL。

可用的開放權重 VLM 模型

創建者	模型名稱	大小
Alibaba	Qwen 2.5 VL	3b, 7b, 32b, 72b
Alibaba	Qwen 3 VL	2b, 4b, 8b, 30b, 32b, 235b
Google	Gemma 3	4b, 12b, 27b
Meta	Llama 3.2-Vision	11b, 90b
Meta	Llama 4	16x17b, 128x17b
Microsoft	Phi-3.5-vision	4.2b
NVIDIA	Cosmos-Reason1	7b
NVIDIA	Nemotron Nano 12B V2 VL	12b

即時測試 VLM 存在特定挑戰:

Open WebUI 等網頁介面需要手動上傳圖片(無串流)
缺乏跨平台統一的基準測試工具
有限的即時 GPU 監控整合

Live VLM WebUI 通過提供基於 WebRTC 的介面來解決這些差距,用於即時視覺推理測試並整合系統監控。

入門指南

步驟 1: 準備 VLM 後端 (Ollama)

首先,安裝 Ollama 作為後端來服務 VLM。Ollama 官方安裝程式支援 Jetson。

# Linux/Mac 的 Ollama 安裝程式
curl -fsSL https://ollama.com/install.sh | sh

# 下載推薦模型(輕量級)
ollama pull gemma3:4b

# 或其他視覺模型
# ollama pull llama3.2-vision:11b
# ollama pull qwen2.5-vl:7b

警告 - Jetson Thor (JetPack 7.0) 使用者: Ollama 0.12.10 在 Jetson Thor 上存在 GPU 推理問題。請使用版本 0.12.9:
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.12.9 sh

步驟 2: 安裝 Live VLM WebUI

git clone https://github.com/nvidia-ai-iot/live-vlm-webui.git
cd live-vlm-webui
./scripts/start_container.sh

步驟 3: 訪問網頁介面

打開您的網頁瀏覽器並導航至:

本地 URL: https://localhost:8090 (如果在同一台機器上運行瀏覽器)
網路 URL: https://<IP_ADDRESS>:8090 (從同一網路上的另一台設備訪問)

本地 URL: https://localhost:8090
網路 URL: https://10.110.50.252:8090

給 Jetson Orin Nano 使用者的提示: 建議使用連接在同一網路上的 PC,並遠端訪問網頁 UI,以獲得更好的效能。

如何使用 Live VLM WebUI

步驟 4: 配置並啟動

接受自簽名 SSL 證書

點擊 "進階" 按鈕
點擊 "繼續前往 (不安全)"
提示時允許相機訪問

驗證 VLM API 配置

介面會自動檢測本地 VLM 後端。在 "VLM API 配置" 部分驗證:

API 端點: http://localhost:11434/v1 (Ollama) 或 http://localhost:8000/v1 (vLLM)
模型: 已選擇的模型名稱(例如 gemma3:4b)

對於雲端 API,手動輸入端點和 API 密鑰。

啟動相機和 VLM 分析

點擊 "啟動相機並開始 VLM 分析" 並授予相機權限。介面開始根據配置的間隔串流和分析影格。

主要功能

即時顯示

右側主窗格顯示以下資訊:

1. 即時 AI 分析結果

VLM 輸出資訊 部分顯示:

右上角: 推理延遲、平均延遲、總分析次數
當前使用的 VLM 模型
當前提示 文字
分析結果文字(支援 Markdown)

2. 即時視訊串流

WebRTC 串流您的網路攝影機視訊,具有:

鏡像按鈕(左上角) - 面對相機時方便的鏡像顯示
覆蓋文字 - 分析結果覆蓋在視訊上(如果在設定中啟用)

3. GPU/CPU 監控

即時硬體使用監控:

GPU 使用率(使用 jtop)
VRAM 使用率(使用 jtop)
CPU 使用率
系統 RAM

詳細設定

左側設定選單允許您自訂配置和行為。

1. 提示自訂

最重要的設定是左側選單底部的 提示編輯器。

快速提示 - 8 個可立即使用的預設提示:

場景描述: "用一句話描述您在這張圖片中看到的內容。"
物體檢測: "列出您在這張圖片中看到的所有物體,用逗號分隔。"
活動識別: "描述人物的活動以及他們正在做什麼。"
安全監控: "是否有任何可見的安全隱患?用'警報:描述'或'安全'回答。"
情緒檢測: "描述可見人物的面部表情和情緒。"
無障礙: "為視障人士提供場景的詳細描述。"
OCR / 文字識別: "閱讀並轉錄圖片中可見的任何文字。"
是/否問題: "僅用是或否回答:是否有可見的人?"

自訂提示 - 在自訂提示欄位中輸入您自己的獨特提示。

提示: 許多模型,包括 gemma3:4b,支援多種語言。嘗試用不同語言指示模型並以該語言輸出。

即時提示工程

您可以執行我們可能稱之為 "即時視覺提示工程" 的操作。

例如,按原樣使用物體檢測提示可能會產生:

"這是我在圖片中看到的物體列表:人、桌子、顯示器..."

模型貼心地包含了序言。如果您想直接將其作為 CSV 饋送到下游應用程式,這不太方便,因此您可以自訂提示:

列出您在這張圖片中看到的所有物體,用逗號分隔。
不要以 "這是一個列表..." 開頭

這會抑制序言。這種即時評估能力是該工具的獨特優勢之一。

2. 後端配置

左側選單頂部的 VLM API 配置 支援多個 VLM 後端。

API 基礎 URL

如果 Ollama、vLLM 或 SGLang 在同一台機器上本地運行,會自動檢測
如果未檢測到,您可以指定雲端 API(預設設定為 NVIDIA API Catalog)
使用雲端 API 時,會出現 API 密鑰 欄位供您輸入憑證

模型選擇

查詢指定的 API 並列出可用模型。

3. 相機設定

左側選單中間的 相機和應用程式控制 部分處理相機選擇和相關設定。

相機選擇

列出客戶端 PC 上瀏覽器檢測到的所有相機。大多數現代筆記型電腦應該有可用的前置相機。如果直接在 Jetson 上使用桌面瀏覽器,請連接 USB 相機。

即使在 VLM 分析期間,您也可以切換相機。

影格處理間隔

WebRTC 相機影格處理(簡單地將影格從瀏覽器回傳到 UI 伺服器)和 VLM 分析處理非同步運行。

預設情況下,VLM 分析完成後,它會等待下一個可被 30 整除的影格編號,然後再開始下一次分析。

如果您想放慢分析速度以有更多時間閱讀每個結果,請增加這個數字。

RTSP 串流 (測試版)

暫時支援來自 IP 監控攝影機的 RTSP 串流。

測試尚未涵蓋許多相機,所以如果遇到問題,請在 GitHub 上回報。

已驗證的平台

平台	GPU	狀態	推理速度
PC (RTX 6000 Ada)	RTX 6000 Ada	✅	<1 秒/影格 (gemma3:4b)
Jetson Orin Nano 8GB	1024 核心 Ampere	✅	7-8 秒/影格 (gemma3:4b)
Jetson Thor 128GB	2560 核心 Blackwell	✅	1-2 秒/影格 (llama3.2-vision:11b)
DGX Spark	6144 核心 Blackwell	✅	1-2 秒/影格 (llama3.2-vision:11b)
Mac (M3)	Apple Silicon	✅	2-4 秒/影格 (gemma3:4b)
Windows (WSL2)	RTX A3000	✅	2-4 秒/影格 (gemma3:4b)

Jetson Orin Nano 效能

即使是最實惠的 Jetson,Jetson Orin Nano 開發者套件,也能透過 Ollama 成功運行 gemma3:4b!

雖然每個影格需要 7-8 秒處理,但它持續運行,為即時系統開啟了可能性。

故障排除

Jetson Thor (JetPack 7.0) 上的 Ollama GPU 錯誤

問題: Ollama 0.12.10 在 Jetson Thor 上的 GPU 推理失敗

解決方案: 降級到 Ollama 0.12.9:

# 停止並移除當前的 Ollama
sudo systemctl stop ollama
sudo rm /usr/local/bin/ollama

# 安裝 Ollama 0.12.9
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.12.9 sh

無法訪問相機

問題: 瀏覽器無法訪問網路攝影機或顯示 "權限被拒絕"

解決方案: 確保您使用的是 HTTPS(而非 HTTP):

start_container.sh 腳本預設啟用 HTTPS
在瀏覽器中接受自簽名證書警告(點擊 "進階" → "繼續")
現代瀏覽器需要 HTTPS 才能訪問網路攝影機

無法連接到 VLM 後端

問題: "連接失敗" 或 "連接被拒絕" 錯誤

解決方案:

驗證 VLM 是否正在運行:

# 對於 Ollama
curl http://localhost:11434/v1/models

# 對於 vLLM
curl http://localhost:8000/v1/models

檢查防火牆設定:

sudo ufw allow 11434  # Ollama
sudo ufw allow 8000   # vLLM

如果使用 Docker,確保網路模式:

# 使用主機網路訪問本地服務
docker run --network host ...

GPU 統計顯示 "N/A"

問題: GPU 監控對所有指標顯示 "N/A"

Jetson 的解決方案:

確保已安裝 jetson-stats:

sudo pip3 install -U jetson-stats
sudo reboot

授予容器訪問 jtop socket:

# 已包含在 start_container.sh 中
docker run -v /run/jtop.sock:/run/jtop.sock:ro ...

對於 Jetson Thor,從 GitHub 安裝:

sudo pip3 install --break-system-packages git+https://github.com/rbonghi/jetson_stats.git
sudo jtop --install-service
sudo reboot

效能緩慢 / 低 FPS

問題: 視訊卡頓或 VLM 回應緩慢

解決方案:

使用較小的模型:

ollama pull gemma3:4b  # 而非 gemma3:11b

增加影格處理間隔:

在設定中,將 "影格處理間隔" 設為 60+ 影格
這會減少影格分析的頻率

減少最大 Token:

將 "Max tokens" 設為 50-100 而非 512
較短的回應 = 更快的推理

檢查系統資源:

jtop  # 監控 GPU/CPU 使用率

不支援 JetPack 5.x

問題: JetPack 5.x 上的 Python 3.8 相容性問題

解決方案:

升級到 JetPack 6.x 或 JetPack 7.0
或使用自動處理 Python 環境的 Docker 方法

如需更多故障排除提示,請參閱官方故障排除指南。

Using Rust WebAssembly in Vite + React: A Modern Game of Life Example

Jambo — Tue, 09 Dec 2025 15:25:31 +0000

This project is based on the official Rust + WebAssembly tutorial for Game of Life:

https://rustwasm.github.io/docs/book/game-of-life/introduction.html

All Rust code is taken directly from the tutorial. The focus here is on integrating Rust-generated WebAssembly into a Vite + React + TypeScript project. The official tutorial still uses webpack and JavaScript, which makes the documentation a bit outdated for Vite users. This guide shows how to adapt the workflow to Vite while keeping everything compatible with wasm-bindgen.

1. Project Structure Overview

After setup, the project looks like this:

.
├── backend                # Rust wasm backend
│   ├── Cargo.toml
│   └── src/lib.rs
├── pkg                    # wasm-bindgen output directory
├── src                    # React frontend
│   ├── App.tsx
│   └── main.tsx
├── vite.config.ts
├── package.json
└── index.html

This structure separates the Rust logic (backend) from the React frontend.

2. Create the Vite + React + TypeScript Project

In the project root:

pnpm create vite

Select:

Framework: React
Variant: TypeScript

Install dependencies:

cd wasm-lifegame
pnpm install

3. Create Rust WebAssembly Backend

From the project root:

cargo new backend --lib

Directory structure:

backend/
├── Cargo.toml
└── src/lib.rs

Configure Cargo.toml for wasm

[package]
name = "backend"
version = "0.1.0"
edition = "2024"

[lib]
crate-type = ["cdylib"]

[dependencies]
wasm-bindgen = "0.2.106"

crate-type = ["cdylib"] makes Rust compile to a dynamic library compatible with wasm
wasm-bindgen is required for JS interop ### Rust Code: Game of Life

Open backend/src/lib.rs and replace it with the official Game of Life Rust code.

use std::fmt;
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
#[repr(u8)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Cell {
    Dead = 0,
    Alive = 1,
}

#[wasm_bindgen]
pub struct Universe {
    width: u32,
    height: u32,
    cells: Vec<Cell>,
}

impl Universe {
    fn get_index(&self, row: u32, column: u32) -> usize {
        (row * self.width + column) as usize
    }

    fn live_neighbor_count(&self, row: u32, column: u32) -> u8 {
        let mut count = 0;
        for delta_row in [self.height - 1, 0, 1].iter().cloned() {
            for delta_col in [self.width - 1, 0, 1].iter().cloned() {
                if delta_row == 0 && delta_col == 0 {
                    continue;
                }

                let neighbor_row = (row + delta_row) % self.height;
                let neighbor_col = (column + delta_col) % self.width;
                let idx = self.get_index(neighbor_row, neighbor_col);
                count += self.cells[idx] as u8;
            }
        }
        count
    }
}

#[wasm_bindgen]
impl Universe {
    pub fn tick(&mut self) {
        let mut next = self.cells.clone();

        for row in 0..self.height {
            for col in 0..self.width {
                let idx = self.get_index(row, col);
                let cell = self.cells[idx];
                let live_neighbors = self.live_neighbor_count(row, col);

                let next_cell = match (cell, live_neighbors) {
                    (Cell::Alive, x) if x < 2 => Cell::Dead,
                    (Cell::Alive, 2) | (Cell::Alive, 3) => Cell::Alive,
                    (Cell::Alive, x) if x > 3 => Cell::Dead,
                    (Cell::Dead, 3) => Cell::Alive,
                    (otherwise, _) => otherwise,
                };

                next[idx] = next_cell;
            }
        }

        self.cells = next;
    }

    pub fn new() -> Universe {
        let width = 64;
        let height = 64;

        let cells = (0..width * height)
            .map(|i| {
                if i % 2 == 0 || i % 7 == 0 {
                    Cell::Alive
                } else {
                    Cell::Dead
                }
            })
            .collect();

        Universe {
            width,
            height,
            cells,
        }
    }

    pub fn render(&self) -> String {
        self.to_string()
    }
}

impl fmt::Display for Universe {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        for line in self.cells.as_slice().chunks(self.width as usize) {
            for &cell in line {
                let symbol = if cell == Cell::Dead { '◻' } else { '◼' };
                write!(f, "{}", symbol)?;
            }
            write!(f, "\n")?;
        }

        Ok(())
    }
}

4. Add the wasm compilation target

rustup target add wasm32-unknown-unknown

5. Build Rust to WebAssembly

cd backend
cargo build --target wasm32-unknown-unknown

Generates:

backend/target/wasm32-unknown-unknown/debug/backend.wasm

7. Generate JavaScript Bindings with wasm-bindgen

Install wasm-bindgen-cli by cargo

cargo install wasm-bindgen-cli

Return to the project root:

cd ..
wasm-bindgen backend/target/wasm32-unknown-unknown/debug/backend.wasm \
  --out-dir pkg \
  --target web

Note that --target is "web" and not "bundle".

Output:

pkg
├── backend_bg.wasm
├── backend_bg.wasm.d.ts
├── backend.d.ts
└── backend.js

This pkg folder contains everything the frontend needs to import the wasm module.

8. Install Vite WebAssembly Plugins

pnpm add -D vite-plugin-wasm vite-plugin-top-level-await

These plugins allow Vite to handle .wasm imports and top-level await. Edit vite.config.ts:

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import wasm from "vite-plugin-wasm";
import topLevelAwait from "vite-plugin-top-level-await";

export default defineConfig({
  plugins: [react(), wasm(), topLevelAwait()],
});

React Frontend: Loading Rust wasm (src/App.tsx)

import { useRef, useEffect } from "react";
import "./App.css";
import init, { Universe } from "../pkg/backend"; // Not `backend_bg.wasm`

function App() {
  const preRef = useRef<HTMLPreElement | null>(null);
  const universeRef = useRef<Universe | null>(null);

  useEffect(() => {
    const start = async () => {
      await init();
      const universe = Universe.new();
      universeRef.current = universe;

      const renderLoop = () => {
        if (preRef.current && universeRef.current) {
          preRef.current.textContent = universeRef.current.render();
          universeRef.current.tick();
        }
        requestAnimationFrame(renderLoop);
      };

      requestAnimationFrame(renderLoop);
    };

    start();
  }, []);

  return (
    <pre
      ref={preRef}
      id="game-of-life-canvas"
      style={{ fontFamily: "monospace", lineHeight: 1, fontSize: 10 }}
    />
  );
}

export default App;

Run the Project

pnpm run dev

Visit:

http://localhost:5173

You should see the Game of Life running in real time in the browser, driven by Rust + wasm.

Automate wasm Build (package.json)

"scripts": {
  "wasm": "cd backend && cargo build --target wasm32-unknown-unknown && wasm-bindgen target/wasm32-unknown-unknown/debug/backend.wasm --out-dir ../pkg --target web",
  "predev": "pnpm run wasm",
  "prebuild": "pnpm run wasm",
  "dev": "vite",
  "build": "tsc -b && vite build",
  "lint": "eslint .",
  "preview": "vite preview"
}

This ensures Rust is compiled to wasm automatically before dev or build.

OpenAI 開源 GPT-OSS：重塑 AI 開發生態的里程碑之舉

Jambo — Wed, 06 Aug 2025 03:31:09 +0000

2025年8月5日，OpenAI 正式發布了 GPT-OSS-120B 和 GPT-OSS-20B 兩款開源語言模型，這標誌著自 GPT-2 以來，OpenAI 首次向社群開放大型語言模型的完整權重。這一決定不僅展現了 OpenAI 對開源生態的重新審視，更預示著人工智慧發展模式的深刻變革。

技術突破與架構創新

GPT-OSS 系列模型在技術架構上體現了 OpenAI 的最新研究成果。兩個模型都採用了專家混合（MoE）架構，這一設計顯著降低了推論時的運算開銷。具體而言，GPT-OSS-120B 擁有1170億總參數，但每個 token 僅啟動51億參數；而 GPT-OSS-20B 雖然總參數為210億，但啟動參數僅為36億。這種稀疏啟動的設計使得模型在保持強大效能的同時，大幅降低了運行成本。

在注意力機制方面，兩個模型都採用了交替的密集和局部帶狀稀疏注意力模式，結合分組多查詢注意力（分組大小為8），有效提升了推論和記憶體效率。值得注意的是，這些模型原生支援128k的上下文長度，並使用旋轉位置嵌入（RoPE）進行位置編碼，展現了在長文本處理方面的優勢。

從效能表現來看，GPT-OSS-120B 在核心推理基準測試中與 OpenAI O1-mini 模型幾乎持平，同時能在單個80GB GPU上高效運行。更令人驚喜的是，GPT-OSS-20B 在常見基準測試中達到了與 O1‑mini 相似的結果，卻可以在僅配備16GB記憶體的邊緣裝置上運行。這種硬體友好性使得高品質的AI推論能夠真正走向一般開發者和中小企業。

在實際應用能力方面，兩個模型在工具使用、少樣本函式呼叫、以及鏈式思維推理等方面表現突出。特別是在 Tau-Bench 智慧代理評估套件和 HealthBench 測試中，它們甚至超越了包括 OpenAI O1 和 GPT-4o 在內的專有模型。這種表現證明了開源模型完全有能力在關鍵應用場景中與閉源方案競爭。

開源策略的深遠影響

OpenAI 選擇開源 GPT-OSS 系列模型，背後蘊含著多層次的策略考量。首先，這一舉措直接回應了業界對AI技術透明度和可控性的呼聲。在Apache 2.0授權條款下發布的模型允許開發者進行自由修改和商業化使用，這為建構多樣化的AI應用生態奠定了基礎。

更為重要的是，GPT-OSS 模型的發布體現了 OpenAI 對AI安全的全新思考。與傳統的閉源模型不同，GPT-OSS 提供了完整的思維鏈（CoT）過程，這使得研究人員和開發者能夠深入理解模型的推理過程。OpenAI 明確表示，他們在訓練過程中未對模型的 CoT 進行任何直接監督，這種設計理念為監測模型的不當行為、欺騙和濫用提供了可能。

在安全性方面，OpenAI 採用了創新的「最壞情況微調」評估方法。透過在專門的生物學和網路安全資料上對模型進行惡意微調，模擬攻擊者可能採用的手段，研究團隊發現即使經過廣泛的惡意微調，這些模型仍無法達到其「防範準備框架」所定義的高能力水準。這一發現為開源模型的安全性提供了重要的實證支撐。

對於廣大開發者而言，GPT-OSS 的開源意味著前所未有的自主權。企業可以在本地部署模型，確保資料隱私和安全；研究機構可以基於這些模型進行深度客製化和學術研究；新創公司則無需承擔昂貴的API呼叫費用即可獲得世界級的AI能力。這種模式的轉變有望加速AI技術在各行各業的落地應用。

NVIDIA 的生態賦能

在 GPT-OSS 模型的部署和最佳化方面，NVIDIA 展現出了卓越的技術支援能力。透過 TensorRT-LLM 框架，NVIDIA 為 GPT-OSS 系列模型提供了高效的推論最佳化方案。這套工具不僅支援模型的自動最佳化，還能夠根據不同的GPU架構產生專門的推論引擎。

TensorRT-LLM 的Python API設計體現了易用性和高效能的完美結合。開發者只需幾行程式碼即可從Hugging Face下載模型權重，系統會自動為特定的GPU架構建構最佳化引擎。對於 GPT-OSS-20B 模型，在配備至少20GB VRAM的NVIDIA GPU上，開發者可以輕鬆實現高效能推論。推薦的硬體包括NVIDIA Hopper（如H100、H200）、NVIDIA Blackwell（如B100、B200）以及最新的RTX 50系列GPU。

NVIDIA 還透過預建構的Docker容器簡化了部署流程。透過 NVIDIA NGC 平台，開發者可以快速獲取包含所有相依性的容器映像，大大降低了環境設定的複雜性。這種標準化的部署方案確保了模型在不同硬體環境中的一致性表現。

更值得關注的是，TensorRT-LLM 支援多種量化技術，如 INT8 和 FP8 量化，這些技術能夠在保持模型精度的同時顯著減小模型規模並加速推論過程。對於資源受限的硬體環境，這些最佳化技術尤為重要。結合 NVIDIA 的硬體優勢，開發者可以在從資料中心到邊緣裝置的全場景中部署 GPT-OSS 模型。

在生產環境部署方面，NVIDIA 還提供了 Dynamo 平台支援，實現了強大、可擴展的多模型服務架構。這種企業級的部署方案為 GPT-OSS 模型的商業化應用提供了可靠保障。

結語

GPT-OSS 的發布標誌著 AI 發展進入了一個新階段，開源模型與閉源模型的效能差距正在快速縮小。這一轉變將推動 AI 技術的民主化進程，讓更多組織和個人能夠參與 AI 創新。

然而，開放性也帶來了新的挑戰，包括如何確保負責任使用、維護安全性，以及建立有效的治理機制。OpenAI 透過舉辦紅隊測試挑戰賽等方式，展現了開放協作解決安全問題的新模式。

參考資料與延伸閱讀

OpenAI 官方文件

NVIDIA 相關資源

Isaac Sim 5 与 ROS2 机械臂仿真教程

Jambo — Thu, 17 Jul 2025 12:51:10 +0000

本教程將指導您在 Isaac Sim 5 中導入機械臂模型並與 ROS2 整合，實現機械臂的仿真控制。

資料來源

本教程基於以下資源製作：

影片教程：B站影片教程
開源專案：TheRobotStudio SO-ARM100 機械臂模型
官方文件：Isaac Sim 5

前提條件

開始前，請確保已安裝以下軟體：

Isaac Sim 5：參考官方安裝指南安裝
ROS2：參考 Isaac Sim ROS2 安裝文件配置 ROS2 環境

第一步：取得機械臂模型

TheRobotStudio 開源 SO-ARM101 機械臂，提供完整 URDF 文件：

git clone https://github.com/TheRobotStudio/SO-ARM100.git

提示：URDF（統一機器人描述格式）包含機械臂的幾何結構、關節資訊和物理屬性。

第二步：啟動 Isaac Sim

開啟終端，導航至 Isaac Sim 安裝目錄並啟動：

cd <Isaac Sim 路徑>
./isaac-sim.sh

注意：請將 <Isaac Sim 路徑> 替換為實際安裝路徑。

第三步：導入機械臂模型

在 Isaac Sim 介面點擊 File -> Import
在文件選擇對話框中，導航至 <SO-ARM100 路徑>/Simulation/SO101/so101_new_calib.urdf
選擇 URDF 文件並點擊導入

導入成功後，應可在 Isaac Sim 的 3D 視窗中看到完整機械臂模型。

第四步：添加仿真環境

為進行仿真，需為機械臂添加地面：

點擊 Create -> Physics -> Ground Plane
將在場景中添加物理地面

第五步：配置 ROS2 介面

為機械臂添加 ROS2 通信介面，實現外部控制。

5.1 建立 Joint States 節點

點擊 Tools -> Robotics -> ROS 2 OmniGraphs -> Joint States

5.2 配置 Articulation Root

在對話框中：

點擊 Articulation Root 輸入框右側選擇按鈕
在場景樹中選擇 so101_new_calib 下的 root_joint

Articulation Root 是機械臂的根關節，定義基礎座標系與物理屬性。

5.3 啟用發布與訂閱

勾選 Publisher（發布關節狀態至 ROS2）
勾選 Subscriber（接收 ROS2 控制命令）
點擊 OK 確認

第六步：完善控制圖

6.1 開啟 Action Graph

在 Stage 視窗找到 ROS_JointStates 節點
右鍵點擊，選擇 Open Graph
檢查是否有 Articulation Controller 節點。若已自動建立，跳至第七步；若無，依以下步驟手動建立。

6.2 添加 Articulation Controller

在 Action Graph 視窗中：

在 Nodes 面板搜索 Articulation Controller
將節點拖曳至畫布

Articulation Controller 是控制機械臂關節運動的核心組件。

6.3 建立節點連線

將 ROS2 Subscribe Joint State 的以下輸出埠連接到 Articulation Controller 的對應輸入埠：

Joint Names（關節名稱）
Position Command（位置命令）
Exec Out -> Exec In

第七步：啟動仿真

點擊 Isaac Sim 介面左側 Play 按鈕開始仿真，機械臂將發布狀態資訊至 ROS2，並準備接收控制命令。

第八步：驗證 ROS2 通信

8.1 啟動 ROS2 環境

開啟新終端並啟動 ROS2 環境：

source /opt/ros/jazzy/setup.sh

注意：請根據您的 ROS2 版本調整路徑，如 humble、iron 等。

8.2 查看 ROS2 主題

使用以下命令查看可用 ROS2 主題：

ros2 topic list

應看到以下輸出：

/joint_command
/joint_states
/parameter_events
/rosout

8.3 監控關節狀態

使用以下命令即時查看機械臂關節狀態：

ros2 topic echo /joint_states

將顯示每個關節的位置、速度和力矩資訊。

第九步：編寫控制腳本

以下為基礎鍵盤控制範例：

#!/usr/bin/env python3
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import JointState
import sys
import termios
import tty
import select

class JointKeyboardControl(Node):
    def __init__(self):
        super().__init__('joint_keyboard_control')
        self.publisher_ = self.create_publisher(JointState, '/joint_command', 10)

        # 關節名稱（與 /joint_states 一致）
        self.joint_names = [
            'shoulder_pan',
            'shoulder_lift',
            'elbow_flex',
            'wrist_flex',
            'wrist_roll',
            'gripper'
        ]

        # 當前關節位置（初始為0）
        self.joint_positions = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]

        # 當前選中關節索引（預設第一個）
        self.selected_joint = 0

        # 關節調整步長
        self.step_size = 0.01

        # 保存終端設定
        self.old_settings = termios.tcgetattr(sys.stdin)

        # 操作提示
        self.print_instructions()

    def print_instructions(self):
        print("\n=== 機械臂鍵盤控制 ===")
        print("1-6: 選擇關節")
        print("a/d: 調整關節位置（a=減小, d=增大）")
        print("q: 退出程式")
        print("當前關節:", self.joint_names[self.selected_joint])
        print("當前位置:", self.joint_positions[self.selected_joint])

    def get_key(self):
        # 非阻塞讀取鍵盤輸入
        if select.select([sys.stdin], [], [], 0) == ([sys.stdin], [], []):
            return sys.stdin.read(1)
        return None

    def run(self):
        try:
            # 設置終端為非阻塞模式
            tty.setcbreak(sys.stdin.fileno())

            while rclpy.ok():
                key = self.get_key()
                if key is not None:
                    # 選擇關節（1-6）
                    if key in ['1', '2', '3', '4', '5', '6']:
                        self.selected_joint = int(key) - 1
                        print("\n當前關節:", self.joint_names[self.selected_joint])
                        print("當前位置:", self.joint_positions[self.selected_joint])

                    # 調整關節位置（a=減小, d=增大）
                    elif key == 'a':
                        self.joint_positions[self.selected_joint] -= self.step_size
                        self.publish_joint_command()
                        print("位置 -:", self.joint_positions[self.selected_joint])

                    elif key == 'd':
                        self.joint_positions[self.selected_joint] += self.step_size
                        self.publish_joint_command()
                        print("位置 +:", self.joint_positions[self.selected_joint])

                    # 退出程式（q）
                    elif key == 'q':
                        print("\n退出程式...")
                        break

                # 短暫休眠，避免CPU過高
                rclpy.spin_once(self, timeout_sec=0.01)

        finally:
            # 恢復終端設定
            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, self.old_settings)

    def publish_joint_command(self):
        msg = JointState()
        msg.header.stamp = self.get_clock().now().to_msg()
        msg.name = self.joint_names
        msg.position = self.joint_positions
        self.publisher_.publish(msg)

def main(args=None):
    rclpy.init(args=args)
    joint_keyboard_control = JointKeyboardControl()

    try:
        joint_keyboard_control.run()
    except KeyboardInterrupt:
        pass
    finally:
        joint_keyboard_control.destroy_node()
        rclpy.shutdown()

if __name__ == '__main__':
    main()

執行控制腳本

將程式碼儲存為 joint_keyboard_control.py，然後執行：

python3 joint_keyboard_control.py

您可在終端使用鍵盤控制機械臂運動，同時觀察 Isaac Sim 中機械臂的即時回應。

LeRobot 機械手臂操作教程

Jambo — Fri, 11 Jul 2025 07:47:08 +0000

本教程基於 Linux 環境編寫，假設用戶已完成環境配置、機械臂組裝與校準。教程中將 Leader 稱為主臂，Follower 稱為從臂。

訓練環境：Ubuntu 22.10，RTX 4060 TI (16G)

準備工作

由於 LeRobot 迭代速度快，建議切換到教程編寫時的版本：

git checkout d2645cb19fc521e5b117fe03d90a84f698d3d3f6

1. 遙控操作

完成主從臂校準後，可用以下腳本控制主臂遙控從臂，顯示相機畫面與馬達資訊：

python -m lerobot.teleoperate \
 --robot.type=so101_follower \
 --robot.port=/dev/ttyACM1 \
 --robot.id=follower \
 --robot.cameras="{ front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30}}" \
 --teleop.type=so101_leader \
 --teleop.port=/dev/ttyACM0 \
 --teleop.id=leader \
 --display_data=true

參數說明：

robot.id 與 teleop.id：應與校準時的機械臂唯一 ID 一致，用於讀取校準時儲存的馬達資訊
robot.cameras：相機配置資訊，可執行 python -m lerobot.find_cameras opencv 查找可用相機。支援多機位配置，透過字典鍵區分與記錄不同相機

2. 資料收集

基本收集命令

python -m lerobot.record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM1 \
  --robot.id=follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30}}" \
  --teleop.type=so101_leader \
  --teleop.port=/dev/ttyACM0 \
  --teleop.id=leader \
  --display_data=true \
  --dataset.num_episodes=20 \
  --dataset.push_to_hub=False \
  --dataset.repo_id=${HF_USER}/record-test \
  --dataset.single_task="Grab the black cube"

資料儲存位置

預設儲存路徑：~/.cache/huggingface/lerobot/{repo-id}
自訂儲存：設定 HF_LEROBOT_HOME 環境變數，資料儲存於 HF_LEROBOT_HOME/repo_id

資料收集控制

收集過程可透過鍵盤控制：

右箭頭 (→)：錄製階段完成當前錄製並進入恢復階段；恢復階段進入下一輪錄製
左箭頭 (←)：重新錄製當前資料
ESC：完成當前錄製並退出

注意：腳本使用 pynput 監聽按鍵，SSH 或 Wayland 下可能無法運作。詳見：pynput 平台限制

恢復中斷的收集

若收集過程出錯，可在原命令加 --resume=true 參數恢復。

資料上傳

手動上傳資料至 HuggingFace：

huggingface-cli upload ${HF_USER}/record-test ~/.cache/huggingface/lerobot/{repo-id} --repo-type dataset

注意：若未設定 --dataset.push_to_hub=False，收集完成時會自動上傳資料。

3. 模型訓練

基本訓練命令

python -m lerobot.scripts.train \
  --dataset.repo_id=${HF_USER}/record-test \
  --policy.type=act \
  --output_dir=outputs/train/act_so101_test \
  --job_name=act_so101_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.repo_id=${HF_USER}/my_policy \
  --policy.push_to_hub=false \
  --steps 50000 \
  --batch_size 32 \
  --save_freq 10000

訓練腳本從 HF_LEROBOT_HOME/dataset.repo_id 路徑讀取資料進行訓練。

恢復訓練

從最新檢查點恢復訓練：

python -m lerobot.scripts.train \
  --config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

4. 模型推理與評估

使用訓練好的模型進行推理，同時記錄評估片段：

python -m lerobot.record \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM1 \
  --robot.cameras="{ front: {type: opencv, index_or_path: /dev/video2, width: 640, height: 480, fps: 30}}" \
  --robot.id=follower \
  --display_data=true \
  --dataset.repo_id=${HF_USER}/eval_so101 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/

用 Ollama？其實你在跑 llama.cpp！學會直接使用它，發揮更強性能！

Jambo — Wed, 05 Mar 2025 23:00:00 +0000

前言

Ollama 在大語言模型社群中擁有極高的關注度，因為它讓使用者能夠輕鬆地在本地環境運行大型語言模型，即使對相關參數不熟悉，也能獲得良好的使用體驗。此外，Ollama 還提供模型託管服務，使得部署與管理變得更加便捷。

然而，在 Ollama 背後執行推理的核心技術其實是 llama.cpp，而 GGUF 模型格式也是由 llama.cpp 的作者所開發。雖然 Ollama 已經足以應對日常使用，但如果追求極致的推理效能，或希望探索尚未正式發布的實驗性功能，那麼深入理解與使用 llama.cpp 便是必要的。

本指南將介紹如何在特定硬體環境下編譯 llama.cpp，轉換與量化 GGUF 模型，以及進行高效的推理測試。

試驗平台

硬體環境：Jetson Orin Nano

軟體環境：JetPack 6.2 (Ubuntu 22.04, CUDA 12.6)

測試模型：microsoft/Phi-4-mini-instruct

1. 編譯 llama.cpp

安裝必要套件

在 Jetson Orin Nano 上編譯 llama.cpp 需要確保系統具備必要的依賴項，包括 CUDA 支援、CMake 以及 g++ 編譯器。如果你使用的是 Jetson 平台，這些工具應該已經預裝。

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential cmake git

下載並編譯 llama.cpp

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

Jetson 平台具備 CUDA 核心，因此我們可以啟用 CUDA 加速 GPU 計算。若使用其他平台，請參考官方文檔以啟用對應功能。

cmake -B build -DGGML_CUDA=ON
make -j$(nproc)

執行完上述步驟後，llama.cpp 應已成功編譯，編譯的可執行文件會儲存在 build/bin 目錄下。

2. 轉換 GGUF 模型

llama.cpp 使用 GGUF 格式的模型。你可以在 Hugging Face 或 Ollama 的儲存庫上直接下載別人轉換好的 GUFF 模型。但如果暫時還沒有現成的 GUFF，你可以自己將 Hugging Face 上發佈的模型轉換從 GUFF 模型，llama.cpp 有提供轉換的 Python 腳本。

下載原始 Hugging Face 模型

可以通過 huggingface-cli 快速下載 Hugging Face 上的模型:

huggingface-cli download microsoft/Phi-4-mini-instruct --local-dir ./phi4

這將把模型下載到本地的 ./phi4 目錄中。

轉換為 GGUF 格式

轉換模型的腳本在 llama.cpp 目錄中。在運行腳本之前，你應該要安裝 python 的依賴

pip3 install -r pyproject.toml

接下來就可以用 convert_hf_to_gguf.py轉換模型。你可以用命令 python3 convert_hf_to_gguf.py -h 查看該腳本的可用參數。

python3 convert_hf_to_gguf.py --model-dir ./phi4 --outfile ./models

這將在 ./models 目錄下生成 GGUF 格式模型。到這裏 llama.cpp 就可以推理模型了。

3. 量化模型

為了提高推理速度並減少記憶體佔用，我們可以對 GGUF 模型進行量化處理。讓原本需要 9G 現存的模型，只需要 5G 就能運行。

./build/bin/llama-quantize ./models/Phi-4-mini-instruct.gguf ./models/Phi-4-mini-instruct-q4.gguf q4_0

這會將模型從浮點格式轉換為 Q4_0 量化格式，從而提升推理速度並降低硬體需求。

目前量化格式種類繁多，各自具備不同程度的加速與壓縮效果，相對應的準確度也會有所犧牲。不同模型與應用場景適用不同的量化格式，因此建議嘗試多種量化方案，以尋找最適合的配置。

4. 推理

當完成模型準備後，即可開始執行推理。

./build/bin/llama-cli -m ./models/Phi-4-mini-instruct-q4.gguf

如果一切順利，你應該能成功加載模型並進入對話模型。

Running Phi-3-vision via ONNX on Jetson Platform

Jambo — Fri, 19 Jul 2024 09:54:58 +0000

This article aims to run the quantized Phi-3-vision model in ONNX format on the Jetson platform and successfully perform inference for image+text dialogue tasks.

What is Jetson?

Jetson is a series of small arm64 devices launched by NVIDIA, equipped with powerful GPU computing capabilities. It is designed for edge computing and AI applications. Running on a Linux system, Jetson can handle complex computing tasks with low power consumption, making it ideal for developing embedded AI and machine learning projects.

Why ONNX Runtime?

ONNX Runtime is a high-performance inference engine for executing ONNX (Open Neural Network Exchange) models. It provides a simple way to run large language models like Llama, Phi, Gemma, and Mistral via the onnxruntime-genai API.

Running the Phi-3-vision Model

In this project, I ran the Phi-3-vision model on the Jetson platform using ONNX Runtime. Here’s a sneak peek at the results.

Inference Speed and Resource Utilization

By running the Phi-3-vision model in ONNX format on the Jetson Orin Nano with the Int4 quantized model, I achieved remarkable performance metrics. The Python process utilized 5.4 GB of GPU memory while keeping the CPU load minimal and almost fully utilizing the GPU.

The inference speed was impressively fast, even on a device with just a 15W power consumption.

Example Output

Here’s an example of running the Phi-3-vision model on the Jetson platform. Given an image and a prompt, the model successfully converted the image to markdown format:

Input Image:
Prompt:
```
Convert this image to markdown format
```

Output:

| Product             | Qtr 1    | Qtr 2    | Grand Total |
|---------------------|----------|----------|-------------|
| Chocolade           | $744.60  | $162.56  | $907.16     |
| Gummibarchen        | $5,079.60| $1,249.20| $6,328.80   |
| Scottish Longbreads | $1,267.50| $1,062.50| $2,330.00   |
| Sir Rodney's Scones | $1,418.00| $756.00  | $2,174.00   |
| Tarte au sucre      | $4,728.00| $4,547.92| $9,275.92   |
| Chocolate Biscuits  | $943.89  | $349.60  | $1,293.49   |
| Total               | $14,181.59| $8,127.78| $22,309.37  |

The table lists various products along with their sales figures for Qtr 1, Qtr 2, and the Grand Total. The products include Chocolade, Gummibarchen, Scottish Longbreads, Sir Rodney's Scones, Tarte au sucre, and Chocolate Biscuits. The Grand Total column sums up the sales for each product across the two quarters.

Conclusion

Running the Phi-3-vision model in ONNX format on the Jetson platform demonstrates the incredible potential of combining powerful AI models with efficient edge computing devices. The results are impressive, and the resource utilization is optimized for low-power devices.

👉 For a detailed step-by-step guide on setting up and running the Phi-3-vision model on Jetson, including preparation and installation, please visit the complete article here: Running Phi-3-vision via ONNX on Jetson Platform

If you're interested in AI and edge computing, don't miss out on this comprehensive tutorial!

Profiling Rust with VS on Windows

Jambo — Thu, 23 May 2024 10:00:00 +0000

Preface

This all began while I was developing a tool in Rust for reading from a database, processing data, and writing back to it. The program was taking too long to run, and I couldn't figure out where the bottleneck was. Online searches for 'how to profile Rust on Windows' mostly pointed to using Visual Studio (with some mentions of WPA), yet I found no straightforward guides for beginners, especially as a VS Code user. After some trial and error, I've put together this article.

It's not a full-fledged profiling tutorial, but more a record of my own experiences. I've also experimented with Intel Vtune, which I quite like, but it occupies a hefty 2GB of space. Considering that installing Rust on Windows seems to inevitably involve downloading Visual Studio (I'm not aware of how to avoid it), I've decided to document the profiling process using VS.

This is just a simple tutorial. For more detailed information, please refer to the Visual Studio documentation:

Profiling

First and foremost, add the following lines to your project's Cargo.toml file:

[profile.release]
debug=1

After saving, building the release will also include debug information:

cargo build --release
    Finished release [optimized + debuginfo] target(s) in 0.10s

Next, open Visual Studio (I'm using VS 2022). Since I'm only planning to use VS as a performance analysis tool, click "Continue without code".

Then, go to the 'Debug' menu and open 'Performance Profiler'.

Select the executable file (exe) as the target for analysis.

Set the working directory to the project's directory, and locate the compiled executable file in the project's target/release directory.

Choose 'CPU Usage' and then click 'Start' to begin executing the file and recording. You can wait for the file to finish running or interrupt it yourself. After completion, Visual Studio will automatically generate a report.

The generated report includes information on the execution time of functions and their sub-functions, and it also lists the functions that consume the most time. Clicking 'Open details' will open a more detailed report.

In the upper left corner, you can switch the displayed view. After clicking on a function, Visual Studio will also display the specific code and the time consumed by each line of code. The flame graph can also be used to display code performance details.

Reference

用 LangChain 構建基於資料庫的問答機器人（四）：通過代理使用外部工具

Jambo — Tue, 25 Jul 2023 00:00:00 +0000

上一篇教程我們介紹了 ReAct 系統，這是一個非常強大的行為模式，但它需要編寫大量的示例來告訴 LLM 如何思考、行動，並且為了遵循這個模式，還需要編寫代碼來分析生成文字、調用函數、拼接 prompt 等，這些工作都是十分繁瑣且冗長的。而 LangChain 幫我們把這些步驟都隱藏起來了，將這一系列動作都封裝成 “代理”，我們只需要提供有那些工具可以使用，以及這些工具的功能，就可以讓 LLM 自動完成這些工作了。這樣我們的代碼就會變得簡潔、易讀，並且擁有更高的靈活性。

代理（Agent）

所謂代理，就是將一系列的行為和可以使用的工具封裝起來，讓我們可以通過一個簡單的接口來調用這些動作，而不需要關心這些動作是如何完成的。這樣可以讓我們的代碼更簡潔、易讀，並且擁有更高的靈活性。接下來我們就結合 ReAct 和向量數據庫來介紹代理的使用。

準備工作

和之前一樣，我們先設置環境變量。

# set the environment variables needed for openai package to know to reach out to azure
import os

os.environ["OPENAI_API_TYPE"] = "azure"
os.environ["OPENAI_API_BASE"] = "https://<your-endpoint.openai.azure.com/"
os.environ["OPENAI_API_KEY"] = "your AzureOpenAI key"
os.environ["OPENAI_API_VERSION"] = "2023-03-15-preview"

接下來我們先把 llm 類創建好。

from langchain.chat_models import AzureChatOpenAI
from langchain.embeddings import OpenAIEmbeddin Whether to return only outputs in the
                response. If True, only new keys generated by this chain will be
                returned. If False, both input keys and new keys generated by this
                chain will be returned. Defaults to False.gs

llm = AzureChatOpenAI(deployment_name="gpt-35-turbo", temperature=0)
embeddings = OpenAIEmbeddings(deployment="text-embedding-ada-002", chunk_size=1)

因為我們的向量數據庫已經在之前的教程中創建好了，所以我們用 from_existing_index 直接連接到數據庫。這裡 index_name 是我們之前創建數據庫時指定的名字。另外不同的數據庫所使用的鏈接方法可能不同，具體還是要參考各個數據庫的文檔。

from langchain.vectorstores.redis import Redis

rds = Redis.from_existing_index(
    embeddings, redis_url="redis://localhost:6379", index_name="link"
)
retriever = rds.as_retriever()

創建工具

雖然代理可以讓 llm 使用外部工具，但我們首先要創建工具，並為工具編寫描述。我們的目的是為了要能夠讓 llm 根據問題從數據庫中檢索出答案，因此我們創建的工具一定是與此相關的。我們可以將檢索器的搜索功能包裝成一個函數，然後以此作為工具，但我們完全可以用之前教程中所介紹的 RetrievalQA Chain ，它的輸出本就是字符串，而且已經先將相關的資料進行了整理，這顯然比檢索器更高效。

from langchain.chains import RetrievalQA

qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)

然後用 Tool 將上面創建的 Chain 包裝起來。其中 func 參數是告訴代理系統要調用哪個函數，description 是對這個工具的描述。我們將包裝好的工具放在一個列表中，這樣就是告訴系統他可以使用的工具有哪些了。

from langchain.agents import Tool

tools = [
    Tool(
        name="Contract QA System",
        func=qa.run,
        description="useful for when you need to answer questions about contracts."
    )
]

創建代理

我們用 initialize_agent 函數來創建代理。這裡 agent 參數是告訴系統我們要創建的代理類型，這裡我們創建的是 CHAT_ZERO_SHOT_REACT_DESCRIPTION，名字中的 CHAT 表示這是一個聊天代理，因為我們用的是聊天模型；ZERO_SHOT 表示它的 prompt 沒有編寫示例，而是僅通過描述來引導 llm 的行為。

agent_chain = initialize_agent(
    tools, llm, agent=AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)

然後用 run 方法來運行代理。

agent_chain.run("在什麼情況下可以單方面解除合同？")

> Entering new  chain...
Thought: This question is asking about the circumstances under which a contract can be unilaterally terminated.

Action:
\```


{
  "action": "Contract QA System",
  "action_input": "在什麼情況下可以單方面解除合同？"
}
\

Observation: 根據文本，可以單方面解除合同的情況包括：

在承擔國家重大科研項目期間；
掌握重大科技成果關鍵技術和資料，未脫離保密期；
被審查期間或因經濟問題未作結案處理之前；
合同訂立時所依據的客觀情況發生重大變化，致使合同無法履行，經甲乙雙方協商不能就變更合同達成協議的；
甲方提出解除本合同，乙方同意解除的；
乙方患病或者非因工負傷，醫療期滿後，不能從事原工作也不能從事由甲方安排的其他工作，甲方單方面解除本合同的；
乙方年度考核或者聘期考核不合格，又不同意甲方調整其工作崗位的；
在試用期內被證明不符合本崗位要求；
連續曠工超過 10 個工作日或者 1 年內累計曠工超過 20 個工作日的； ...

Final Answer: 根據文本，可以單方面解除合同的情況有很多種，包括在承擔國家重大科研項目期間、合同訂立時所依據的客觀情況發生重大變化、甲方提出解除本合同且乙方同意解除等。此外，乙方在試用期內、考入普通高等院校、被錄用或者選調為公務員、依法服兵役的情況下也可以隨時單方面解除合同。如果乙方提出解除合同未能與甲方協商一致，乙方應當堅持正常工作，繼續履行合同；6個月後再次提出解除合同仍未能與甲方協商一致的，即可單方面解除合同。

Finished chain.

'根據文本，可以單方面解除合同的情況有很多種，包括在承擔國家重大科研項目期間、合同訂立時所依據的客觀情況發生重大變化、甲方提出解除本合同且乙方同意解除等。此外，乙方在試用期內、考入普通高等院校、被錄用或者選調為公務員、依法服兵役的情況下也可以隨時單方面解除合同。如果乙方提出解除合同未能與甲方協商一致，乙方應當堅持正常工作，繼續履行合同；6個月後再次提出解除合同仍未能與甲方協商一致的，即可單方面解除合同。 '




這樣我們很容易的完成 ReAct 的流程，並且它確實可以從資料源中檢索出答案。用 LangChain 我們就可以用簡潔的代碼完成如此復雜的任務，並且也不需要編寫 prompt，這樣我們就可以更專注於業務的邏輯了。

用 LangChain 構建基於資料庫的問答機器人（三）：ReAct

Jambo — Mon, 24 Jul 2023 00:00:00 +0000

大家好，我是 Jambo。我們已經學習瞭如何使用 LangChain 的一些基本功能，解下我們就應該要結合這些功能來做一些複雜的東西了。但在這之前，為了讓同學們更好的理解 LangChain 在這其中做了什麼，我想先介紹一下關於 GPT 使用方面的一些知識。

在 ChatGPT 開放之初，除了各大公司在 AI 算法方面競爭，還有許多人在研究如何僅通過修改 prompt 就能讓 GPT-3 做出更好的回答，這種方法被稱為“提示工程（Prompt Engineering）”。如果把 LLM 比喻成一個擁有一般常識的大腦，那麼提示工程就是在教它如何思考，從而更有效的結合知識得出答案。像 AutoGPT 就是這樣，他通過精心設計的 prompt，就能讓 GPT-4 自行完成各種任務。為了讓同學們了解這其中的思想，我們先從“思維鏈”開始介紹。

思維鏈（Chain of Thought）

思維鏈（Chain of Thought）在 ChatGPT 推出後不久就被提出，具體來說就是通過手動編寫示例的方式讓 GPT-3 將問題的思考過程也生成出來，通過這種方式 GPT-3 回答的效果會有大幅提升。就像我們在寫比較複雜的計算題，將過程一步一步寫出來的正確率會比直接寫出答案要高。

後來有人發現，只需要加上 “Let's think step by step.” 這一魔法提示，就能達到一樣的效果，還不需要寫示例。並且他還在這基礎上，額外讓 GPT 根據它前面附帶思考過程的回答，再總結出一個更簡潔的答案，相當於把思考過程隱藏起來。

我這裡想強調的是，我們用 LLM 構建應用時，完全可以在輸出最終答案前多次用 LLM 分析、拆解、解決問題。就像深度學習網絡中的介於輸入和輸出之間的隱藏層，我們可以在這裡加入更多的邏輯，讓 LLM 能夠更好的理解問題，從而得出更好的答案。

ReAct

無論我們如何調整 prompt，但 LLM 仍然存在一個重大缺陷：它始終基於訓練時的數據集和 prompt 中提供的信息生成回答。如果提問有關天氣、新聞或內部文件等問題，LLM 將無法回答或會產生虛假回答（"幻覺"）。

當然，我們可以在用戶提出問題後，先使用搜索引擎或內部資料庫來搜索問題，然後將搜索結果作為 prompt 的一部分。但在實際應用中，這種方法的效果並不總是好的，甚至在某些情況下會產生誤導。例如，如果我們想讓 LLM 幫助我們修改一篇文章，在這種流程下，程序會首先使用搜索引擎搜索文章，但很可能搜索不到相關結果。這樣一來，LLM 就會直接罷工，因為我們通常要求 LLM 僅根據 prompt 提供的信息生成內容，以確保准確性。

為了解決這個問題，我們可以讓 LLM 自己決定是否要進行搜索，要搜索什麼內容，就和上一篇教程中提到的用 LLM 優化搜索語句一樣。於是 ReAct 系統就被提出來了，通過 prompt 中的示例告訴 LLM 可以使用哪些工具，然後讓 LLM 自己決定是否要使用這些工具，以及如何使用這些工具。 ReAct 總共有三個部分：

思考：根據當前的信息思考需要做什麼動作。
行動：根據思考結果做出相應的行動，如調用工具。程序可以分析這一步生成的字符串，來調用相應的工具，類似 Python 的 eval 函數。
觀察：存放行動的結果，如搜索的內容，以便下一次思考時使用。

這三個步驟會不斷循環，直到思考步驟判斷已經找到答案，並在下面的行動中給出最終答案。

其實你仔細回想一下，這個過程和我們人類思考的過程是類似的。我們在思考時，會根據當前的信息判斷是否需要做出某些行動，然後根據行動的結果來判斷是否已經找到答案，如果沒有就繼續思考，直到找到答案為止。

AutoGPT 的行為模式實際上和 ReAct 一樣，只是相比提出 ReAct 的論文中的步驟，AutoGPT 的 prompt 更加詳細，並且提供了更多的工具給 LLM 使用。但不管哪種方式，都需要編寫大量的示例來告訴 LLM 如何思考、行動，並且根據提供工具的不同，效果也會有所不同，並且 ReAct 的思考流程會有很多步驟。而 LangChain 幫我們把這些步驟都隱藏起來了，將這一系列動作都封裝成 “代理”，而這就是我們下一章要介紹的內容了。

用 LangChain 構建基於資料庫的問答機器人（二）：從資料源中提取文本信息

Jambo — Mon, 17 Jul 2023 23:00:00 +0000

大家好，我是學生大使 Jambo。這個系列的目標是做出一個根據資料回答問題的機器人，那麼從資料源中提取文本信息就是一件必要的事。但我們的資料源格式是多樣的，比如 PDF、Word、HTML、PPT 等等，甚至有的資料源來自於網絡，這些格式都不能直接提取出文本，但好在 Python 有很多第三方庫可以幫助我們提取文本信息，並且 LangChain 也幫我們整合到了一起，我們只需要調用 LangChain 的接口就可以了。

我在公開網絡上找到了一份 PDF 格式的合同，我們就以這份合同為例，介紹一下如何提取文本信息。

文本提取

LangChain 針對 PDF 包含了許多第三方庫，比如 PyPDF2、PyPDFium2、PDFMiner 等等，這裡我們以 PyPDF2 為例，介紹一下如何提取文本信息。

pip install pypdf

我們使用 PyPDFLoader 來加載 PDF 文件，然後調用 load 方法就可以得到文本信息了。 PDF 的讀取器會將 PDF 文件中的每一頁轉換成一段文本，然後將這些文本段組成一個列表返回。

from langchain.document_loaders import PyPDFLoader
loader = PyPDFLoader("./contract.pdf")
documents = loader.load()

文本分割

但僅僅是按頁進行分割，仍然是不夠的，因為一頁中仍然包含了太多的字數，如果將來將這些文本放在 prompt 的上下文中，會佔據大量的 token，而這些文本對於當下所問的問題不一定都是有用的，所以我們需要將這些文本再進行分割。

LangChain 提供了幾種分割器，可以分割代碼、段落、Markdown 標題。這裡我們使用 RecursiveCharacterTextSplitter ，他會把文本按照字符進行分割，直到每個文本段的長度足夠小。它默認的分割列表是 ["\n\n", "\n", " ", ""]，這樣它可以盡可能把段落、句子或單詞放在一起。

其中 chunk_size 限制了每段文本的最大長度。 chunk_overlap 則是兩個文本段之間的重疊長度，如果一個段落實在太長而被強制分割成了兩段，那麼這兩段之間就會有一段重疊的文本，這樣可以保證上下文的連貫性。

它還有個參數 length_function，用來計算文本的長度，默認是 len。如果你想按照 token 的數量來分割，那麼可以結合 tiktoken 庫來使用。

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
docs = text_splitter.split_documents(documents)

這樣我們就很容易的得到了一個文本列表，而不用考慮具體的分割細節了。

當然，這裡只是簡單的帶大家了解一下 LangChain 的文本提取功能，還有其他很多格式和對應的細節沒有介紹到，比如 Word、HTML、PPT 等等，如果你想了解更多，還是要自己去看看官方的文檔。

我的微軟學生大使成長經歷- 從 Alpha 到 Beta 的升級經驗分享

Jambo — Tue, 04 Jul 2023 00:00:00 +0000

大家好，我是微軟學生大使 Jambo。前幾天，我從微軟學生大使 Alpha 升級到了 Beta，離最高的 Gold 又進了一步！我非常開心能在暑假到來前升級到微軟學生大使 Beta ，這不僅是對我過去幾個月努力的回報，更是對我未來的鼓勵。

回想起最初申請學生大使時，我對這個計劃的認識還很模糊，只是覺得這是一個很好的鍛煉機會，抱著試試看的心情申請，當然更多的也是被福利所吸引。而申請通過後，我才真正意識到這個計劃的意義和價值，它的核心並不只是技術，更多的是分享和傳播，是一種精神，是一種對技術的熱愛和對社區的貢獻。這不僅僅要求過硬的技術，還要能有足夠的社交能力。當然，這對我而言也是一種挑戰，因為我在此之前一直都是自己一個人埋頭學習，很少與人分享技術，更不用說參與社區、組織活動了。但是，我做到了，我參與了很多活動，分享了很多技術，認識了很多志同道合的朋友，這些都是我以前從未有過的經歷，我也從中學到了很多，收穫了很多，升級到 Beta 便是證明。

為了讓更多的人了解微軟學生大使計劃，也是讓申請者們能夠少走彎路，接下來我將介紹下學生大使計劃和分享下我的經歷，也希望有更多學生大使能盡快升級。

學生大使計劃由Microsoft發起，旨在培養和支持全球範圍內的年輕領導者。作為學生大使，我們有機會代表 Microsoft 在學校和社區中扮演積極的角色，與其他有著相同激情的學生共同學習、合作和成長。

學生大使分為 4 個階段：New、Alpha、Beta 和 Gold，每個階段都有對應的福利和要求。當然，除了學生大使的福利以外，你還能用 edu 郵箱去申請 Azure、Github 的學生福利。

當你成功申請成為學生大使並成功入職後，便會進入 New 階段，同時你也能獲得 Microsoft 365 作為福利。在這個階段，你只需要完成一些很簡單的任務，比如完成一個 Microsoft Learn 路徑，就能進入到下一階段。

在晉升到 Alpha 後，你將獲得 Visual Studio 企業版訂閱，以及每月 150 美元的 Azure 額度等福利。而想要升級到 Beta，你需要完成一些更具挑戰性的任務，比如舉辦活動，以證明你的影響力。在升級到 Beta 後，你將收到 Microsoft 的 Beta 禮品包。最後，如果你想要升級到 Gold，你需要保持活躍度，舉辦更多的活動，進行更多的社區貢獻。 Gold 的申請是在每年的 12 月和 6 月進行審查，如果你成功升級到 Gold，你將獲得更多的福利，比如 Gold 禮品包、微軟最有價值專家提名等。

我最初是在某個技術交流群中看到有人分享學生大使計劃的鏈接，我就點進行想說看看，結果發現福利還不錯，便想說申請看看。但是發現申請還蠻複雜，除了個人信息外，還要寫英語小作文介紹自己的經歷，以及參與技術社區的經歷，並且還要錄一段視頻。我看到這裡確實是有放棄的想法，因為我此前參與的活動確實不多，並且我非常不擅長寫作。但那些福利又讓我心動，再加上我認為有這一經歷對我以後的發展也是有好處的，便決定硬著頭皮試一下。

雖然我英文也非常糟糕，但這部分完全可以藉助翻譯軟件，視頻也允許用母語，只是要加英文字幕而已，因此對我而言，最大的難點就在於寫作了。此前我有參加的活動，僅僅是學校的幾個比賽，以及在 Nvidia 舉辦的活動裡幫忙回答其他選手的問題，雖然也有寫一些博客，但也只是簡單的記錄而已。我認為這些經歷微不足道，但我還是把它們添油加醋的寫了出來。而視頻的內容，也是把小作文的內容再提煉整理了一下，然後用中文錄製，最後加上英文字幕，當然，我也錄製了好幾遍才錄出了相對流暢的版本。我將這些內容提交後，便等待結果了。

1 月多的時候，我收到了申請通過的郵件，我有些意外但也很開心。我照著郵件裡的鏈接進行入職程序，然後便進入了 New 階段，也收到了學生大使的賬號。在這個階段，我需要完成一個 Microsoft Learn 路徑，只需要幾個小時就能完成，沒過幾天我便自動升級到 Alpha 了。

在 Alpha 階段，我獲得了 Visual Studio 企業版訂閱，以及每月 150 美元的 Azure 額度等福利。我也開始了解微軟提供的一些服務，比如 Github Codespaces、Azure ML 等，並將我的收穫寫成教程發在 CSDN 和 Dev.To 上。同時，我也了解到微軟有推出 Azure OpenAI Service，但需要填表申請才能使用，於是我便用 edu 郵箱進行申請，沒想到很快就通過了。我也將這個過程寫成了教程，當然也包括申請後的使用教程，做成了一個 Azure OpenAI Service 的系列：

但是僅僅是寫教程是不夠的，升級到 Beta 的要求是能夠舉辦活動，需要 15 人參與，並且至少要有 20 分鐘時間是專注於分享微軟相關的技術。可以是線上或者線下，但一定要是學生大使自己舉辦的，並且一次活動只能作為一位學生大使的申請條件。如果你舉辦了活動，那麼就可以到學生大使的頁面，在 "Events" 中的 "Add Events" 進行申請。在申請時，你需要填寫活動的信息，以及參與的人數，以及活動的照片或者視頻。如果你的活動通過審核，那麼你就可以升級到 Beta 了。

舉辦活動的要求對我一個社恐是十分困難的。我也曾想過舉辦線上活動，但是我認為我沒有足夠的影響力，而且我也不知道該如何宣傳，因此我便放棄了這個想法。但後來我在某個技術群看到微軟的 Reactor 活動，那是個線上活動，以直播的方式分享技術。我也認為我在 Alpha 待了這麼久，也該做點什麼了，於是我硬著頭皮到微軟 Reactor 上直播分享，而分享的內容正是我之前寫的 Azure OpenAI Service 的教程。雖然我在直播前很緊張，但還是勉強完成了分享，而且也有人參與了我的直播。雖然我只是參加微軟的活動，但我作為演講者也應該能算是“舉辦”吧。雖然不太確定，但我還是將這個活動的信息、錄像都提交了上去，沒想到 2 天后我就收到了晉升 Beta 的郵件。這對我而言是個驚喜，也是鼓舞，也讓我對沖擊 Gold 有了信心。

（如果有人想看我的直播回放，可以點擊以下圖片↓）

我分享這些不僅僅是對我前一階段的總結，更是學生大使這條路的開門磚，希望有更多大中華地區的同學加入到微軟學生大使的行列，也期待有更多人加入到微軟學生大使計劃，申請鏈接在這裡。

與我相關的鏈接：