[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-maderix--ANE":3,"tool-maderix--ANE":61},[4,18,26,36,44,53],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":17},4358,"openclaw","openclaw\u002Fopenclaw","OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。\n\n这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。\n\nOpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你",349277,3,"2026-04-06T06:32:30",[13,14,15,16],"Agent","开发框架","图像","数据工具","ready",{"id":19,"name":20,"github_repo":21,"description_zh":22,"stars":23,"difficulty_score":10,"last_commit_at":24,"category_tags":25,"status":17},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,"2026-04-05T11:01:52",[14,15,13],{"id":27,"name":28,"github_repo":29,"description_zh":30,"stars":31,"difficulty_score":32,"last_commit_at":33,"category_tags":34,"status":17},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",149489,2,"2026-04-10T11:32:46",[14,13,35],"语言模型",{"id":37,"name":38,"github_repo":39,"description_zh":40,"stars":41,"difficulty_score":32,"last_commit_at":42,"category_tags":43,"status":17},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",108322,"2026-04-10T11:39:34",[14,15,13],{"id":45,"name":46,"github_repo":47,"description_zh":48,"stars":49,"difficulty_score":32,"last_commit_at":50,"category_tags":51,"status":17},6121,"gemini-cli","google-gemini\u002Fgemini-cli","gemini-cli 是一款由谷歌推出的开源 AI 命令行工具，它将强大的 Gemini 大模型能力直接集成到用户的终端环境中。对于习惯在命令行工作的开发者而言，它提供了一条从输入提示词到获取模型响应的最短路径，无需切换窗口即可享受智能辅助。\n\n这款工具主要解决了开发过程中频繁上下文切换的痛点，让用户能在熟悉的终端界面内直接完成代码理解、生成、调试以及自动化运维任务。无论是查询大型代码库、根据草图生成应用，还是执行复杂的 Git 操作，gemini-cli 都能通过自然语言指令高效处理。\n\n它特别适合广大软件工程师、DevOps 人员及技术研究人员使用。其核心亮点包括支持高达 100 万 token 的超长上下文窗口，具备出色的逻辑推理能力；内置 Google 搜索、文件操作及 Shell 命令执行等实用工具；更独特的是，它支持 MCP（模型上下文协议），允许用户灵活扩展自定义集成，连接如图像生成等外部能力。此外，个人谷歌账号即可享受免费的额度支持，且项目基于 Apache 2.0 协议完全开源，是提升终端工作效率的理想助手。",100752,"2026-04-10T01:20:03",[52,13,15,14],"插件",{"id":54,"name":55,"github_repo":56,"description_zh":57,"stars":58,"difficulty_score":32,"last_commit_at":59,"category_tags":60,"status":17},4721,"markitdown","microsoft\u002Fmarkitdown","MarkItDown 是一款由微软 AutoGen 团队打造的轻量级 Python 工具，专为将各类文件高效转换为 Markdown 格式而设计。它支持 PDF、Word、Excel、PPT、图片（含 OCR）、音频（含语音转录）、HTML 乃至 YouTube 链接等多种格式的解析，能够精准提取文档中的标题、列表、表格和链接等关键结构信息。\n\n在人工智能应用日益普及的今天，大语言模型（LLM）虽擅长处理文本，却难以直接读取复杂的二进制办公文档。MarkItDown 恰好解决了这一痛点，它将非结构化或半结构化的文件转化为模型“原生理解”且 Token 效率极高的 Markdown 格式，成为连接本地文件与 AI 分析 pipeline 的理想桥梁。此外，它还提供了 MCP（模型上下文协议）服务器，可无缝集成到 Claude Desktop 等 LLM 应用中。\n\n这款工具特别适合开发者、数据科学家及 AI 研究人员使用，尤其是那些需要构建文档检索增强生成（RAG）系统、进行批量文本分析或希望让 AI 助手直接“阅读”本地文件的用户。虽然生成的内容也具备一定可读性，但其核心优势在于为机器",93400,"2026-04-06T19:52:38",[52,14],{"id":62,"github_repo":63,"name":64,"description_en":65,"description_zh":66,"ai_summary_zh":67,"readme_en":68,"readme_zh":69,"quickstart_zh":70,"use_case_zh":71,"hero_image_url":72,"owner_login":73,"owner_name":74,"owner_avatar_url":75,"owner_bio":76,"owner_company":77,"owner_location":77,"owner_email":78,"owner_twitter":79,"owner_website":77,"owner_url":80,"languages":81,"stars":101,"forks":102,"last_commit_at":103,"license":104,"difficulty_score":105,"env_os":106,"env_gpu":107,"env_ram":108,"env_deps":109,"category_tags":117,"github_topics":77,"view_count":32,"oss_zip_url":77,"oss_zip_packed_at":77,"status":17,"created_at":119,"updated_at":120,"faqs":121,"releases":150},8188,"maderix\u002FANE","ANE","Training neural networks on Apple Neural Engine via reverse-engineered private APIs","ANE 是一个极具探索精神的研究项目，旨在突破苹果官方限制，直接在 Apple Neural Engine (ANE) 上进行神经网络训练。通常，苹果芯片中的 ANE 仅被允许用于模型推理（如运行 CoreML 模型），而训练任务则需依赖 GPU 或 CPU。ANE 通过逆向工程苹果未公开的内部私有 API（如 `_ANEClient` 和 `_ANECompiler`），成功绕过了这一软件层面的封锁，实现了纯 ANE 算力下的反向传播训练，无需借助 Metal 或 GPU。\n\n该项目主要解决了“硬件具备训练能力但被软件锁死”的问题，证明了在消费级苹果设备上利用 NPU 进行模型训练的可行性。它提供了宝贵的性能基准测试数据，并展示了如何构建自定义计算图以执行完整的向前和向后传播。\n\nANE 非常适合对底层系统架构、编译器技术感兴趣的资深开发者、AI 研究人员以及黑客爱好者使用。对于希望快速落地生产应用的设计师或普通用户而言，目前它尚不具备替代成熟框架（如 MLX 或 PyTorch）的能力，因为其利用率仍有较大优化空间且部分运算需回退至 CPU。作为一个开源的实验性代码库，ANE 的核","ANE 是一个极具探索精神的研究项目，旨在突破苹果官方限制，直接在 Apple Neural Engine (ANE) 上进行神经网络训练。通常，苹果芯片中的 ANE 仅被允许用于模型推理（如运行 CoreML 模型），而训练任务则需依赖 GPU 或 CPU。ANE 通过逆向工程苹果未公开的内部私有 API（如 `_ANEClient` 和 `_ANECompiler`），成功绕过了这一软件层面的封锁，实现了纯 ANE 算力下的反向传播训练，无需借助 Metal 或 GPU。\n\n该项目主要解决了“硬件具备训练能力但被软件锁死”的问题，证明了在消费级苹果设备上利用 NPU 进行模型训练的可行性。它提供了宝贵的性能基准测试数据，并展示了如何构建自定义计算图以执行完整的向前和向后传播。\n\nANE 非常适合对底层系统架构、编译器技术感兴趣的资深开发者、AI 研究人员以及黑客爱好者使用。对于希望快速落地生产应用的设计师或普通用户而言，目前它尚不具备替代成熟框架（如 MLX 或 PyTorch）的能力，因为其利用率仍有较大优化空间且部分运算需回退至 CPU。作为一个开源的实验性代码库，ANE 的核心价值在于为边缘 AI 优化提供了全新的研究视角和技术参考，鼓励社区在此基础上构建更强大的工具。","# ANE Training — Backpropagation on Apple Neural Engine\r\n\r\nTraining neural networks directly on Apple's Neural Engine (ANE) via reverse-engineered private APIs. No CoreML training APIs, no Metal, no GPU — pure ANE compute.\r\n\r\n## Project Scope & Intent\r\n\r\nI'm genuinely grateful for all the attention this project has received — I never expected a weekend research hack to blow up like this. Thank you to everyone who starred, forked, ran benchmarks on their own hardware, and shared the work. It means a lot.\r\n\r\nThat said, I want to set clear expectations about what this project is and isn't.\r\n\r\nThis is a **research project**, not a production framework.\r\n\r\nThe goal was to demonstrate that **training on the Apple Neural Engine — and potentially other NPUs — is possible**, and that the barrier has always been software support, not hardware capability. The ANE is a remarkably capable piece of silicon that Apple restricts to inference-only use through CoreML. This project bypasses that restriction using reverse-engineered private APIs to show what's possible when you give the hardware a chance.\r\n\r\n### What This Project Is\r\n\r\n- A proof of concept for ANE training via `_ANEClient` and `_ANECompiler` private APIs\r\n- A set of benchmarks documenting real ANE performance characteristics (throughput, power, SRAM behavior)\r\n- A reference for anyone exploring direct ANE access outside CoreML\r\n- Research code that I update when I find something interesting\r\n\r\n### What This Project Is Not\r\n\r\n- A maintained framework or library\r\n- A replacement for CoreML, MLX, llama.cpp, or any production inference stack\r\n- A path to training large models on consumer hardware (yet)\r\n\r\n### On The Hype\r\n\r\nSome coverage of this project has overstated its implications. To be clear:\r\n\r\n- Training works, but utilization is low (~5-9% of peak) with significant engineering challenges remaining\r\n- Many element-wise operations still fall back to CPU\r\n- This does **not** replace GPU training for anything beyond small research models today\r\n\r\nThe honest results — including all limitations — are documented in the accompanying articles:\r\n- [Part 1: Reverse Engineering](https:\u002F\u002Fmaderix.substack.com\u002Fp\u002Finside-the-m4-apple-neural-engine)\r\n- [Part 2: Benchmarks](https:\u002F\u002Fmaderix.substack.com\u002Fp\u002Finside-the-m4-apple-neural-engine-615)\r\n- [Part 3: Training](https:\u002F\u002Fmaderix.substack.com\u002Fp\u002Finside-the-m4-apple-neural-engine-c8b)\r\n\r\n### On Maintenance\r\n\r\nI don't intend to grow this into a large community project. My focus is on original research (compiler infrastructure for edge AI optimization), and maintaining an open-source framework takes time away from that.\r\n\r\nThat said:\r\n- I'll keep pushing updates when I discover something interesting\r\n- Bug fixes and benchmark contributions (especially on hardware I don't own) are welcome\r\n- Feature requests will likely go unaddressed — but feel free to fork\r\n- PRs will be merged at a relatively slow pace, otherwise I become the bottleneck for community growth around this tech\r\n\r\n### Fork it, build on it\r\n\r\nThis is MIT licensed for a reason. Everyone now has access to AI-assisted development tools that can adapt and extend code in hours. If this project is useful to you — take it, modify it, build something better. If you do something cool with it, I'd love to hear about it.If in future, community decides to maintain one source of truth repo, I'm in full support of that.\r\n\r\n---\r\n\r\n## What This Is\r\n\r\nA from-scratch implementation of transformer training (forward + backward pass) running on the ANE in Apple Silicon. The ANE is a 15.8 TFLOPS FP16 (M4) inference accelerator that Apple does not expose for training. This project reverse-engineers the `_ANEClient` \u002F `_ANECompiler` private APIs and the MIL (Model Intermediate Language) format to run custom compute graphs — including backpropagation — directly on ANE hardware.\r\n\r\n**Current results:**\r\n\r\n| Model | Params | ms\u002Fstep | Pipeline |\r\n|-------|--------|---------|----------|\r\n| Stories110M (12L, dim=768, MHA 12\u002F12) | 109M | **91 ms** | Dynamic (no recompile) |\r\n| Qwen3-0.6B (28L, dim=1024, GQA 16\u002F8) | 596M | **412 ms** | Dynamic (no recompile) |\r\n\r\n- All forward and backward dx passes on ANE, dW gradients on CPU (Accelerate cblas)\r\n- Adam optimizer, gradient accumulation, checkpoint\u002Fresume via exec() restart\r\n- GQA (Grouped-Query Attention) support with per-head tiling\u002Freduction\r\n- GPU↔ANE zero-copy pipeline via shared IOSurface (GPU prefill → ANE decode)\r\n\r\n**INT8 W8A8 quantization — 1.88x throughput (M4, H16G):**\r\n\r\n| Config | FP16 | INT8 W8A8 | Speedup |\r\n|--------|------|-----------|---------|\r\n| 128x conv 512ch 64x64 | 18.6 TOPS, 14.8ms | 35.1 TOPS, 7.8ms | **1.88x** |\r\n| 64x conv 512ch 64x64 | 18.4 TOPS, 7.5ms | 34.1 TOPS, 4.0ms | **1.85x** |\r\n\r\nINT8 activations halve L2 SRAM bandwidth between tiles via MIL `quantize`\u002F`dequantize` ops. Weights use `constexpr_affine_dequantize` (int8 stored, fp16 at compile time).\r\n\r\n## Architecture\r\n\r\nThe dynamic pipeline uses shared ANE kernels with weights packed into spatial dimensions (no recompilation when weights change):\r\n\r\n**MHA models (Stories110M) — 6 kernels per layer:**\r\n\r\n| Kernel | Function |\r\n|--------|----------|\r\n| `sdpaFwd` | QKV projection + SDPA + output projection |\r\n| `ffnFused` | SwiGLU FFN (W1, W3, SiLU, W2) |\r\n| `ffnBwdW2t` \u002F `ffnBwdW13t` | FFN backward (split for memory) |\r\n| `sdpaBwd1` \u002F `sdpaBwd2` | SDPA backward |\r\n\r\n**GQA models (Qwen3-0.6B) — 10 kernels per layer:**\r\nAdds separate `woFwd`, `qBwd`, `kvBwd` kernels for grouped-query attention (Q_DIM ≠ DIM).\r\n\r\nCPU handles: RMSNorm forward\u002Fbackward, residual connections (DeepNet α scaling), loss computation, dW gradient accumulation (cblas_sgemm), Adam optimizer updates.\r\n\r\nKey optimizations:\r\n- **Channel-first CPU layout** — matches ANE IOSurface `[1,C,1,S]` format, eliminates all transpose overhead\r\n- **vDSP vectorized RMSNorm** — 10x faster than naive (6.7ms → 0.7ms)\r\n- **GCD async cblas overlap** — dW gradient sgemms run in parallel with ANE evals on a serial dispatch queue\r\n- **Deferred cblas wait** — wait pushed into next step's forward pass for maximum overlap\r\n- **ANE RMSNorm fusion** — RMSNorm folded into forward kernels as MIL ops (reduce_sum + pow + mul)\r\n- **Wo^T fusion** — output projection backward merged into SDPA backward kernel\r\n- **Forward taps** — Q, K, V, attention scores, hidden states exposed via concat outputs, avoiding CPU recompute\r\n- **exec() restart** — bypasses ~119 ANE compile limit per process\r\n\r\n## File Structure\r\n\r\n```\r\n├── api_exploration.m           # Initial ANE API discovery\r\n├── inmem_basic.m               # In-memory MIL compilation proof-of-concept\r\n├── inmem_bench.m               # ANE dispatch latency benchmarks\r\n├── inmem_peak.m                # Peak TFLOPS measurement (2048x2048 matmul)\r\n├── ane_int8_bench.m            # INT8 W8A8 vs FP16 throughput benchmark\r\n├── sram_bench.m                # ANE SRAM bandwidth probing\r\n├── sram_probe.m                # SRAM size\u002Flayout exploration\r\n├── gpu_ane_share.m             # GPU↔ANE zero-copy IOSurface demo\r\n├── gpu_prefill_ane_decode.m    # GPU prefill → ANE decode pipeline\r\n├── bridge\u002F\r\n│   ├── ane_bridge.h            # C-callable ANE API (compile, eval, I\u002FO)\r\n│   ├── ane_bridge.m            # Bridge implementation (int8 + fp16 weight blobs)\r\n│   └── Makefile\r\n└── training\u002F\r\n    ├── ane_runtime.h           # ANE private API wrapper (compile, eval, IOSurface)\r\n    ├── ane_classifier.h        # Classifier fwd (32K conv), softmax, rmsnorm on ANE\r\n    ├── train_large.m           # Static pipeline (weights as constants, recompiles)\r\n    ├── training_dynamic\u002F\r\n    │   ├── train.m             # Dynamic training loop (model-agnostic)\r\n    │   ├── config.h            # Derived sizes, structs, alloc helpers\r\n    │   ├── mil_dynamic.h       # MIL generators for dynamic weight kernels (GQA-aware)\r\n    │   ├── io.h                # IOSurface I\u002FO, weight staging, GQA tile\u002Freduce\r\n    │   ├── models\u002F\r\n    │   │   ├── stories110m.h   # Stories110M config (12L, MHA)\r\n    │   │   └── qwen3_06b.h    # Qwen3-0.6B config (28L, GQA)\r\n    │   └── Makefile\r\n    ├── dashboard.py            # Live training dashboard (blessed TUI)\r\n    └── Makefile\r\n```\r\n\r\n## Training Data\r\n\r\nTraining requires pretokenized TinyStories data. To download:\r\n```bash\r\ncd training && bash download_data.sh\r\n```\r\nSee [training\u002FREADME.md](training\u002FREADME.md) for detailed training instructions.\r\n\r\n## Building\r\n\r\nRequires macOS 15+ on Apple Silicon (tested on M4).\r\n\r\n```bash\r\n# Dynamic pipeline (recommended) — model selected at build time\r\ncd training\u002Ftraining_dynamic\r\nmake MODEL=stories110m    # Stories110M (12L, MHA, 109M params)\r\nmake MODEL=qwen3_06b      # Qwen3-0.6B (28L, GQA, 596M params)\r\n.\u002Ftrain --scratch          # train from random init\r\n.\u002Ftrain --resume           # resume from checkpoint\r\n\r\n# Static pipeline (legacy — recompiles weights each step)\r\ncd training && make train_large\r\n.\u002Ftrain_large ane_stories110M_ckpt.bin 256 100 1e-4\r\n\r\n# INT8 benchmark\r\nxcrun clang -O2 -fobjc-arc -framework Foundation -framework IOSurface -ldl \\\r\n  -o ane_int8_bench ane_int8_bench.m\r\n.\u002Fane_int8_bench\r\n\r\n# Bridge library (C-callable ANE API)\r\ncd bridge && make\r\n```\r\n\r\nNo external dependencies. Uses only system frameworks + private ANE APIs resolved at runtime via `objc_msgSend`.\r\n\r\n## How It Works\r\n\r\n1. **MIL generation** — Objective-C code constructs MIL program text at runtime, specifying convolutions (for linear layers), matmul (for attention), softmax, element-wise ops\r\n2. **In-memory compilation** — `_ANEInMemoryModelDescriptor` compiles MIL text + weight blobs directly to ANE programs, no disk mlmodelc needed\r\n3. **IOSurface I\u002FO** — Input\u002Foutput tensors passed via IOSurface shared memory in `[1, channels, 1, spatial]` format (fp16 or fp32; fp16 direct I\u002FO is ~37% faster)\r\n4. **Dynamic weights** — Activations and weights packed into a single spatial input dimension, sliced apart inside the MIL kernel. Weights change without recompilation.\r\n5. **Gradient flow** — Forward taps expose intermediates needed for backward; backward kernels compute dx (input gradients) on ANE; dW (weight gradients) computed on CPU via cblas\r\n6. **INT8 quantization** — `constexpr_affine_dequantize` for int8 weights, `quantize`\u002F`dequantize` between layers for int8 activation caching in L2 SRAM (1.88x throughput)\r\n\r\n## Limitations\r\n\r\n- **SDPA causal masking** — ANE hardware ignores `attn_mask` in SDPA ops; causal attention is decomposed into separate Q@K^T (ANE) → mask+softmax (CPU) → scores@V (ANE)\r\n- **~119 compile limit** — ANE compiler leaks resources; worked around via `exec()` restart with checkpoint\r\n- **FP16 gradient underflow** — backward matmuls underflow in fp16; fixed with global loss scaling (`256 * NLAYERS`)\r\n- **Single-input constraint** — multi-input ANE requests cause 0x1d error; inputs packed into spatial dimension instead\r\n\r\n## Performance\r\n\r\n**Training throughput (M4):**\r\n\r\n| Model | Params | ms\u002Fstep | Layers | Kernels\u002Flayer |\r\n|-------|--------|---------|--------|---------------|\r\n| Stories110M | 109M | 91 ms | 12 | 6 (MHA) |\r\n| Qwen3-0.6B | 596M | 412 ms | 28 | 10 (GQA) |\r\n\r\n**ANE peak throughput (M4, H16G):**\r\n\r\n| Precision | Peak TOPS | Config |\r\n|-----------|-----------|--------|\r\n| FP16 | 18.6 | 128x conv 512ch 64x64 |\r\n| INT8 W8A8 | 35.1 | 128x conv 512ch 64x64 |\r\n\r\n**GPU↔ANE inference pipeline (M4, seq=256):**\r\n\r\n| Model | GPU Prefill | ANE Decode | Total |\r\n|-------|------------|------------|-------|\r\n| Stories110M | 6.7ms | 1.9ms | 8.8ms |\r\n| Qwen3-0.6B | 9.7ms | 2.3ms | 12.0ms |\r\n\r\n## Disclaimer\r\n\r\nThis project uses Apple's private, undocumented APIs (`_ANEClient`, `_ANECompiler`, `_ANEInMemoryModelDescriptor`). These APIs are not covered by any public stability guarantee and may change or break with any macOS update. This is independent research into Apple Neural Engine architecture, using APIs discovered through runtime introspection for research and educational purposes under fair use and interoperability provisions (see *Sega v. Accolade*, 1992; DMCA §1201(f)). No Apple proprietary code or binaries are included in this repository. This project is not affiliated with or endorsed by Apple Inc. Use at your own risk.\r\n\r\n## License\r\n\r\nMIT — see [LICENSE](LICENSE)\r\n\r\n---\r\n\r\n*Built by a human + Claude, one weekend at a time.*\r\n\r\n\r\n","# ANE 训练 — 在 Apple Neural Engine 上进行反向传播\n\n通过逆向工程的私有 API，直接在 Apple 的 Neural Engine (ANE) 上训练神经网络。不使用 CoreML 训练 API，不使用 Metal，也不依赖 GPU——纯粹的 ANE 计算。\n\n## 项目范围与意图\n\n我由衷感谢大家对这个项目的关注——我从未想过一个周末的研究性尝试会如此火爆。感谢所有点赞、叉仓、在自己的硬件上运行基准测试并分享成果的人，这对我来说意义重大。\n\n不过，我想明确一下这个项目的定位和边界。\n\n这是一个**研究项目**，而非生产级框架。\n\n我们的目标是证明**在 Apple Neural Engine——以及潜在的其他 NPU 上进行训练是可行的**，并且一直以来的瓶颈在于软件支持，而非硬件能力。ANE 是一块功能强大的芯片，但 Apple 通过 CoreML 将其限制为仅用于推理。本项目通过逆向工程的私有 API 绕过了这一限制，展示了只要给予硬件机会，就能实现怎样的可能性。\n\n### 本项目是什么\n\n- 基于 `_ANEClient` 和 `_ANECompiler` 私有 API 的 ANE 训练概念验证\n- 一组记录真实 ANE 性能特征（吞吐量、功耗、SRAM 行为）的基准测试\n- 为任何探索 CoreML 之外 ANE 直接访问方式的人提供的参考\n- 我会在发现有趣内容时更新的研究代码\n\n### 本项目不是什么\n\n- 不是一个维护良好的框架或库\n- 不是 CoreML、MLX、llama.cpp 或任何生产级推理栈的替代品\n- 至少目前还不是在消费级硬件上训练大型模型的途径\n\n### 关于炒作\n\n一些关于该项目的报道夸大了其影响。澄清如下：\n\n- 训练确实可以运行，但利用率较低（约峰值的 5–9%），且仍存在显著的工程挑战\n- 许多逐元素操作仍然回退到 CPU\n- 这**并不**意味着它可以取代 GPU 训练，至少在当前阶段还无法用于任何超出小型研究模型的任务\n\n诚实的结果——包括所有局限性——都记录在配套的文章中：\n- [第 1 部分：逆向工程](https:\u002F\u002Fmaderix.substack.com\u002Fp\u002Finside-the-m4-apple-neural-engine)\n- [第 2 部分：基准测试](https:\u002F\u002Fmaderix.substack.com\u002Fp\u002Finside-the-m4-apple-neural-engine-615)\n- [第 3 部分：训练](https:\u002F\u002Fmaderix.substack.com\u002Fp\u002Finside-the-m4-apple-neural-engine-c8b)\n\n### 关于维护\n\n我不打算将这个项目发展成一个大型社区项目。我的重心在于原创研究（边缘 AI 优化的编译器基础设施），而维护一个开源框架会占用我在这方面的精力。\n\n尽管如此：\n- 只要我发现有趣的内容，就会继续推送更新\n- 欢迎提交 bug 修复和基准测试贡献（尤其是针对我没有的硬件）\n- 功能请求可能不会被采纳——但欢迎大家 fork\n- PR 的合并速度可能会比较慢，否则我会成为推动该技术社区发展的瓶颈。\n\n### Fork 它，基于它构建\n\n之所以采用 MIT 许可证，是有原因的。如今，每个人都可以使用 AI 辅助开发工具，在几小时内就完成代码的适配和扩展。如果这个项目对你有用，那就拿走它，修改它，构建出更好的东西。如果你用它做出了什么酷炫的东西，我很乐意听听你的故事。如果未来社区决定维护一个事实来源仓库，我也完全支持。\n\n---\n\n## 这是什么\n\n一个从头开始实现的 Transformer 训练框架（前向 + 反向传播），运行在 Apple Silicon 的 ANE 上。ANE 是一款 15.8 TFLOPS FP16（M4）的推理加速器，但 Apple 并未将其开放用于训练。本项目通过逆向工程 `_ANEClient` \u002F `_ANECompiler` 私有 API 以及 MIL（Model Intermediate Language）格式，实现了在 ANE 硬件上直接运行自定义计算图——包括反向传播。\n\n**当前结果：**\n\n| 模型 | 参数量 | ms\u002F步 | 流水线 |\n|------|--------|--------|--------|\n| Stories110M（12 层，dim=768，MHA 12\u002F12） | 1.09 亿 | **91 ms** | 动态（无需重新编译） |\n| Qwen3-0.6B（28 层，dim=1024，GQA 16\u002F8） | 5.96 亿 | **412 ms** | 动态（无需重新编译） |\n\n- 所有前向和反向 dx 传递都在 ANE 上执行，dW 梯度则在 CPU 上计算（Accelerate cblas）\n- 使用 Adam 优化器，支持梯度累积，并通过 exec() 重启实现检查点和恢复\n- 支持 GQA（分组查询注意力），并采用每头平铺与归约策略\n- 通过共享 IOSurface 实现 GPU↔ANE 零拷贝流水线（GPU 预填充 → ANE 解码）\n\n**INT8 W8A8 量化——M4, H16G 下吞吐量提升 1.88 倍：**\n\n| 配置 | FP16 | INT8 W8A8 | 加速比 |\n|------|------|-----------|--------|\n| 128x 卷积 512 通道 64x64 | 18.6 TOPS，14.8ms | 35.1 TOPS，7.8ms | **1.88x** |\n| 64x 卷积 512 通道 64x64 | 18.4 TOPS，7.5ms | 34.1 TOPS，4.0ms | **1.85x** |\n\nINT8 激活值通过 MIL `quantize`\u002F`dequantize` 操作，将 tile 之间的 L2 SRAM 带宽减半。权重使用 `constexpr_affine_dequantize`（以 int8 存储，编译时转换为 fp16）。\n\n## 架构\n\n动态流水线使用共享 ANE 内核，权重打包进空间维度（权重变化时无需重新编译）：\n\n**MHA 模型（Stories110M）——每层 6 个内核：**\n\n| 内核 | 功能 |\n|------|------|\n| `sdpaFwd` | QKV 投影 + SDPA + 输出投影 |\n| `ffnFused` | SwiGLU FFN（W1、W3、SiLU、W2） |\n| `ffnBwdW2t` \u002F `ffnBwdW13t` | FFN 反向传播（为节省内存拆分为两部分） |\n| `sdpaBwd1` \u002F `sdpaBwd2` | SDPA 反向传播 |\n\n**GQA 模型（Qwen3-0.6B）——每层 10 个内核：**\n新增独立的 `woFwd`、`qBwd` 和 `kvBwd` 内核，用于处理分组查询注意力（Q_DIM ≠ DIM）。\n\nCPU 负责：RMSNorm 的前向和反向计算、残差连接（DeepNet α 缩放）、损失计算、dW 梯度累积（cblas_sgemm）以及 Adam 优化器的更新。\n\n关键优化：\n- **通道优先的 CPU 布局**——与 ANE IOSurface `[1,C,1,S]` 格式一致，消除所有转置开销\n- **vDSP 向量化 RMSNorm**——比原生实现快 10 倍（6.7ms → 0.7ms）\n- **GCD 异步 cblas 重叠**——dW 梯度 sgemms 在串行调度队列上与 ANE 评估并行执行\n- **延迟 cblas 等待**——将等待推迟到下一步的前向传播中，以实现最大重叠\n- **ANE RMSNorm 融合**——将 RMSNorm 作为 MIL 操作融合进前向内核（reduce_sum + pow + mul）\n- **Wo^T 融合**——输出投影的反向传播与 SDPA 反向传播内核合并\n- **前向输出引出**——Q、K、V、注意力分数和隐藏状态通过拼接输出暴露出来，避免 CPU 重复计算\n- **exec() 重启**——绕过每个进程约 119 次的 ANE 编译次数限制\n\n## 文件结构\n\n``` \n├── api_exploration.m           # 初始 ANE API 发现\n├── inmem_basic.m               # 内存中 MIL 编译的概念验证\n├── inmem_bench.m               # ANE 分发延迟基准测试\n├── inmem_peak.m                # 峰值 TFLOPS 测量（2048×2048 矩阵乘法）\n├── ane_int8_bench.m            # INT8 W8A8 与 FP16 吞吐量对比基准测试\n├── sram_bench.m                # ANE SRAM 带宽探测\n├── sram_probe.m                # SRAM 大小\u002F布局探索\n├── gpu_ane_share.m             # GPU↔ANE 零拷贝 IOSurface 示例\n├── gpu_prefill_ane_decode.m    # GPU 预填充 → ANE 解码流水线\n├── bridge\u002F\n│   ├── ane_bridge.h            # 可由 C 调用的 ANE API（编译、评估、I\u002FO）\n│   ├── ane_bridge.m            # 桥接实现（int8 + fp16 权重块）\n│   └── Makefile\n└── training\u002F\n    ├── ane_runtime.h           # ANE 私有 API 封装（编译、评估、IOSurface）\n    ├── ane_classifier.h        # 分类器前向传播（32K 卷积）、softmax、rmsnorm 在 ANE 上执行\n    ├── train_large.m           # 静态流水线（权重作为常量，需重新编译）\n    ├── training_dynamic\u002F\n    │   ├── train.m             # 动态训练循环（模型无关）\n    │   ├── config.h            # 衍生尺寸、结构体、内存分配辅助函数\n    │   ├── mil_dynamic.h       # 用于动态权重核的 MIL 生成器（支持 GQA）\n    │   ├── io.h                # IOSurface I\u002FO、权重暂存、GQA 片段化\u002F归约\n    │   ├── models\u002F\n    │   │   ├── stories110m.h   # Stories110M 配置（12 层，MHA）\n    │   │   └── qwen3_06b.h    # Qwen3-0.6B 配置（28 层，GQA）\n    │   └── Makefile\n    ├── dashboard.py            # 实时训练仪表板（受认可的 TUI）\n    └── Makefile\n```\n\n## 训练数据\n\n训练需要预分词的 TinyStories 数据。下载方法如下：\n```bash\ncd training && bash download_data.sh\n```\n详细训练说明请参阅 [training\u002FREADME.md](training\u002FREADME.md)。\n\n## 构建\n\n需要 macOS 15+ 且搭载 Apple Silicon 芯片（已在 M4 上测试）。\n\n```bash\n# 动态流水线（推荐）—— 模型在构建时选定\ncd training\u002Ftraining_dynamic\nmake MODEL=stories110m    # Stories110M（12 层，MHA，1.09 亿参数）\nmake MODEL=qwen3_06b      # Qwen3-0.6B（28 层，GQA，5.96 亿参数）\n.\u002Ftrain --scratch          # 从随机初始化开始训练\n.\u002Ftrain --resume           # 从检查点恢复训练\n\n# 静态流水线（遗留方案——每步都会重新编译权重）\ncd training && make train_large\n.\u002Ftrain_large ane_stories110M_ckpt.bin 256 100 1e-4\n\n# INT8 基准测试\nxcrun clang -O2 -fobjc-arc -framework Foundation -framework IOSurface -ldl \\\n  -o ane_int8_bench ane_int8_bench.m\n.\u002Fane_int8_bench\n\n# 桥接库（可由 C 调用的 ANE API）\ncd bridge && make\n```\n\n无外部依赖。仅使用系统框架及通过 `objc_msgSend` 在运行时解析的 ANE 私有 API。\n\n## 工作原理\n\n1. **MIL 生成** — Objective-C 代码在运行时构造 MIL 程序文本，指定卷积（用于线性层）、矩阵乘法（用于注意力机制）、softmax 和逐元素操作。\n2. **内存中编译** — `_ANEInMemoryModelDescriptor` 直接将 MIL 文本和权重块编译为 ANE 程序，无需磁盘上的 mlmodelc 文件。\n3. **IOSurface I\u002FO** — 输入输出张量通过 IOSurface 共享内存以 `[1, 通道数, 1, 空间维度]` 格式传递（fp16 或 fp32；fp16 直接 I\u002FO 速度提升约 37%）。\n4. **动态权重** — 激活值和权重打包到单个空间输入维度中，在 MIL 内核内部再进行切分。权重可在不重新编译的情况下变化。\n5. **梯度流** — 前向传播会暴露反向传播所需的中间结果；反向传播内核在 ANE 上计算输入梯度 dx；权重梯度 dW 则由 CPU 通过 cblas 计算。\n6. **INT8 量化** — 使用 `constexpr_affine_dequantize` 处理 int8 权重，并在各层之间进行量化\u002F反量化，以便在 L2 SRAM 中缓存 int8 激活值（吞吐量提升 1.88 倍）。\n\n## 限制\n\n- **SDPA 因果掩码** — ANE 硬件会忽略 SDPA 操作中的 `attn_mask`；因果注意力被分解为单独的 Q@K^T（ANE）→ 掩码+softmax（CPU）→ 分数@V（ANE）。\n- **约 119 次编译限制** — ANE 编译器存在资源泄漏问题，可通过重启进程并加载检查点来规避。\n- **FP16 梯度下溢** — 反向传播中的矩阵乘法在 fp16 下会发生下溢，已通过全局损失缩放（`256 * NLAYERS`）解决。\n- **单输入约束** — ANE 请求多输入会导致 0x1d 错误；应将输入打包到空间维度中。\n\n## 性能\n\n**训练吞吐量（M4）：**\n\n| 模型         | 参数     | 每步时间 (ms) | 层数 | 每层内核数 |\n|--------------|----------|---------------|------|------------|\n| Stories110M  | 1.09 亿 | 91            | 12   | 6（MHA）   |\n| Qwen3-0.6B   | 5.96 亿 | 412           | 28   | 10（GQA）  |\n\n**ANE 峰值吞吐量（M4，H16G）：**\n\n| 精度   | 峰值 TOPS | 配置                     |\n|--------|-----------|--------------------------|\n| FP16   | 18.6      | 128 个卷积，512 通道，64×64 |\n| INT8 W8A8 | 35.1      | 128 个卷积，512 通道，64×64 |\n\n**GPU↔ANE 推理流水线（M4，序列长度=256）：**\n\n| 模型         | GPU 预填充 | ANE 解码 | 总计 |\n|--------------|------------|----------|------|\n| Stories110M  | 6.7 ms     | 1.9 ms   | 8.8 ms |\n| Qwen3-0.6B   | 9.7 ms     | 2.3 ms   | 12.0 ms |\n\n## 免责声明\n\n本项目使用了 Apple 的私有未文档化 API（`_ANEClient`、`_ANECompiler`、`_ANEInMemoryModelDescriptor`）。这些 API 不受任何公开稳定性保证，可能随 macOS 更新而更改或失效。本项目是对 Apple Neural Engine 架构的独立研究，所使用的 API 是通过运行时内省发现的，仅用于研究和教育目的，符合合理使用和互操作性条款（参见 *Sega v. Accolade*, 1992；DMCA §1201(f)）。本仓库不包含任何 Apple 专有代码或二进制文件。本项目与 Apple Inc. 无任何关联，亦未获其认可。请用户自行承担风险。\n\n## 许可证\n\nMIT — 详见 [LICENSE](LICENSE)\n\n---\n\n*由人类与 Claude 共同打造，利用每个周末的时间完成。*","# ANE 快速上手指南\n\nANE 是一个研究性项目，旨在通过逆向工程 Apple 的私有 API，直接在 Apple Neural Engine (ANE) 上运行神经网络的反向传播（训练）。本项目不依赖 CoreML 训练接口或 Metal，纯粹利用 ANE 算力。\n\n> **注意**：这是一个概念验证（PoC）研究项目，并非生产级框架。目前主要用于探索硬件潜力和小规模模型的研究训练。\n\n## 环境准备\n\n- **操作系统**：macOS 15+ (Sequoia)\n- **硬件要求**：Apple Silicon 芯片（已在 M4 上测试，其他 M 系列芯片可能兼容但性能不同）\n- **开发工具**：Xcode Command Line Tools (包含 `clang`, `make` 等)\n- **依赖项**：无外部依赖，仅使用系统框架和运行时解析的私有 ANE API\n\n确保你的终端已安装必要的构建工具：\n```bash\nxcode-select --install\n```\n\n## 安装步骤\n\n克隆仓库并进入训练目录：\n\n```bash\ngit clone \u003Crepository-url>\ncd ANE\u002Ftraining\u002Ftraining_dynamic\n```\n\n根据你想训练的模型选择编译目标（二选一）：\n\n**选项 1：编译 Stories110M 模型 (1.09 亿参数，MHA 架构)**\n```bash\nmake MODEL=stories110m\n```\n\n**选项 2：编译 Qwen3-0.6B 模型 (5.96 亿参数，GQA 架构)**\n```bash\nmake MODEL=qwen3_06b\n```\n\n**下载训练数据**\n项目需要预分词的 TinyStories 数据集。运行以下脚本自动下载：\n```bash\nbash download_data.sh\n```\n\n## 基本使用\n\n编译完成后，可直接运行训练脚本。\n\n**从头开始训练（随机初始化权重）**\n```bash\n.\u002Ftrain --scratch\n```\n\n**从检查点恢复训练**\n如果之前中断过，可以使用以下命令恢复：\n```bash\n.\u002Ftrain --resume\n```\n\n**查看实时训练仪表盘**\n项目包含一个基于终端的实时监控界面（需 Python 环境）：\n```bash\npython dashboard.py\n```\n\n### 进阶：INT8 量化基准测试\n如果你想测试 ANE 的 INT8 W8A8 量化吞吐量，可在根目录编译并运行基准测试：\n```bash\ncd ..\u002F..\nxcrun clang -O2 -fobjc-arc -framework Foundation -framework IOSurface -ldl \\\n  -o ane_int8_bench ane_int8_bench.m\n.\u002Fane_int8_bench\n```\n\n### 核心机制说明\n- **动态权重**：权重被打包到空间维度中，无需在每次权重更新时重新编译模型。\n- **混合计算**：前向传播和输入梯度 (dx) 在 ANE 上计算；权重梯度 (dW) 和优化器步骤在 CPU (Accelerate\u002Fcblas) 上计算以规避当前限制。\n- **显存优化**：利用 IOSurface 实现 GPU 与 ANE 之间的零拷贝数据共享。","一位边缘 AI 研究员试图在 MacBook Pro 上直接训练小型 Transformer 模型，以验证苹果神经网络引擎（ANE）在反向传播中的潜力，而无需依赖外部 GPU 集群。\n\n### 没有 ANE 时\n- **硬件闲置浪费**：尽管 M4 芯片内置了强大的 15.8 TFLOPS NPU，但受限于 CoreML 仅支持推理，训练任务只能强制调用 GPU 或 CPU，导致专用 AI 算力完全闲置。\n- **能耗与发热过高**：使用 Metal 进行 GPU 训练时，笔记本电脑风扇狂转、机身发烫，电池续航急剧下降，难以在移动办公场景下长时间运行实验。\n- **技术验证受阻**：由于缺乏直接访问 NPU 训练能力的途径，开发者无法低成本验证“端侧全链路训练”的可行性，必须等待官方开放接口或购买昂贵设备。\n- **依赖重型框架**：为了绕过限制，往往需要配置复杂的 CUDA 环境或云端资源，增加了本地轻量级原型开发的门槛和延迟。\n\n### 使用 ANE 后\n- **激活沉睡算力**：ANE 通过逆向工程私有 API（`_ANEClient`），成功将反向传播计算图直接映射到 NPU 硬件，让原本仅用于推理的硅片开始承担训练任务。\n- **能效显著提升**：利用 NPU 专用的低功耗架构，训练过程中的功耗大幅降低，设备保持冷静且安静，实现了真正的“静音训练”体验。\n- **打破软件壁垒**：证明了阻碍 NPU 训练的并非硬件能力不足而是软件封锁，为探索非 GPU 架构的边缘模型训练提供了宝贵的代码参考和基准数据。\n- **纯本地化研发**：无需安装 CUDA 或连接云服务器，仅凭原生 MIL 格式和自定义计算图即可在 macOS 上完成从正向到反向的完整训练循环。\n\nANE 的核心价值在于它是一把钥匙，打破了苹果对 NPU 训练功能的软件封锁，让开发者能在低功耗本地设备上首次实证端侧模型训练的可行性。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fmaderix_ANE_5f3b6ad4.png","maderix","Manjeet Singh","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Fmaderix_310397ff.jpg","Generative art and deep learning",null,"maderix@gmail.com","originalmaderix","https:\u002F\u002Fgithub.com\u002Fmaderix",[82,86,90,94,98],{"name":83,"color":84,"percentage":85},"Objective-C","#438eff",72.4,{"name":87,"color":88,"percentage":89},"C","#555555",19.9,{"name":91,"color":92,"percentage":93},"Python","#3572A5",7,{"name":95,"color":96,"percentage":97},"Shell","#89e051",0.4,{"name":99,"color":100,"percentage":97},"Makefile","#427819",6572,921,"2026-04-10T03:38:40","MIT",5,"macOS","不需要独立 GPU（如 NVIDIA），但项目利用 Apple Silicon 内置 GPU 进行部分预处理（如 Prefill），通过 IOSurface 与 ANE 零拷贝交互。必须使用搭载 Apple Neural Engine (ANE) 的 Apple Silicon 设备（如 M4）。","未说明（取决于运行模型的大小，需容纳模型权重及激活值）",{"notes":110,"python":111,"dependencies":112},"1. 这是一个研究项目而非生产框架，旨在通过逆向工程苹果私有 API (_ANEClient, _ANECompiler) 直接在 Apple Neural Engine (ANE) 上进行神经网络训练。\n2. 严禁在非 Apple Silicon 设备（Linux\u002FWindows\u002FNVIDIA GPU）上运行。\n3. 无需安装外部 Python 包（如 PyTorch），主要依赖系统自带的 C\u002FObj-C 编译器和框架。\n4. 需要预分词的 TinyStories 数据集用于训练。\n5. 由于使用未公开的私有 API，macOS 系统更新可能导致项目失效。","未说明（主要代码为 Objective-C (.m) 和 C，仅 dashboard.py 可能涉及 Python）",[113,114,115,116],"macOS 15+","Apple Silicon (M4 tested)","Xcode Command Line Tools (clang, make)","System Frameworks: Foundation, IOSurface, Accelerate (cblas, vDSP)",[14,118],"其他","2026-03-27T02:49:30.150509","2026-04-11T03:23:09.849957",[122,127,131,136,141,145],{"id":123,"question_zh":124,"answer_zh":125,"source_url":126},28915,"如何获取项目使用的 TinyStories 数据集？","数据集来自 HuggingFace 上的 `roneneldan\u002FTinyStories`。需要使用 [karpathy\u002Fllama2.c](https:\u002F\u002Fgithub.com\u002Fkarpathy\u002Fllama2.c) 中的 Llama 2 32k tokenizer 进行分词。你可以直接使用该项目中的 `tinystories.py pretokenize` 脚本来处理数据，设置与 llama2.c 项目相同。","https:\u002F\u002Fgithub.com\u002Fmaderix\u002FANE\u002Fissues\u002F4",{"id":128,"question_zh":129,"answer_zh":130,"source_url":126},28916,"运行 train_large 时出现文件路径错误或缺失文件怎么办？","代码中似乎硬编码了路径。解决方法是修改 `train_large.m` 文件的第 9 行，将路径从 `\"..\u002F..\u002Fassets\u002Fmodels\u002Fstories110M.bin\"` 改为 `\"stories110M.bin\"`，然后将数据文件放入 `training\u002F` 目录下。所需的模型文件 `stories110M.bin` 可以从 https:\u002F\u002Fhuggingface.co\u002Fkarpathy\u002Ftinyllamas 下载。",{"id":132,"question_zh":133,"answer_zh":134,"source_url":135},28917,"是否有基于此项目的 ANE 推理引擎或合成器示例？","有的。社区基于此逆向工程工作构建了多个项目：1. **ane-infer**：一个混合 ANE+Metal+CPU 的推理引擎，支持 Qwen3.5-2B，实现了融合内核（Fused Kernels）以达到 3.6 TFLOPS；2. **ane-synth**：一个直接在 ANE 上运行的实时神经合成器，利用私有 API 实现低延迟音频处理（157μs\u002F缓冲区）。这些项目验证了 `_ANEInMemoryModel`、MIL 文档和 IOSurface 模式的可用性。","https:\u002F\u002Fgithub.com\u002Fmaderix\u002FANE\u002Fissues\u002F44",{"id":137,"question_zh":138,"answer_zh":139,"source_url":140},28918,"在哪里可以找到 tinystories_data00.bin 文件？","该文件不是直接提供的二进制文件，而是需要用户自行生成。请参考相关 Issue 中关于数据集来源的说明：使用 HuggingFace 上的 `roneneldan\u002FTinyStories` 数据集，并配合 `karpathy\u002Fllama2.c` 项目中的脚本进行预处理和分词后生成。","https:\u002F\u002Fgithub.com\u002Fmaderix\u002FANE\u002Fissues\u002F1",{"id":142,"question_zh":143,"answer_zh":144,"source_url":135},28919,"该项目是否支持融合内核（Fused Kernels）以提升性能？","原始项目采用每个投影一个 ANE 内核的方式，但社区扩展项目（如 ane-infer）已成功实现融合内核技术。例如，将完整的 FFN（门控+sigmoid+up+mul+down = 8 个操作）融合到一个 MIL 程序中，吞吐量提升了 3 倍，达到 3.6 TFLOPS。这表明通过优化 MIL 程序结构可以显著突破单操作吞吐限制。",{"id":146,"question_zh":147,"answer_zh":148,"source_url":149},28920,"如何利用此项目进行实时音频处理？","可以参考 `ane-synth` 项目的实现方案。该项目使用 Rust 编写并通过 Obj-C 桥接层调用逆向工程发现的 API（如 `_ANEInMemoryModel`, `_ANERequest`）。它实现了纯 FP16 计算，无需 CoreML 或 Python，在单个批处理 ANE 调度中实现了 8 复音，延迟仅为 157μs，拥有 79 倍的实时余量。架构上使用 ANE 预测谐波振幅，CPU 负责加法合成。","https:\u002F\u002Fgithub.com\u002Fmaderix\u002FANE\u002Fissues\u002F43",[]]