Google AI Edge Gallery 深度拆解：当手机成为大模型的「离线战场」——从 LiteRT 推理引擎到端侧 GenAI 的工程全貌（2026）

前言：端侧 AI 的「iPhone 时刻」

2026 年初，Google 做了一件可能改变 AI 格局的事——开源 AI Edge Gallery。这不是一个普通的 Demo App，而是一套完整的端侧大模型部署参考架构。它的核心价值在于：让普通手机在完全离线的情况下运行大语言模型。

这不是第一次有人尝试在移动端跑 LLM。llama.cpp 早就支持 Android，Ollama 也有移动端版本。但 Google 这次不一样——它不仅提供了用户级应用，更开源了整个技术栈的工程细节：从模型转换、量化优化、推理加速到多模态支持，全部可追溯、可复刻、可定制。

当你能在地铁上、飞机里、无网络的任何地方，用手机与 Gemma 4 对话、分析图片、生成代码，AI 的使用边界被彻底打破。云端 AI 给你能力，端侧 AI 给你自由。

本文将从源码级深度拆解 AI Edge Gallery 的工程全貌：LiteRT 推理引擎的核心架构、模型量化的底层原理、跨平台部署的技术难点，以及企业级落地的实战路径。

一、项目全景：AI Edge Gallery 是什么？

1.1 核心定位

AI Edge Gallery 是 Google 推出的实验性应用，定位为「移动端的生成式 AI 实验室」。它让用户在 Android 设备上：

• 完全离线运行 多种开源 LLM（Gemma、Phi-3、Qwen 等）
• 多模态交互：图像问答、多轮对话、音频处理
• 实时性能监控：TTFT（首 Token 延迟）、tokens/s、内存占用
• 模型灵活切换：支持从 Hugging Face 拉取新模型
• 自定义模型加载：可导入自己训练并转换好的 LiteRT 模型

关键数字：

• 支持设备：Android 11+（iOS 即将支持）
• 最低内存：2GB RAM
• 推理引擎：LiteRT（Google 自研）
• 开源协议：Apache 2.0

1.2 技术栈分层

┌─────────────────────────────────────────────────┐
│            AI Edge Gallery App                   │
│   (Kotlin/Java UI + Model Management)           │
├─────────────────────────────────────────────────┤
│          LiteRT-LM (Orchestration Layer)         │
│   Model Loading + Tokenization + Generation     │
├─────────────────────────────────────────────────┤
│            LiteRT Runtime (Core)                 │
│   GPU/NPU/NNAPI Acceleration + Quantization     │
├─────────────────────────────────────────────────┤
│         Hardware Abstraction Layer               │
│   Qualcomm Hexagon | ARM Ethos | MediaTek APU   │
└─────────────────────────────────────────────────┘

1.3 与竞品对比

Google 的优势：

1. 官方生态：与 Android NNAPI 深度集成，硬件加速更激进
2. 工具链完整：从 Hugging Face 模型到 .task 格式的一键转换
3. 多模态原生支持：视觉、音频、文本统一架构
4. 生产级成熟度：已用于 Chrome、Pixel Watch 等产品

二、LiteRT 推理引擎：端侧 AI 的「心脏」

2.1 LiteRT 是什么？

LiteRT（Lite Runtime） 是 Google 为移动端和嵌入式设备打造的高性能推理引擎。它的前身是 TensorFlow Lite Runtime，但在 2026 年被重新定位为一个更轻量、更专注的推理框架。

核心特点：

• 极小体积：运行时仅 3-5 MB，适合 App 集成
• 硬件加速原生：支持 NNAPI、GPU Delegate、Hexagon DSP
• 统一模型格式：.task 文件封装模型权重 + Tokenizer + 元数据
• 跨平台统一：Android、iOS、Web、Desktop、IoT 同一套 API

2.2 LiteRT vs TensorFlow Lite

很多人会问：LiteRT 和传统 TensorFlow Lite 有什么区别？

本质区别：TF Lite 是「瑞士军刀」，LiteRT 是「手术刀」。后者放弃了通用性，换取了 GenAI 场景下的极致性能。

2.3 LiteRT 核心架构

// LiteRT-LM 核心接口（简化版）
class LlmInferenceTask {
 public:
  // 从 .task 文件加载模型
  static std::unique_ptr<LlmInferenceTask> CreateFromFile(
      const std::string& model_path);
  
  // 执行推理（流式输出）
  void Generate(const std::string& prompt,
                std::function<void(const std::string&)> callback);
  
  // 性能监控
  Metrics GetMetrics() const;
  
 private:
  // 底层组件
  std::unique_ptr<Tokenizer> tokenizer_;      // 分词器
  std::unique_ptr<Engine> engine_;            // 推理引擎
  std::unique_ptr<KvCache> kv_cache_;         // KV 缓存
  std::unique_ptr<Accelerator> accelerator_; // 硬件加速器
};

关键组件解析：

1. Tokenizer（分词器）

LiteRT 内置多种分词器支持：

• SentencePiece：Gemma、T5 等主流
• BPE：GPT 系列
• Unigram：多语言模型

分词器直接嵌入 .task 文件，无需外部依赖。

2. Engine（推理引擎）

核心推理逻辑：

• Prefill：处理输入 Prompt，填充 KV Cache
• Decode：逐 Token 生成，流式输出
• Sampling：Top-P、Top-K、Temperature 采样

3. KV Cache（键值缓存）

这是 LLM 推理的核心优化点：

• Prefill 阶段：计算并缓存所有 Key-Value
• Decode 阶段：仅计算新 Token，复用历史 KV
• 内存管理：自动淘汰、动态扩容

4. Accelerator（硬件加速）

根据设备自动选择最优后端：

Accelerator::Backend SelectBestBackend() {
  // 优先级：NPU > GPU > CPU
  if (SupportsNNAPI()) return Backend::kNnapi;
  if (SupportsGPUDelegate()) return Backend::kGpu;
  return Backend::kCpu;
}

2.4 硬件加速机制详解

Android NNAPI 加速

// 配置 NNAPI Delegate
val nnapiOptions = NnapiDelegate.Options()
    .setAllowFp16(true)           // 启用 FP16 加速
    .setAcceleratorName("qti-hvx") // 指定高通 HVX
    .setExecutionPriority(3)       // 高优先级

val delegate = NnapiDelegate(nnapiOptions)
interpreter.modifyGraphWithDelegate(delegate)

支持的 NPU 架构：

• Qualcomm Hexagon：骁龙 8 Gen 3+ 的 HVX 和 HTP
• ARM Ethos：Cortex-X 系列的 NPU
• MediaTek APU：天玑 9000+ 系列
• Samsung NPU：Exynos 2400 系列

GPU Delegate 加速

对于不支持 NPU 的设备，LiteRT 会降级到 GPU：

val gpuOptions = GpuDelegate.Options()
    .setEnableQuantizedInference(true) // 量化推理
    .setModelBindings(GpuDelegate.ModelBindings()
        .setPrecisionLossAllowed(true)) // 允许精度损失换取速度

val gpuDelegate = GpuDelegate(gpuOptions)

性能对比（以 Gemma 4 4B 为例）：

三、模型量化：从 32GB 到 2GB 的「瘦身术」

3.1 为什么必须量化？

以 Gemma 4 12B 为例：

• 原始大小（FP32）：48 GB
• FP16：24 GB
• INT8：12 GB
• INT4：6 GB

手机内存限制：

• 旗舰机：12-16 GB RAM（可用约 8-10 GB）
• 中端机：6-8 GB RAM（可用约 4-6 GB）
• 入门机：4 GB RAM（可用约 2-3 GB）

结论：不量化，大模型根本跑不起来。

3.2 LiteRT 量化方案

LiteRT 支持三种量化级别：

1. INT4 量化（推荐）

# 模型转换脚本（简化版）
from ai_edge_converter import Converter

converter = Converter(
    model_path="gemma-4-12b",
    quantization="int4",
    calibration_data=calibration_dataset,  # 校准数据集
    enable_kv_cache=True,                  # 启用 KV Cache
    enable_speculative_decoding=True       # 启用投机解码
)

converter.convert("gemma-4-12b-int4.task")

效果：

• 模型大小：~6 GB
• 精度损失：< 2%（在 MMLU、HumanEval 等基准上）
• 推理速度：比 FP16 快 2-3 倍

2. INT8 量化（平衡方案）

converter = Converter(
    model_path="gemma-4-12b",
    quantization="int8",
    per_channel=True,  # 每通道独立量化
    symmetric=False    # 非对称量化
)

效果：

• 模型大小：~12 GB
• 精度损失：< 0.5%
• 推理速度：比 FP16 快 1.5-2 倍

3. FP16（不推荐）

converter = Converter(
    model_path="gemma-4-12b",
    quantization="fp16"
)

问题：模型太大，大部分手机无法运行。

3.3 量化底层原理

INT4 量化的数学原理

量化公式：

q = round(r / scale) + zero_point

其中：

• r：原始 FP32 值
• q：量化后的 INT4 值（-8 到 7）
• scale：缩放因子
• zero_point：零点偏移

反量化公式：

r = (q - zero_point) * scale

实际示例（以某个权重矩阵为例）：

# 原始权重
weights_fp32 = [0.23, -0.45, 0.67, -0.12, 0.89, -0.34]

# 计算量化参数
max_val = max(abs(w) for w in weights_fp32)  # 0.89
scale = max_val / 7  # 将范围映射到 [-7, 7]
zero_point = 0  # 对称量化

# 量化
weights_int4 = [round(w / scale) for w in weights_fp32]
# 结果：[2, -4, 5, -1, 7, -3]

# 反量化（验证）
weights_reconstructed = [q * scale for q in weights_int4]
# 结果：[0.254, -0.508, 0.635, -0.127, 0.889, -0.381]
# 相对误差：约 5%

KV Cache 量化

除了模型权重，KV Cache 也需要量化：

class QuantizedKvCache {
 public:
  void Store(int layer, const std::vector<float>& key,
             const std::vector<float>& value) {
    // 量化 Key
    auto quantized_key = QuantizeToInt4(key, key_scale_[layer]);
    // 量化 Value
    auto quantized_value = QuantizeToInt4(value, value_scale_[layer]);
    
    // 存储
    cache_[layer] = {quantized_key, quantized_value};
  }
  
  std::pair<std::vector<float>, std::vector<float>> 
  Load(int layer) {
    // 反量化
    auto key = DequantizeFromInt4(cache_[layer].key, key_scale_[layer]);
    auto value = DequantizeFromInt4(cache_[layer].value, value_scale_[layer]);
    return {key, value};
  }
  
 private:
  std::unordered_map<int, QuantizedKv> cache_;
  std::vector<float> key_scale_;  // 每层独立的缩放因子
  std::vector<float> value_scale_;
};

效果：

• KV Cache 内存占用：减少 8 倍
• 长文本生成：从 1000 tokens 扩展到 4000+ tokens

3.4 量化精度损失评估

基准测试对比（Gemma 4 12B）：

结论：INT4 量化的精度损失在可接受范围内，而内存和速度收益巨大。

四、多模态架构：视觉 + 音频 + 文本的统一

4.1 多模态模型支持

AI Edge Gallery 原生支持多模态模型：

支持的模型

4.2 视觉编码器架构

// 视觉编码流程
class VisionEncoder {
  fun encodeImage(imageBitmap: Bitmap): FloatArray {
    // 1. 图像预处理
    val resized = resize(imageBitmap, 224, 224)
    val normalized = normalize(resized, mean, std)
    
    // 2. Patch Embedding
    val patches = splitIntoPatches(normalized, patchSize = 14)
    val embeddings = patchEmbedding(patches)  // [N, 768]
    
    // 3. Vision Transformer
    val encoded = visionTransformer.forward(embeddings)
    
    // 4. 投影到 LLM 空间
    val projected = projectionLayer(encoded)
    
    return projected
  }
}

关键参数：

• 图像输入：224x224 像素
• Patch 大小：14x14 像素
• Embedding 维度：768（SigLIP）/ 1024（PaliGemma）

4.3 音频处理流程

// 音频编码流程
class AudioEncoder {
  fun encodeAudio(audioData: FloatArray): FloatArray {
    // 1. Log-Mel 频谱
    val melSpectrogram = computeMelSpectrogram(audioData)
    val logMel = log(melSpectrogram + epsilon)
    
    // 2. 卷积层
    val convOutput = conv1d.forward(logMel)
    
    // 3. Transformer Encoder
    val encoded = audioTransformer.forward(convOutput)
    
    return encoded
  }
}

4.4 多模态融合策略

// 多模态融合
class MultimodalFusion {
  fun fuse(
    textTokens: IntArray,
    imageEmbeddings: FloatArray?,
    audioEmbeddings: FloatArray?
  ): FloatArray {
    // 文本 Token Embedding
    var combined = textEmbedding(textTokens)
    
    // 插入视觉 Embedding
    if (imageEmbeddings != null) {
      combined = insertAtPosition(combined, imageEmbeddings, position = 0)
    }
    
    // 插入音频 Embedding
    if (audioEmbeddings != null) {
      combined = insertAtPosition(combined, audioEmbeddings, position = 0)
    }
    
    // 统一 Transformer 处理
    return llmTransformer.forward(combined)
  }
}

效果示例：

• 输入：图片（表格）+ 问题「这个表格的总和是多少？」
• 处理：视觉编码 → OCR → LLM 推理 → 输出答案
• 延迟：约 1.5 秒（在骁龙 8 Gen 3 上）

五、工程实战：从 Hugging Face 到手机部署

5.1 完整部署流程

┌──────────────────┐
│ Hugging Face     │
│ Model (PyTorch)  │
└────────┬─────────┘
         │ 1. 下载模型
         ▼
┌──────────────────┐
│ AI Edge          │
│ Converter        │ ← 量化 + 优化
└────────┬─────────┘
         │ 2. 转换为 .task 格式
         ▼
┌──────────────────┐
│ .task 文件       │ ← 包含权重、Tokenizer、元数据
│ (6-12 GB)        │
└────────┬─────────┘
         │ 3. 分发到设备
         ▼
┌──────────────────┐
│ AI Edge Gallery  │
│ App              │ ← 加载模型并推理
└──────────────────┘

5.2 模型转换实战

Step 1：准备环境

# 安装 AI Edge Converter
pip install ai-edge-converter

# 安装依赖
pip install torch transformers sentencepiece

Step 2：下载源模型

# 从 Hugging Face 下载
huggingface-cli download google/gemma-4-12b-it \
  --local-dir ./gemma-4-12b

Step 3：创建校准数据集

# calibration_dataset.py
from datasets import load_dataset

# 加载通用数据集
dataset = load_dataset("c4", "en", split="train[:1000]")

# 提取文本
calibration_texts = [item["text"] for item in dataset][:512]

# 保存
with open("calibration.txt", "w") as f:
    f.write("\n".join(calibration_texts))

Step 4：执行转换

# convert_model.py
from ai_edge_converter import Converter

converter = Converter(
    # 模型配置
    model_path="./gemma-4-12b",
    model_type="gemma",
    
    # 量化配置
    quantization="int4",
    calibration_data="calibration.txt",
    
    # 优化配置
    enable_kv_cache=True,
    enable_speculative_decoding=False,
    enable_multimodal=False,
    
    # 输出配置
    output_path="gemma-4-12b-int4.task"
)

# 执行转换
converter.convert()

# 验证
converter.verify()

Step 5：上传到设备

方式 1：ADB 推送

adb push gemma-4-12b-int4.task /sdcard/Download/

方式 2：应用内下载

// 在 App 中提供下载链接
val modelUrl = "https://your-cdn.com/gemma-4-12b-int4.task"
ModelDownloader.download(modelUrl, onProgress = { progress ->
  updateProgress(progress)
})

5.3 自定义 LiteRT 模型加载

Kotlin 代码示例

// LocalLlm.kt
class LocalLlm(private val context: Context) {
  private var llmTask: LlmInferenceTask? = null
  
  // 加载模型
  suspend fun loadModel(modelPath: String): Result<Unit> {
    return withContext(Dispatchers.IO) {
      try {
        // 创建推理任务
        llmTask = LlmInferenceTask.createFromFile(context, modelPath)
        
        // 配置参数
        llmTask?.apply {
          setMaxTokens(2048)
          setTopK(40)
          setTopP(0.9f)
          setTemperature(0.7f)
        }
        
        Result.success(Unit)
      } catch (e: Exception) {
        Result.failure(e)
      }
    }
  }
  
  // 生成文本（流式）
  fun generate(
    prompt: String,
    onToken: (String) -> Unit,
    onComplete: () -> Unit
  ) {
    llmTask?.generate(prompt, object : LlmInferenceTask.Callback {
      override fun onToken(token: String) {
        onToken(token)
      }
      
      override fun onComplete() {
        onComplete()
      }
      
      override fun onError(e: Exception) {
        Log.e("LocalLlm", "Generation failed", e)
      }
    })
  }
  
  // 获取性能指标
  fun getMetrics(): Metrics {
    return llmTask?.getMetrics() ?: Metrics()
  }
  
  // 释放资源
  fun unload() {
    llmTask?.close()
    llmTask = null
  }
}

UI 集成

// ChatScreen.kt
@Composable
fun ChatScreen(viewModel: ChatViewModel) {
  var inputText by remember { mutableStateOf("") }
  var responseText by remember { mutableStateOf("") }
  
  Column {
    // 显示对话
    LazyColumn {
      items(viewModel.messages) { message ->
        MessageBubble(message)
      }
    }
    
    // 输入框
    Row {
      TextField(
        value = inputText,
        onValueChange = { inputText = it },
        modifier = Modifier.weight(1f)
      )
      
      Button(onClick = {
        viewModel.sendMessage(inputText)
        inputText = ""
      }) {
        Text("发送")
      }
    }
    
    // 性能指标
    viewModel.metrics?.let { metrics ->
      Row {
        Text("TTFT: ${metrics.ttft}ms")
        Text("Speed: ${metrics.tokensPerSecond} tokens/s")
        Text("Memory: ${metrics.memoryUsed}MB")
      }
    }
  }
}

5.4 性能优化技巧

1. 选择合适的模型大小

2. 调整生成参数

// 速度优先
llmTask.apply {
  setMaxTokens(512)      // 限制输出长度
  setTopK(20)            // 降低 Top-K
  setTemperature(0.5f)   // 降低温度
}

// 质量优先
llmTask.apply {
  setMaxTokens(2048)
  setTopK(40)
  setTemperature(0.8f)
}

3. 启用投机解码

// 投机解码：用小模型「猜」大模型的输出
llmTask.enableSpeculativeDecoding(
  drafterModel = "gemma-4-2b.task",  // 草稿模型
  acceptanceThreshold = 0.9f
)

效果：生成速度提升 2-3 倍，精度损失 < 1%。

4. KV Cache 优化

// 动态 KV Cache 管理
llmTask.setKvCacheConfig(
  maxSize = 4096,          // 最大 Token 数
  evictionPolicy = "lru",  // 淘汰策略
  quantization = "int4"    // KV Cache 量化
)

六、企业级落地场景

6.1 场景一：医疗问诊助手（离线合规）

需求：医院 App 需在无网络环境下提供初步症状分析。

技术方案：

// 医疗助手封装
class MedicalAssistant(context: Context) {
  private val llm = LocalLlm(context)
  private val knowledgeBase = LocalVectorDb(context)
  
  suspend fun analyzeSymptoms(symptoms: String): Diagnosis {
    // 1. RAG 检索本地医疗知识库
    val relevantInfo = knowledgeBase.search(symptoms, topK = 5)
    
    // 2. 构建 Prompt
    val prompt = """
      你是一位专业的医疗助手。根据以下信息回答用户问题。
      
      相关医学知识：
      ${relevantInfo.joinToString("\n")}
      
      用户症状：$symptoms
      
      请提供初步分析建议（非诊断）。
    """.trimIndent()
    
    // 3. LLM 推理
    val response = llm.generate(prompt)
    
    // 4. 日志脱敏
    val sanitized = sanitizeLog(symptoms, response)
    LocalLogger.log(sanitized)
    
    return Diagnosis(response, confidence = 0.85f)
  }
}

合规要点：

• 模型在本地运行，患者数据永不离开设备
• 支持 HIPAA/GDPR 合规
• 日志本地加密存储

6.2 场景二：工业设备智能巡检

需求：工程师通过手机拍摄设备照片，AI 自动识别故障。

技术方案：

// 工业巡检助手
class IndustrialInspector(context: Context) {
  private val visionLlm = MultimodalLlm(context, "paligemma-3b.task")
  private val knowledgeBase = EquipmentManualDb(context)
  
  suspend fun inspectEquipment(
    photo: Bitmap,
    equipmentId: String
  ): InspectionResult {
    // 1. 视觉编码
    val imageEmbedding = visionLlm.encodeImage(photo)
    
    // 2. 检索设备手册
    val manual = knowledgeBase.getManual(equipmentId)
    
    // 3. 多模态推理
    val prompt = """
      根据设备手册，分析照片中的设备状态。
      手册内容：${manual.summary}
      
      请指出可能的故障点并给出维修建议。
    """.trimIndent()
    
    val analysis = visionLlm.generate(prompt, imageEmbedding)
    
    // 4. 结构化输出
    return parseInspectionResult(analysis)
  }
}

6.3 场景三：教育智能辅导（离线学习）

需求：学生用平板练习数学题，AI 实时讲解错题。

技术方案：

// 数学辅导员
class MathTutor(context: Context) {
  private val llm = LocalLlm(context, "math-specialist-3b.task")
  private val handwritingRecognizer = HandwritingRecognizer(context)
  
  suspend fun explainWrongAnswer(
    photo: Bitmap,  // 拍摄的题目和答案
    correctAnswer: String
  ): Explanation {
    // 1. 手写识别
    val recognized = handwritingRecognizer.recognize(photo)
    val (question, studentAnswer) = parseQuestionAndAnswer(recognized)
    
    // 2. 构建讲解 Prompt
    val prompt = """
      题目：$question
      学生答案：$studentAnswer
      正确答案：$correctAnswer
      
      请用通俗易懂的方式讲解这道题，指出学生的错误原因。
    """.trimIndent()
    
    // 3. 生成讲解
    val explanation = llm.generate(prompt)
    
    // 4. 渲染 LaTeX
    val rendered = LatexRenderer.render(explanation)
    
    return Explanation(rendered, wrongPoints = extractWrongPoints(explanation))
  }
}

七、常见问题与解决方案

7.1 模型加载失败

问题：Error loading model: OutOfMemoryError

原因：

• 设备内存不足
• 模型过大（如 Gemma 4 12B 在 6GB 设备上）

解决方案：

// 动态选择模型
val model = when {
  totalMemory >= 12 * 1024 -> "gemma-4-12b-int4.task"
  totalMemory >= 8 * 1024 -> "gemma-4-4b-int4.task"
  else -> "gemma-4-e2b-int4.task"
}

// 或启用内存压缩
llmTask.enableMemoryCompression(true)

7.2 推理速度慢

问题：生成速度 < 5 tokens/s

排查步骤：

// 1. 检查硬件加速
val backend = llmTask.getCurrentBackend()
Log.d("LiteRT", "Using backend: $backend")  // 应为 GPU 或 NPU

// 2. 检查量化级别
val quantization = llmTask.getQuantizationLevel()
Log.d("LiteRT", "Quantization: $quantization")  // 应为 INT4

// 3. 检查温度设置
val temperature = llmTask.getTemperature()
if (temperature > 1.0f) {
  llmTask.setTemperature(0.7f)  // 降低温度
}

7.3 Tokenizer 不一致

问题：输出全是乱码 <unk>

原因：模型转换时未正确嵌入 Tokenizer

解决方案：

# 转换时显式指定 Tokenizer
converter = Converter(
    model_path="./gemma-4-12b",
    tokenizer_path="./gemma-4-12b/tokenizer.model",  # 显式指定
    tokenizer_type="sentencepiece"
)

7.4 跨设备兼容性

问题：在 Pixel 上流畅，在小米上崩溃

解决方案：

// 硬件能力检测
val capabilities = LiteRT.getDeviceCapabilities()
val supportedOps = capabilities.supportedOperations

// 降级策略
val backend = when {
  supportedOps.contains("NPU_GEMV") -> Backend.NPU
  supportedOps.contains("GPU_INT4") -> Backend.GPU
  else -> Backend.CPU
}

llmTask.setPreferredBackend(backend)

八、未来展望：端侧 AI 的下一个五年

8.1 技术趋势

1. 更小的模型，更强的能力

   • 2026：4B 参数达到 2024 年 70B 模型的能力
   • 2028：1B 模型可处理复杂推理任务

2. 多模态融合深化

   • 视觉 + 音频 + 文本 + 触觉 + 嗅觉
   • 实时环境感知与交互

3. 边缘-云协同

   • 敏感数据本地处理
   • 复杂任务云端扩展
   • 无缝切换体验

8.2 商业机会

1. 企业级应用

   • 合规型 AI 助手（医疗、金融、法律）
   • 工业智能巡检
   • 教育个性化辅导

2. 消费级产品

   • 离线个人助理
   • 隐私优先的智能设备
   • 无网络环境的 AI 服务

3. 基础设施

   • 端侧模型托管平台
   • LiteRT 优化服务
   • 边缘 AI 开发工具链

九、总结：端侧 AI 的「iPhone 时刻」已来

Google AI Edge Gallery + LiteRT 的组合，标志着生成式 AI 从「云中心」走向「人身边」。

核心价值：

• 隐私：数据永不离开设备
• 可靠：无网络也能使用
• 低延迟：毫秒级响应
• 低成本：无 API 调用费用

适用人群：

• 普通用户：体验离线大模型
• 开发者：学习端侧 AI 部署
• 产品经理：寻找 AI 落地方案
• 企业：构建合规 AI 应用

技术要点：

• LiteRT 是核心推理引擎，支持 GPU/NPU 加速
• INT4 量化是主流方案，精度损失可控
• 多模态统一架构，视觉/音频/文本一体化
• 企业级落地需关注合规、性能、兼容性

下一步行动：

1. 下载 AI Edge Gallery App 体验
2. 阅读 LiteRT 官方文档
3. 尝试转换自己的模型
4. 探索企业级应用场景

项目地址：

• AI Edge Gallery：https://github.com/google-ai-edge/gallery
• LiteRT-LM：https://github.com/google-ai-edge/LiteRT-LM

端侧 AI 的黄金时代已来，你准备好了吗？

参考资料：

• LiteRT 官方文档
• AI Edge Gallery GitHub
• Gemma 4 技术报告
• Android NNAPI 开发指南