树莓派AI项目：在迷你电脑上运行人工智能

树莓派（Raspberry Pi）是一款价格低廉、体积小巧的单板计算机，自问世以来就受到了全球创客和开发者的热爱。很多人认为 AI 需要昂贵的 GPU 和强大的服务器，但实际上，树莓派也能运行很多实用的 AI 项目。本文将分享 5 个精彩的树莓派 AI 项目，从入门级的语音助手到进阶的智能家居控制器，让你用几百元的硬件就能体验人工智能的魅力。

一、树莓派的 AI 能力概述

1.1 树莓派硬件参数

目前主流的树莓派型号是 Raspberry Pi 5，它的核心参数如下：

• 处理器：Broadcom BCM2712，四核 Arm Cortex-A76 @ 2.4GHz
• 内存：4GB 或 8GB LPDDR4X
• 存储：MicroSD 卡或 NVMe SSD（通过 HAT）
• 接口：2x USB 3.0、2x USB 2.0、2x Micro HDMI、GPIO 40针
• 网络：千兆以太网、Wi-Fi 5、蓝牙 5.0
• 价格：约 400-600 元人民币

1.2 树莓派能跑什么样的 AI

虽然树莓派的算力无法与桌面 GPU 相比，但它仍然可以运行多种 AI 模型：

• 小型语言模型：通过量化技术可以运行 1B-3B 参数的小型 LLM
• 计算机视觉：物体检测、人脸识别、图像分类
• 语音识别：本地语音转文字
• 语音合成：文字转语音
• 边缘 AI：TinyML 模型推理
• AI 助手：结合各种 AI 能力的综合应用

1.3 性能优化手段

在树莓派上运行 AI，需要特别注意性能优化：

• 模型量化：使用 INT8 或 INT4 量化减少计算量
• ONNX Runtime：使用优化后的推理引擎
• TensorFlow Lite：专为边缘设备设计的推理框架
• NCNN / MNN：移动端和嵌入式设备优化的推理框架
• Hailo AI HAT：树莓派专用的 AI 加速模块（26 TOPS 算力）

1.4 硬件准备清单

除了树莓派本体，你可能还需要：

二、项目一：本地语音助手

2.1 项目概述

我们要做的第一个项目是一个完全本地运行的语音助手，类似 Siri 或 Alexa，但所有处理都在树莓派上完成，不需要联网，也不会将你的语音数据发送到任何服务器。

功能特性：

• 语音唤醒（“Hey Pi”）
• 语音转文字（本地 STT）
• 自然语言理解
• 文字转语音回复
• 可自定义的技能和命令

2.2 系统安装和配置

首先安装 Raspberry Pi OS（64位）：

# 使用 Raspberry Pi Imager 烧录系统
# 选择 Raspberry Pi OS (64-bit) with desktop

# 更新系统
sudo apt update && sudo apt upgrade -y

# 安装基础依赖
sudo apt install -y python3-pip python3-venv portaudio19-dev \
    libffi-dev libssl-dev swig

# 创建虚拟环境
python3 -m venv ~/ai-assistant
source ~/ai-assistant/bin/activate

2.3 安装语音识别组件

我们使用 OpenAI 的 Whisper 模型进行本地语音识别：

# 安装 Whisper
pip install openai-whisper

# 或使用 faster-whisper（更快的替代方案）
pip install faster-whisper

# 安装音频处理库
pip install pyaudio sounddevice numpy

2.4 安装语音合成组件

使用 Piper TTS 进行本地语音合成，它速度快、质量高：

# 安装 Piper TTS
pip install piper-tts

# 下载中文语音模型
mkdir -p ~/models/piper
cd ~/models/piper
wget https://huggingface.co/rhasspy/piper-voices/zh_CN/zh_CN-huayan-medium/zh_CN-huayan-medium.onnx
wget https://huggingface.co/rhasspy/piper-voices/zh_CN/zh_CN-huayan-medium/zh_CN-huayan-medium.onnx.json

2.5 安装本地语言模型

使用 Ollama 在树莓派上运行小型语言模型：

# 安装 Ollama
curl -fsSL https://ollama.com/install.sh | sh

# 下载小型模型（适合树莓派）
ollama pull phi3:mini    # 微软 Phi-3 Mini，约 2GB
# 或
ollama pull qwen2:1.5b   # 通义千问 1.5B，约 1GB

2.6 核心代码实现

#!/usr/bin/env python3
"""树莓派本地语音助手"""

import sounddevice as sd
import numpy as np
from faster_whisper import WhisperModel
import requests
import subprocess
import json

# 配置
WAKE_WORD = "嘿派"
WHISPER_MODEL = "small"  # small 模型在树莓派5上平衡速度和质量
LLM_MODEL = "qwen2:1.5b"
OLLAMA_URL = "http://localhost:11434"

# 初始化 Whisper
whisper_model = WhisperModel(WHISPER_MODEL, device="cpu", 
                              compute_type="int8")

def record_audio(duration=5, sample_rate=16000):
    """录制音频"""
    print("正在录音...")
    audio = sd.rec(int(duration * sample_rate), 
                   samplerate=sample_rate, 
                   channels=1, dtype='float32')
    sd.wait()
    return audio

def transcribe(audio):
    """语音转文字"""
    # 保存临时文件
    import soundfile as sf
    sf.write("/tmp/temp_audio.wav", audio, 16000)
    
    segments, info = whisper_model.transcribe(
        "/tmp/temp_audio.wav", 
        language="zh",
        beam_size=5
    )
    text = "".join([segment.text for segment in segments])
    return text.strip()

def ask_llm(prompt):
    """调用本地大模型"""
    response = requests.post(
        f"{OLLAMA_URL}/api/generate",
        json={
            "model": LLM_MODEL,
            "prompt": prompt,
            "stream": False,
            "system": "你是一个友善的语音助手，回答简洁明了。"
        }
    )
    return response.json()["response"]

def speak(text):
    """文字转语音"""
    cmd = f'echo "{text}" | piper --model ~/models/piper/zh_CN-huayan-medium.onnx --output_raw | aplay -r 22050 -f S16_LE -t raw -'
    subprocess.run(cmd, shell=True)

def main():
    """主循环"""
    print("语音助手已启动，等待唤醒词...")
    
    while True:
        # 持续监听，等待唤醒词
        audio = record_audio(duration=2)
        text = transcribe(audio)
        
        if WAKE_WORD in text:
            speak("我在听，请说")
            
            # 录制用户指令
            audio = record_audio(duration=5)
            user_input = transcribe(audio)
            print(f"用户说: {user_input}")
            
            if user_input:
                # 调用语言模型
                response = ask_llm(user_input)
                print(f"助手: {response}")
                
                # 语音回复
                speak(response)

if __name__ == "__main__":
    main()

2.7 性能优化

在树莓派上，这个语音助手的响应时间大约为：

• 语音识别：2-4 秒
• LLM 推理：3-8 秒
• 语音合成：1-2 秒
• 总响应时间：约 6-14 秒

虽然不如云端方案快，但完全本地运行、保护隐私的特点让它非常实用。

三、项目二：智能安防摄像头

3.1 项目概述

利用树莓派和摄像头搭建一个具备 AI 识别能力的智能安防系统。它可以自动检测画面中的人、车辆和动物，当检测到异常活动时发送通知。

功能特性：

• 实时人形检测
• 车辆和动物识别
• 移动侦测
• 异常事件通知（邮件/微信/Telegram）
• 录像回放
• 本地存储，保护隐私

3.2 硬件准备

• 树莓派 5（推荐 8GB 版本）
• USB 摄像头或树莓派官方摄像头模块
• Hailo AI HAT（可选，大幅提升检测速度）
• 大容量 MicroSD 卡或 SSD

3.3 安装目标检测模型

# 安装 OpenCV
sudo apt install -y python3-opencv

# 安装目标检测框架
pip install ultralytics  # YOLOv8
pip install onnxruntime  # ONNX 推理

# 下载轻量级模型
python3 -c "
from ultralytics import YOLO
model = YOLO('yolov8n.pt')  # nano 模型，最小最快
model.export(format='onnx', imgsz=320)  # 导出 ONNX 格式
"

3.4 核心检测代码

#!/usr/bin/env python3
"""树莓派智能安防摄像头"""

import cv2
import onnxruntime as ort
import numpy as np
from datetime import datetime
import time
import smtplib
from email.mime.text import MIMEText
from email.mime.image import MIMEImage

class SmartCamera:
    def __init__(self):
        # 初始化摄像头
        self.cap = cv2.VideoCapture(0)
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        
        # 加载 YOLOv8 模型
        self.session = ort.InferenceSession("yolov8n.onnx")
        self.input_name = self.session.get_inputs()[0].name
        
        # 关注的目标类别
        self.alert_classes = ['person', 'car', 'dog', 'cat']
        self.last_alert_time = 0
        self.alert_cooldown = 300  # 5分钟内不重复报警
        
    def preprocess(self, frame):
        """预处理图像"""
        img = cv2.resize(frame, (320, 320))
        img = img.transpose(2, 0, 1)  # HWC -> CHW
        img = img.astype(np.float32) / 255.0
        img = np.expand_dims(img, axis=0)
        return img
    
    def detect(self, frame):
        """目标检测"""
        input_data = self.preprocess(frame)
        outputs = self.session.run(None, {self.input_name: input_data})
        
        # 解析检测结果
        detections = self.parse_outputs(outputs, frame.shape)
        return detections
    
    def parse_outputs(self, outputs, original_shape):
        """解析模型输出"""
        # 简化版的后处理逻辑
        detections = []
        # 实际使用时需要完整的 NMS 后处理
        return detections
    
    def send_alert(self, frame, detected_objects):
        """发送告警通知"""
        current_time = time.time()
        if current_time - self.last_alert_time < self.alert_cooldown:
            return
            
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        objects_str = ", ".join(detected_objects)
        message = f"检测到: {objects_str}\n时间: {timestamp}"
        
        print(f"[告警] {message}")
        
        # 保存截图
        filename = f"/home/pi/security/alerts/{timestamp.replace(' ', '_').replace(':', '-')}.jpg"
        cv2.imwrite(filename, frame)
        
        self.last_alert_time = current_time
    
    def run(self):
        """主循环"""
        print("智能安防摄像头已启动")
        
        while True:
            ret, frame = self.cap.read()
            if not ret:
                continue
            
            # 每秒检测一帧（降低 CPU 占用）
            detections = self.detect(frame)
            
            # 检查是否检测到关注的目标
            detected_objects = []
            for det in detections:
                if det['class'] in self.alert_classes:
                    detected_objects.append(det['class'])
            
            if detected_objects:
                self.send_alert(frame, detected_objects)
            
            # 可选：显示实时画面
            # cv2.imshow('Security Camera', frame)
            # if cv2.waitKey(1) & 0xFF == ord('q'):
            #     break
            
            time.sleep(0.1)

if __name__ == "__main__":
    camera = SmartCamera()
    camera.run()

3.5 使用 Hailo AI HAT 加速

如果你购买了 Hailo AI HAT，检测速度可以从每秒 2-3 帧提升到每秒 20+ 帧：

# 安装 Hailo 运行时
sudo apt install hailo-all

# 使用 Hailo 优化的模型
from hailo_platform import HEF
hef = HEF("yolov8n_hailo.hef")

四、项目三：本地 AI 文档助手

4.1 项目概述

在树莓派上搭建一个基于 RAG（检索增强生成）的本地文档助手。你可以将 PDF、Word、TXT 等文档导入系统，然后用自然语言提问，AI 会基于你的文档内容给出准确回答。

应用场景：

• 个人知识库管理
• 小型团队的文档共享和检索
• 学生论文和教材的智能问答
• 公司制度文件查询

4.2 技术栈

• Ollama：本地 LLM 推理
• ChromaDB：轻量级向量数据库
• LangChain：RAG 框架
• Streamlit：Web 界面

4.3 系统搭建

# 安装依赖
pip install langchain chromadb sentence-transformers
pip install streamlit pypdf python-docx
pip install langchain-community langchain-ollama

# 确保 Ollama 已安装并运行
ollama pull qwen2:1.5b

4.4 文档导入和处理

#!/usr/bin/env python3
"""本地文档助手 - 文档导入模块"""

import os
from langchain_community.document_loaders import (
    PyPDFLoader, TextLoader, Docx2txtLoader
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import HuggingFaceEmbeddings
import chromadb

# 初始化向量数据库
client = chromadb.PersistentClient(path="./chroma_db")
collection = client.get_or_create_collection(
    name="documents",
    metadata={"hnsw:space": "cosine"}
)

# 初始化嵌入模型
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
    model_kwargs={'device': 'cpu'}
)

# 文本分割器
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", "。", "！", "？", ".", " "]
)

def load_document(file_path):
    """加载不同格式的文档"""
    ext = os.path.splitext(file_path)[1].lower()
    
    if ext == '.pdf':
        loader = PyPDFLoader(file_path)
    elif ext == '.txt':
        loader = TextLoader(file_path, encoding='utf-8')
    elif ext in ['.docx', '.doc']:
        loader = Docx2txtLoader(file_path)
    else:
        raise ValueError(f"不支持的文件格式: {ext}")
    
    return loader.load()

def process_and_store(file_path):
    """处理文档并存入向量数据库"""
    print(f"正在处理: {file_path}")
    
    # 加载文档
    documents = load_document(file_path)
    
    # 分割文本
    chunks = text_splitter.split_documents(documents)
    print(f"  生成 {len(chunks)} 个文本块")
    
    # 生成嵌入并存入数据库
    for i, chunk in enumerate(chunks):
        embedding = embeddings.embed_query(chunk.page_content)
        doc_id = f"{os.path.basename(file_path)}_{i}"
        
        collection.add(
            ids=[doc_id],
            embeddings=[embedding],
            documents=[chunk.page_content],
            metadatas=[{
                "source": file_path,
                "chunk_index": i,
                "filename": os.path.basename(file_path)
            }]
        )
    
    print(f"  已存入向量数据库")

def search_documents(query, n_results=3):
    """搜索相关文档"""
    query_embedding = embeddings.embed_query(query)
    results = collection.query(
        query_embeddings=[query_embedding],
        n_results=n_results
    )
    return results

4.5 Web 界面

#!/usr/bin/env python3
"""Streamlit Web 界面"""

import streamlit as st
import requests
import os

st.set_page_config(page_title="树莓派文档助手", page_icon="📚")
st.title("📚 本地文档助手")

# 文件上传
uploaded_files = st.file_uploader(
    "上传文档", 
    type=["pdf", "txt", "docx"],
    accept_multiple_files=True
)

if uploaded_files:
    for file in uploaded_files:
        save_path = f"/tmp/{file.name}"
        with open(save_path, "wb") as f:
            f.write(file.getbuffer())
        process_and_store(save_path)
    st.success("文档已成功导入！")

# 问答界面
query = st.text_input("请输入你的问题：")

if query:
    # 检索相关文档
    results = search_documents(query, n_results=3)
    
    # 构建上下文
    context = "\n".join(results['documents'][0])
    
    # 调用 LLM
    prompt = f"""基于以下参考资料回答问题。如果资料中没有相关信息，请说明。

参考资料：
{context}

问题：{query}

回答："""
    
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": "qwen2:1.5b",
            "prompt": prompt,
            "stream": False
        }
    )
    
    answer = response.json()["response"]
    st.write("### 回答")
    st.write(answer)
    
    # 显示引用来源
    st.write("### 参考来源")
    for meta in results['metadatas'][0]:
        st.write(f"- {meta['filename']}")

运行方式：

streamlit run doc_assistant.py --server.port 8501

五、项目四：AI 植物识别器

5.1 项目概述

使用树莓派和摄像头制作一个 AI 植物识别器。将摄像头对准植物，系统自动识别植物种类，并提供养护建议。这个项目的亮点在于它可以完全离线运行。

5.2 技术实现

#!/usr/bin/env python3
"""AI 植物识别器"""

import cv2
import numpy as np
import onnxruntime as ort
import json
from PIL import Image

class PlantIdentifier:
    def __init__(self):
        # 加载植物分类模型
        self.session = ort.InferenceSession("plant_model.onnx")
        self.input_name = self.session.get_inputs()[0].name
        
        # 加载植物数据库
        with open("plant_database.json", "r") as f:
            self.plant_db = json.load(f)
    
    def capture_and_identify(self):
        """拍照并识别"""
        cap = cv2.VideoCapture(0)
        ret, frame = cap.read()
        cap.release()
        
        if not ret:
            return None
        
        # 预处理
        img = cv2.resize(frame, (224, 224))
        img = img.astype(np.float32) / 255.0
        img = np.expand_dims(img.transpose(2, 0, 1), axis=0)
        
        # 推理
        outputs = self.session.run(None, {self.input_name: img})
        predictions = outputs[0][0]
        
        # 获取 Top-5 预测
        top5_indices = np.argsort(predictions)[-5:][::-1]
        
        results = []
        for idx in top5_indices:
            plant_name = self.plant_db[str(idx)]["name"]
            confidence = predictions[idx]
            care_info = self.plant_db[str(idx)].get("care", "")
            results.append({
                "name": plant_name,
                "confidence": float(confidence),
                "care_info": care_info
            })
        
        return results
    
    def display_results(self, results):
        """显示识别结果"""
        if not results:
            print("未能识别植物")
            return
        
        print(f"\n🌿 识别结果:")
        for i, r in enumerate(results):
            print(f"  {i+1}. {r['name']} (置信度: {r['confidence']:.1%})")
        
        best_match = results[0]
        if best_match['confidence'] > 0.5:
            print(f"\n📋 养护建议 ({best_match['name']}):")
            print(f"  {best_match['care_info']}")

# 使用示例
identifier = PlantIdentifier()
results = identifier.capture_and_identify()
identifier.display_results(results)

5.3 扩展：自动浇水系统

可以将植物识别与自动浇水系统结合：

import RPi.GPIO as GPIO
import time

class AutoWatering:
    def __init__(self, pump_pin=18, moisture_pin=4):
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(pump_pin, GPIO.OUT)
        self.pump_pin = pump_pin
        self.moisture_pin = moisture_pin
    
    def read_moisture(self):
        """读取土壤湿度"""
        GPIO.setup(self.moisture_pin, GPIO.IN)
        return GPIO.input(self.moisture_pin)
    
    def water(self, duration=5):
        """浇水"""
        GPIO.output(self.pump_pin, GPIO.HIGH)
        time.sleep(duration)
        GPIO.output(self.pump_pin, GPIO.LOW)
    
    def auto_check(self):
        """自动检查并浇水"""
        moisture = self.read_moisture()
        if moisture == 0:  # 土壤干燥
            print("土壤干燥，正在浇水...")
            self.water(duration=5)
        else:
            print("土壤湿度正常")

六、项目五：智能家居 AI 控制器

6.1 项目概述

最后一个项目是一个基于语音和 AI 的智能家居控制器。通过语音指令控制家中的灯光、空调、窗帘等设备。结合大语言模型，支持自然语言交互。

功能特性：

• 语音控制家电
• 自然语言理解（不需要精确的指令格式）
• 场景模式（如”我要睡觉了”自动关灯、锁门、设闹钟）
• 定时任务
• 设备状态查询

6.2 系统架构

用户语音 → 语音识别 → 大模型理解意图 → 执行控制命令 → 语音反馈
                                           ↓
                                    GPIO 控制 / MQTT / Home Assistant API

6.3 核心代码

#!/usr/bin/env python3
"""智能家居 AI 控制器"""

import json
import requests
import RPi.GPIO as GPIO
from datetime import datetime

class SmartHomeController:
    def __init__(self):
        GPIO.setmode(GPIO.BCM)
        
        # 设备配置
        self.devices = {
            "living_room_light": {"pin": 17, "type": "light", "state": False},
            "bedroom_light": {"pin": 27, "type": "light", "state": False},
            "kitchen_light": {"pin": 22, "type": "light", "state": False},
            "fan": {"pin": 23, "type": "fan", "state": False},
            "curtain": {"pin": 24, "type": "curtain", "state": "closed"},
        }
        
        # 初始化 GPIO
        for device in self.devices.values():
            GPIO.setup(device["pin"], GPIO.OUT)
            GPIO.output(device["pin"], GPIO.LOW)
        
        # 场景定义
        self.scenes = {
            "睡觉模式": {
                "living_room_light": False,
                "bedroom_light": False,
                "kitchen_light": False,
                "fan": True,
                "curtain": "closed"
            },
            "回家模式": {
                "living_room_light": True,
                "bedroom_light": False,
                "kitchen_light": True,
                "fan": False,
                "curtain": "open"
            },
            "离家模式": {
                "living_room_light": False,
                "bedroom_light": False,
                "kitchen_light": False,
                "fan": False,
                "curtain": "closed"
            }
        }
    
    def parse_intent(self, text):
        """使用 LLM 解析用户意图"""
        system_prompt = """你是一个智能家居控制器的意图解析模块。
根据用户的自然语言指令，输出 JSON 格式的控制命令。

可用的设备：living_room_light, bedroom_light, kitchen_light, fan, curtain
可用的场景：睡觉模式, 回家模式, 离家模式

输出格式：
{"action": "control/scene/query", "devices": {"device_name": true/false}, "scene": "场景名"}

只输出 JSON，不要其他内容。"""

        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "qwen2:1.5b",
                "prompt": f"{system_prompt}\n用户指令：{text}",
                "stream": False,
                "options": {"temperature": 0.1}
            }
        )
        
        try:
            result = json.loads(response.json()["response"])
            return result
        except:
            return {"action": "unknown"}
    
    def execute(self, intent):
        """执行控制命令"""
        if intent["action"] == "control":
            for device, state in intent.get("devices", {}).items():
                if device in self.devices:
                    self.set_device(device, state)
            return "好的，已执行"
            
        elif intent["action"] == "scene":
            scene_name = intent.get("scene", "")
            if scene_name in self.scenes:
                self.activate_scene(scene_name)
                return f"已启动{scene_name}"
            return f"未找到场景：{scene_name}"
            
        elif intent["action"] == "query":
            return self.get_status()
        
        return "抱歉，我没有理解你的指令"
    
    def set_device(self, device_name, state):
        """控制单个设备"""
        device = self.devices[device_name]
        if isinstance(state, bool):
            GPIO.output(device["pin"], GPIO.HIGH if state else GPIO.LOW)
            device["state"] = state
            action = "打开" if state else "关闭"
            print(f"  ✓ {action} {device_name}")
    
    def activate_scene(self, scene_name):
        """激活场景"""
        scene = self.scenes[scene_name]
        for device, state in scene.items():
            self.set_device(device, state)
    
    def get_status(self):
        """获取设备状态"""
        status = "当前设备状态：\n"
        for name, device in self.devices.items():
            state = "开启" if device["state"] else "关闭"
            status += f"  - {name}: {state}\n"
        return status

# 使用示例
controller = SmartHomeController()

# 模拟语音输入
user_commands = [
    "把客厅灯打开",
    "我要睡觉了",
    "关掉所有灯，打开风扇",
    "现在家里什么情况"
]

for cmd in user_commands:
    print(f"\n用户: {cmd}")
    intent = controller.parse_intent(cmd)
    response = controller.execute(intent)
    print(f"助手: {response}")

6.4 与 Home Assistant 集成

如果你已经在使用 Home Assistant，可以通过 API 集成：

import requests

class HomeAssistantBridge:
    def __init__(self, ha_url, token):
        self.ha_url = ha_url
        self.headers = {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json"
        }
    
    def call_service(self, domain, service, entity_id):
        """调用 Home Assistant 服务"""
        url = f"{self.ha_url}/api/services/{domain}/{service}"
        data = {"entity_id": entity_id}
        response = requests.post(url, headers=self.headers, json=data)
        return response.status_code == 200
    
    def get_state(self, entity_id):
        """获取设备状态"""
        url = f"{self.ha_url}/api/states/{entity_id}"
        response = requests.get(url, headers=self.headers)
        return response.json()

七、树莓派 AI 项目优化技巧

7.1 系统级优化

# 增加交换空间（推荐 4GB）
sudo dphys-swapfile swapoff
sudo sed -i 's/CONF_SWAPSIZE=.*/CONF_SWAPSIZE=4096/' /etc/dphys-swapfile
sudo dphys-swapfile setup
sudo dphys-swapfile swapon

# 启用 CPU 性能模式
echo "performance" | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

# 关闭不需要的服务
sudo systemctl disable bluetooth
sudo systemctl disable avahi-daemon

7.2 模型优化

• 使用量化模型：INT4/INT8 量化可提升 2-4 倍速度
• 选择合适大小的模型：在树莓派上，1B-3B 的模型是最佳平衡点
• 使用 ONNX Runtime：比原生 PyTorch 推理快 30-50%
• 启用硬件加速：如果使用 Hailo AI HAT，将视觉模型部署到 Hailo 上

7.3 软件架构优化

• 异步处理：使用 asyncio 实现非阻塞的推理和 I/O
• 模型缓存：避免重复加载模型
• 批处理：如果有多个输入，合并为一批处理
• 服务化：将模型作为常驻服务运行，避免每次请求都加载

七点五、树莓派 AI 项目的学习路径规划

我自己是从零开始玩树莓派的，走过不少弯路，浪费了不少时间在错误的方向上。总结下来，我认为最合理的学习路径应该分为四个阶段，循序渐进地提升自己的能力。

第一阶段（1-2周）：基础搭建与环境配置

先买好硬件，装好系统，熟悉 Linux 基本命令。这个阶段不要急着跑 AI 模型，先把树莓派的基础操作搞熟练。我当时花了整整一个周末折腾系统安装和 SSH 连接，后来发现这些基础功非常重要。建议你在这个阶段把 Python 环境、虚拟环境管理、基本的文件操作都练习一遍，后面做项目时会省很多时间。

第二阶段（2-4周）：简单模型体验与原理学习

从最简单的图像分类开始，用 TensorFlow Lite 跑一个 MobileNet 模型，感受 AI 在树莓派上的运行速度和资源消耗。然后尝试用 Ollama 安装一个 1.5B 的小语言模型，体验本地对话的乐趣。我第一次在树莓派上跑通 Qwen 1.5B 的时候，那种兴奋感真的难以形容——这么小的板子居然能理解我说的话并给出有逻辑的回答！

第三阶段（1-2个月）：完整项目独立实践

选择本文介绍的一个项目，从头到尾独立完成。我强烈建议从语音助手开始，因为它涵盖了语音识别、语言模型、语音合成三个核心 AI 模块，做完这个项目你对 AI 系统的整体理解会提升一个层次。做完第一个项目后，再选一个视觉相关的项目，比如安防摄像头或植物识别器，补齐计算机视觉方面的经验。

第四阶段（持续深入）：进阶创新与社区分享

当你能独立完成项目后，就可以开始创新了。把多个 AI 能力组合起来，做出自己独特的应用。比如我把植物识别和自动浇水结合起来，做了一个智能花园管理系统，已经稳定运行了半年，还开源到了 GitHub 上获得了两百多个 Star。学习过程中遇到问题很正常，树莓派的社区非常活跃，几乎任何问题都能在社区论坛找到答案。

七点六、树莓派与云端 AI 的混合架构实践

在实际使用中，我逐渐发现纯本地方案和纯云端方案各有不足。最好的做法是把两者有机结合起来，形成一个混合架构。这也是我目前在自己的智能家居和安防项目中采用的方案，实际效果非常好。

混合架构的三个设计原则：

• 隐私敏感数据本地处理：比如语音指令、摄像头画面、家庭成员的行为数据，这些涉及隐私的信息全部在树莓派上处理，绝不上传云端。这是本地方案最大的优势所在。
• 计算密集型任务交给云端：比如需要大语言模型深度推理的场景，树莓派上的小模型做初步分类和过滤，复杂任务转发给云端 API 处理，这样既快速又智能。
• 本地做推理、云端做训练：日常推理在树莓派上完成，当积累了足够的数据后，把数据脱敏后上传到云端进行模型微调，训练好的模型再部署回树莓派，形成持续优化的闭环。

我实际使用的混合架构案例：

我在家里的树莓派上运行了一个轻量级的意图分类模型（约50MB大小），它可以快速判断用户的语音指令属于哪个类别——灯光控制、温度调节、音乐播放、安防查询等。如果意图明确，直接在本地执行对应的操作。如果遇到复杂的自然语言指令（比如帮我把客厅调成看电影的氛围同时锁上大门），树莓派会把这个请求转发给云端的大模型 API，让大模型解析出具体的设备操作序列，再返回给树莓派逐一执行。

这种混合架构的实际效果是：日常操作中大约百分之九十都在本地完成，响应速度在1秒以内，完全不依赖网络稳定性。只有百分之十的复杂请求才走云端处理，既保证了隐私安全，又保证了智能程度。月均云端 API 调用费用不到5元人民币，性价比极高。对于想要系统学习AI的同学，我推荐看看AI编程工具推荐和AI学习路线图。

如果你是刚入门的朋友，我建议你先从本文介绍的第一个项目——本地语音助手开始做起，这个项目难度适中，成果感很强，非常适合作为入门练习。我当时就是从这个项目入门的，整个过程让我对 AI 的理解有了质的飞跃。

八、常见问题解答（FAQ）

Q：树莓派 5 能运行多大的语言模型？

A：树莓派 5（8GB 版本）可以运行 1B-3B 参数的小型语言模型，如 Phi-3 Mini（3.8B，需要量化）、Qwen 1.5B、Gemma 2B 等。使用 4-bit 量化后，甚至可以勉强运行 7B 模型，但速度较慢（约 2-5 token/s）。

Q：树莓派 AI 项目实用吗？

A：非常实用。虽然单个任务的响应速度不如云端，但树莓派的优势在于：低功耗（5-15W）、7×24小时运行、完全本地化、成本极低。很多智能家居和 IoT 场景非常适合树莓派。

Q：需要购买 Hailo AI HAT 吗？

A：如果你的项目涉及计算机视觉（如目标检测、人脸识别），强烈建议购买。它将视觉 AI 推理速度提升 10 倍以上。如果主要做语言模型相关的项目，则不太需要。

Q：树莓派跑 AI 会不会过热？

A：长时间高负载运行确实会导致过热降频。建议使用带风扇的散热外壳或散热片。主动散热可以将温度控制在 60-70°C，保证性能稳定。

Q：能否同时运行多个 AI 模型？

A：在 8GB 版本的树莓派 5 上，可以同时运行一个小型语言模型和一个轻量级视觉模型。但建议根据实际使用情况调整，避免内存不足。

Q：树莓派 AI 项目的功耗是多少？

A：待机约 3W，轻度 AI 推理约 5-8W，满载约 12-15W。相比桌面 GPU（200-450W），树莓派的功耗极低，适合 7×24 小时运行。

九、总结

树莓派虽然体积小、价格低，但在 AI 领域有着独特的优势。它低功耗、小体积、GPIO 丰富、社区活跃的特点，使其成为 AI IoT 项目和边缘计算的理想平台。

本文介绍的 5 个项目覆盖了语音、视觉、NLP 和 IoT 等多个 AI 方向：

1. 本地语音助手 — 隐私保护的智能语音交互
2. 智能安防摄像头 — AI 驱动的安防监控
3. 文档助手 — 基于 RAG 的知识管理
4. 植物识别器 — 计算机视觉实际应用
5. 智能家居控制器 — 语音+AI 的 IoT 控制

这些项目不仅实用，也是学习 AI 的绝佳实践。通过动手搭建这些项目，你将深入理解 AI 模型在真实环境中的部署和优化。拿起你的树莓派，开始创造吧！