[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-baidu-research--warp-ctc":3,"tool-baidu-research--warp-ctc":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 真正成长为懂上",160015,2,"2026-04-18T11:30:52",[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 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",109154,"2026-04-18T11:18:24",[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":66,"readme_en":67,"readme_zh":68,"quickstart_zh":69,"use_case_zh":70,"hero_image_url":71,"owner_login":72,"owner_name":73,"owner_avatar_url":74,"owner_bio":73,"owner_company":75,"owner_location":75,"owner_email":75,"owner_twitter":75,"owner_website":76,"owner_url":77,"languages":78,"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":115,"github_topics":75,"view_count":32,"oss_zip_url":75,"oss_zip_packed_at":75,"status":17,"created_at":117,"updated_at":118,"faqs":119,"releases":149},9165,"baidu-research\u002Fwarp-ctc","warp-ctc","Fast parallel CTC.","warp-ctc 是百度硅谷人工智能实验室开源的一款高性能计算库，专为加速“连接主义时间分类”（CTC）算法而设计。CTC 是一种关键的损失函数，广泛应用于语音识别等序列数据处理任务，它允许模型在没有输入数据与标签精确对齐的情况下进行端到端训练。\n\n传统 CTC 实现常面临计算效率低和数值不稳定两大难题：直接计算概率容易因组合爆炸导致成本过高，且在浮点运算中极易出现下溢错误。warp-ctc 通过动态规划大幅降低了计算复杂度，并创新性地采用对数空间运算，确保了即使在单精度浮点数下也能保持极高的数值稳定性，避免了结果变为无穷大的风险。\n\n该工具提供了 CPU 和 GPU（CUDA）两种并行版本，并支持 Torch 框架及简单的 C 接口，便于集成到各类深度学习系统中。其独特的 GPU 优化策略能让数据保留在显存中，从而释放带宽以提升数据并行度，显著扩大训练规模。warp-ctc 非常适合从事语音识别、序列建模的 AI 研究人员和深度学习开发者使用，帮助他们构建更高效、稳定的训练流水线。","![Baidu Logo](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fbaidu-research_warp-ctc_readme_1f594f75ad6e.png)\n\n[In Chinese 中文版](README.zh_cn.md)\n\n# warp-ctc\n\nA fast parallel implementation of CTC, on both CPU and GPU.\n\n## Introduction\n\n[Connectionist Temporal Classification](http:\u002F\u002Fwww.cs.toronto.edu\u002F~graves\u002Ficml_2006.pdf)\nis a loss function useful for performing supervised learning on sequence data,\nwithout needing an alignment between input data and labels.  For example, CTC\ncan be used to train\n[end-to-end](http:\u002F\u002Fwww.jmlr.org\u002Fproceedings\u002Fpapers\u002Fv32\u002Fgraves14.pdf)\n[systems](http:\u002F\u002Farxiv.org\u002Fpdf\u002F1408.2873v2.pdf) for\n[speech recognition](http:\u002F\u002Farxiv.org\u002Fabs\u002F1512.02595),\nwhich is how we have been using it at Baidu's Silicon Valley AI Lab.\n\n![DSCTC](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fbaidu-research_warp-ctc_readme_eb7c994618ed.png)\n\nThe illustration above shows CTC computing the probability of an output\nsequence \"THE CAT \", as a sum over all possible alignments of input sequences\nthat could map to \"THE CAT \", taking into account that labels may be duplicated\nbecause they may stretch over several time steps of the input data (represented by\nthe spectrogram at the bottom of the image).\nComputing the sum of all such probabilities explicitly would be prohibitively costly due to the\ncombinatorics involved, but CTC uses dynamic programming to dramatically\nreduce the complexity of the computation. Because CTC is a differentiable function,\nit can be used during standard SGD training of deep neural networks.\n\nIn our lab, we focus on scaling up recurrent neural networks, and CTC loss is an\nimportant component. To make our system efficient, we parallelized the CTC\nalgorithm, as described in [this paper](http:\u002F\u002Farxiv.org\u002Fabs\u002F1512.02595).\nThis project contains our high performance CPU and CUDA versions of the CTC loss,\nalong with bindings for [Torch](http:\u002F\u002Ftorch.ch\u002F).\nThe library provides a simple C interface, so that it is easy to\nintegrate into deep learning frameworks.\n\nThis implementation has improved training scalability beyond the\nperformance improvement from a faster parallel CTC implementation. For\nGPU-focused training pipelines, the ability to keep all data local to\nGPU memory allows us to spend interconnect bandwidth on increased data\nparallelism.\n\n## Performance\n\nOur CTC implementation is efficient compared with many of the other publicly available implementations.  It is\nalso written to be as numerically stable as possible.  The algorithm is numerically sensitive and we have observed\ncatastrophic underflow even in double precision with the standard calculation - the result of division of \ntwo numbers on the order of 1e-324 which should have been approximately one, instead become infinity \nwhen the denominator underflowed to 0.  Instead, by performing the calculation in log space, it is numerically\nstable even in single precision floating point at the cost of significantly more expensive operations.  Instead of\none machine instruction, addition requires the evaluation of multiple transcendental functions.  Because of this,\nthe speed of CTC implementations can only be fairly compared if they are both performing the calculation the same\nway.\n\nWe compare our performance with [Eesen](https:\u002F\u002Fgithub.com\u002Fsrvk\u002Feesen\u002Fcommit\u002F68f2bc2d46a5513cce3c232a645292632a1b08f9), \na CTC implementation built on \n[Theano](https:\u002F\u002Fgithub.com\u002Fmohammadpz\u002FCTC-Connectionist-Temporal-Classification\u002Fcommit\u002F904e8c72e15334887609d399254cf05a591d570f),\nand a Cython CPU only implementation [Stanford-CTC](https:\u002F\u002Fgithub.com\u002Famaas\u002Fstanford-ctc\u002Fcommit\u002Fc8859897336a349b6c561d2bf2d179fae90b4d67).\nWe benchmark the Theano implementation operating on 32-bit floating-point numbers and doing the calculation in log-space,\nin order to match the other implementations we compare against.  Stanford-CTC was modified to perform the calculation\nin log-space as it did not support it natively.  It also does not support minibatches larger than 1, so would require\nan awkward memory layout to use in a real training pipeline, we assume linear increase in cost with minibatch size.\n\nWe show results on two problem sizes relevant to our English and Mandarin end-to-end models, respectively, where *T* represents the number of timesteps in the input to CTC, *L* represents the length of the labels for each example, and *A* represents the alphabet size.\n\nOn the GPU, our performance at a minibatch of 64 examples ranges from 7x faster to 155x faster than Eesen, and 46x to 68x faster than the Theano implementation.\n\n### GPU Performance\nBenchmarked on a single NVIDIA Titan X GPU.\n\n| *T*=150, *L*=40, *A*=28           | warp-ctc  | Eesen   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 3.1 ms| .5 ms   | 67 ms |\n| *N*=16                            | 3.2 ms| 6  ms   | 94 ms |\n| *N*=32                            | 3.2 ms| 12 ms   | 119 ms |\n| *N*=64                            | 3.3 ms| 24 ms   | 153 ms |\n| *N*=128                           | 3.5 ms| 49 ms   | 231 ms |\n\n\n| *T*=150, *L*=20, *A*=5000         | warp-ctc  | Eesen   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 7 ms  | 40   ms | 120 ms |\n| *N*=16                            | 9 ms  | 619  ms | 385 ms |\n| *N*=32                            | 11 ms | 1238 ms | 665 ms |\n| *N*=64                            | 16 ms | 2475 ms | 1100 ms |\n| *N*=128                           | 23 ms | 4950 ms | 2100 ms |\n\n### CPU Performance\n\nBenchmarked on a dual-socket machine with two Intel E5-2660 v3\nprocessors - warp-ctc used 40 threads to maximally take advantage of the CPU resources.\nEesen doesn't provide a CPU implementation. We noticed that the Theano implementation was not\nparallelizing computation across multiple threads.  Stanford-CTC provides no mechanism\nfor parallelization across threads.\n\n\n| *T*=150, *L*=40, *A*=28           | warp-ctc  | Stanford-CTC   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 2.6 ms|  13 ms  | 15 ms |\n| *N*=16                            | 3.4 ms|  208 ms | 180 ms |\n| *N*=32                            | 3.9 ms|  416 ms | 375 ms |\n| *N*=64                            | 6.6 ms|  832 ms | 700 ms |\n| *N*=128                           |12.2 ms| 1684 ms | 1340 ms |\n\n\n| *T*=150, *L*=20, *A*=5000         | warp-ctc  | Stanford-CTC   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 21 ms |  31 ms  | 850 ms  |\n| *N*=16                            | 37 ms |  496 ms | 10800 ms|\n| *N*=32                            | 54 ms |  992 ms | 22000 ms|\n| *N*=64                            | 101 ms| 1984 ms | 42000 ms|\n| *N*=128                           | 184 ms| 3968 ms | 86000 ms|\n\n\n\n\n\n## Interface\n\nThe interface is in [`include\u002Fctc.h`](include\u002Fctc.h).\nIt supports CPU or GPU execution, and you can specify OpenMP parallelism\nif running on the CPU, or the CUDA stream if running on the GPU. We\ntook care to ensure that the library does not perform memory\nallocation internally, in order to avoid synchronizations and\noverheads caused by memory allocation.\n\n## Compilation\n\nwarp-ctc has been tested on Ubuntu 14.04 and OSX 10.10.  Windows is not supported\nat this time.\n\nFirst get the code:\n\n```\ngit clone https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc.git\ncd warp-ctc\n```\n\ncreate a build directory:\n\n```\nmkdir build\ncd build\n```\n\nif you have a non standard CUDA install `export CUDA_BIN_PATH=\u002Fpath_to_cuda` so that CMake detects CUDA and\nto ensure Torch is detected, make sure `th` is in `$PATH`\n\nrun cmake and build:\n\n```\ncmake ..\u002F\nmake\n```\n\nThe C library and torch shared libraries should now be built along with test\nexecutables.  If CUDA was detected, then `test_gpu` will be built; `test_cpu`\nwill always be built.\n\n## Tests\n\nTo run the tests, make sure the CUDA libraries are in `LD_LIBRARY_PATH` (`DYLD_LIBRARY_PATH` for OSX).\n\nThe Torch tests must be run from the `torch_binding\u002Ftests\u002F` directory.\n\n## Torch Installation\n\n```luarocks make torch_binding\u002Frocks\u002Fwarp-ctc-scm-1.rockspec```\n\nYou can also install without cloning the repository using\n\n```luarocks install http:\u002F\u002Fraw.githubusercontent.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fmaster\u002Ftorch_binding\u002Frocks\u002Fwarp-ctc-scm-1.rockspec```\n\nThere is a Torch CTC [tutorial](torch_binding\u002FTUTORIAL.md).\n\n## Contributing\n\nWe welcome improvements from the community, please feel free to submit pull\nrequests.\n\n## Known Issues  \u002F Limitations\n\nThe CUDA implementation requires a device of at least compute capability 3.0.\n\nThe CUDA implementation supports a maximum label length of 639 (timesteps are\nunlimited).\n","![百度Logo](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fbaidu-research_warp-ctc_readme_1f594f75ad6e.png)\n\n[中文版](README.zh_cn.md)\n\n# warp-ctc\n\n一种在 CPU 和 GPU 上实现的快速并行 CTC 算法。\n\n## 引言\n\n[连接时序分类](http:\u002F\u002Fwww.cs.toronto.edu\u002F~graves\u002Ficml_2006.pdf) 是一种损失函数，适用于对序列数据进行监督学习，而无需输入数据与标签之间的对齐。例如，CTC 可以用于训练用于[语音识别](http:\u002F\u002Farxiv.org\u002Fabs\u002F1512.02595)的[端到端](http:\u002F\u002Fwww.jmlr.org\u002Fproceedings\u002Fpapers\u002Fv32\u002Fgraves14.pdf)系统，这也是我们在百度硅谷 AI 实验室一直以来使用的方式。\n\n![DSCTC](https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fbaidu-research_warp-ctc_readme_eb7c994618ed.png)\n\n上图展示了 CTC 如何计算输出序列“THE CAT”的概率，它是所有可能映射到“THE CAT”的输入序列对齐方式的概率之和。需要注意的是，由于标签可能会在输入数据的多个时间步上重复出现（如图中底部的语谱图所示），因此标签可能会被拉伸。如果显式地计算所有这些概率之和，由于组合数学的原因，计算成本将非常高昂。然而，CTC 使用动态规划技术显著降低了计算复杂度。由于 CTC 是一个可微分函数，因此它可以在深度神经网络的标准 SGD 训练过程中使用。\n\n在我们的实验室中，我们专注于扩展循环神经网络，而 CTC 损失是其中的重要组成部分。为了提高系统的效率，我们对 CTC 算法进行了并行化，具体方法见[这篇论文](http:\u002F\u002Farxiv.org\u002Fabs\u002F1512.02595)。该项目包含了我们高性能的 CPU 和 CUDA 版本的 CTC 损失函数，以及针对 [Torch](http:\u002F\u002Ftorch.ch\u002F) 的绑定。该库提供了一个简单的 C 接口，便于集成到深度学习框架中。\n\n这种实现不仅提升了训练的可扩展性，还超越了单纯通过更快的并行 CTC 实现所带来的性能提升。对于以 GPU 为中心的训练流程，能够将所有数据保留在 GPU 内存中，使我们能够将互联带宽用于增加数据并行度。\n\n## 性能\n\n与许多其他公开可用的实现相比，我们的 CTC 实现非常高效。同时，我们也尽可能地提高了数值稳定性。该算法对数值敏感，我们甚至在使用双精度进行标准计算时也观察到了灾难性的下溢现象——两个数量级约为 1e-324 的数相除，本应得到约 1 的结果，但由于分母下溢为 0，最终结果却变成了无穷大。相反，通过在对数空间中进行计算，即使在单精度浮点下也能保持数值稳定性，尽管这会带来更高的计算开销。加法操作不再是一条机器指令，而是需要评估多个超越函数。因此，只有当不同实现采用相同的方式进行计算时，才能公平地比较它们的速度。\n\n我们将我们的性能与 [Eesen](https:\u002F\u002Fgithub.com\u002Fsrvk\u002Feesen\u002Fcommit\u002F68f2bc2d46a5513cce3c232a645292632a1b08f9)、基于 [Theano](https:\u002F\u002Fgithub.com\u002Fmohammadpz\u002FCTC-Connectionist-Temporal-Classification\u002Fcommit\u002F904e8c72e15334887609d399254cf05a591d570f) 构建的 CTC 实现，以及仅支持 CPU 的 Cython 实现 [Stanford-CTC](https:\u002F\u002Fgithub.com\u002Famaas\u002Fstanford-ctc\u002Fcommit\u002Fc8859897336a349b6c561d2bf2d179fae90b4d67) 进行对比。为了与其它实现保持一致，我们对 Theano 实现进行了基准测试，使其在 32 位浮点数上运行，并在对数空间中进行计算。Stanford-CTC 原本不支持对数空间计算，因此我们也对其进行了修改以支持这一功能。此外，Stanford-CTC 不支持大于 1 的小批量，因此在实际训练流程中使用时需要特殊的内存布局，我们假设其计算成本随小批量大小线性增加。\n\n我们展示了两种问题规模的结果，分别对应于我们的英语和普通话端到端模型。其中 *T* 表示 CTC 输入的时间步数，*L* 表示每个样本的标签长度，*A* 表示词汇表大小。\n\n在 GPU 上，当小批量大小为 64 时，我们的性能比 Eesen 快 7 到 155 倍，比 Theano 实现快 46 到 68 倍。\n\n### GPU 性能\n在单个 NVIDIA Titan X GPU 上进行基准测试。\n\n| *T*=150, *L*=40, *A*=28           | warp-ctc  | Eesen   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 3.1 ms| .5 ms   | 67 ms |\n| *N*=16                            | 3.2 ms| 6  ms   | 94 ms |\n| *N*=32                            | 3.2 ms| 12 ms   | 119 ms |\n| *N*=64                            | 3.3 ms| 24 ms   | 153 ms |\n| *N*=128                           | 3.5 ms| 49 ms   | 231 ms |\n\n\n| *T*=150, *L*=20, *A*=5000         | warp-ctc  | Eesen   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 7 ms  | 40   ms | 120 ms |\n| *N*=16                            | 9 ms  | 619  ms | 385 ms |\n| *N*=32                            | 11 ms | 1238 ms | 665 ms |\n| *N*=64                            | 16 ms | 2475 ms | 1100 ms |\n| *N*=128                           | 23 ms | 4950 ms | 2100 ms |\n\n### CPU 性能\n\n在一台配备两颗 Intel E5-2660 v3 处理器的双路服务器上进行基准测试。warp-ctc 使用 40 个线程以充分利用 CPU 资源。Eesen 没有提供 CPU 实现。我们注意到 Theano 实现并未在多线程之间并行化计算。而 Stanford-CTC 则完全不支持多线程并行化。\n\n| *T*=150, *L*=40, *A*=28           | warp-ctc  | Stanford-CTC   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 2.6 ms|  13 ms  | 15 ms |\n| *N*=16                            | 3.4 ms|  208 ms | 180 ms |\n| *N*=32                            | 3.9 ms|  416 ms | 375 ms |\n| *N*=64                            | 6.6 ms|  832 ms | 700 ms |\n| *N*=128                           |12.2 ms| 1684 ms | 1340 ms |\n\n\n| *T*=150, *L*=20, *A*=5000         | warp-ctc  | Stanford-CTC   | Theano  |\n|-----------------------------------|-------|---------|---------|\n| *N*=1                             | 21 ms |  31 ms  | 850 ms  |\n| *N*=16                            | 37 ms |  496 ms | 10800 ms|\n| *N*=32                            | 54 ms |  992 ms | 22000 ms|\n| *N*=64                            | 101 ms| 1984 ms | 42000 ms|\n| *N*=128                           | 184 ms| 3968 ms | 86000 ms|\n\n## 接口\n\n接口定义在 [`include\u002Fctc.h`](include\u002Fctc.h) 中。它支持 CPU 或 GPU 上的执行；在 CPU 上运行时可以指定 OpenMP 并行度，在 GPU 上运行时则可以指定 CUDA 流。我们特别注意确保该库内部不进行内存分配，以避免因内存分配带来的同步和开销。\n\n## 编译\n\nwarp-ctc 已在 Ubuntu 14.04 和 OSX 10.10 上测试通过。目前暂不支持 Windows。\n\n首先获取代码：\n\n```\ngit clone https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc.git\ncd warp-ctc\n```\n\n创建一个构建目录：\n\n```\nmkdir build\ncd build\n```\n\n如果您的 CUDA 安装路径非标准，请设置环境变量 `export CUDA_BIN_PATH=\u002Fpath_to_cuda`，以便 CMake 能够正确检测到 CUDA。同时，请确保 `th` 命令位于 `$PATH` 中，以保证 Torch 能被正确识别。\n\n接下来运行 CMake 并编译：\n\n```\ncmake ..\u002F\nmake\n```\n\n此时应会生成 C 库和 Torch 共享库，以及相应的测试可执行文件。如果检测到了 CUDA，则会构建 `test_gpu`；而 `test_cpu` 则始终会被构建。\n\n## 测试\n\n运行测试时，请确保 CUDA 库位于 `LD_LIBRARY_PATH`（对于 OSX 为 `DYLD_LIBRARY_PATH`）中。\n\nTorch 相关的测试必须从 `torch_binding\u002Ftests\u002F` 目录下运行。\n\n## Torch 安装\n\n```luarocks make torch_binding\u002Frocks\u002Fwarp-ctc-scm-1.rockspec```\n\n您也可以无需克隆仓库直接安装，命令如下：\n\n```luarocks install http:\u002F\u002Fraw.githubusercontent.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fmaster\u002Ftorch_binding\u002Frocks\u002Fwarp-ctc-scm-1.rockspec```\n\n此外，还提供了一个 Torch CTC 的[教程](torch_binding\u002FTUTORIAL.md)。\n\n## 贡献\n\n我们欢迎社区的改进与贡献，请随时提交 Pull Request。\n\n## 已知问题 \u002F 限制\n\nCUDA 实现要求设备的计算能力至少为 3.0。\n\nCUDA 实现支持的最大标签长度为 639（时间步数无限制）。","# warp-ctc 快速上手指南\n\nwarp-ctc 是百度研究院开源的高性能 CTC（Connectionist Temporal Classification）损失函数实现，支持 CPU 和 GPU 并行计算。它专为端到端语音识别等序列学习任务设计，具有极高的数值稳定性和训练扩展性。\n\n## 环境准备\n\n### 系统要求\n- **操作系统**：Ubuntu 14.04+ 或 macOS 10.10+（暂不支持 Windows）\n- **GPU 要求**（如需 GPU 加速）：NVIDIA GPU，计算能力（Compute Capability）至少为 3.0\n- **编译器**：支持 C++11 的编译器（如 GCC）\n\n### 前置依赖\n- **CMake**：用于构建项目\n- **CUDA Toolkit**（可选）：如需编译 GPU 版本，需安装 CUDA 并配置环境变量\n- **Torch**（可选）：如需使用 Lua\u002FTorch 绑定，需安装 Torch 框架并确保 `th` 命令在 `$PATH` 中\n- **OpenMP**：CPU 版本利用 OpenMP 进行多线程并行（通常随编译器自带）\n\n> **提示**：若 CUDA 安装在非标准路径，请设置环境变量：\n> ```bash\n> export CUDA_BIN_PATH=\u002Fpath_to_cuda\n> ```\n\n## 安装步骤\n\n### 1. 获取源码\n```bash\ngit clone https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc.git\ncd warp-ctc\n```\n\n### 2. 创建构建目录\n```bash\nmkdir build\ncd build\n```\n\n### 3. 配置与编译\n确保 `th`（如果使用 Torch）在环境变量中，然后运行 CMake 和 Make：\n```bash\ncmake ..\u002F\nmake\n```\n\n编译完成后，`build` 目录下将生成：\n- `libwarpctc.so` (或 `.dylib`)：C 动态链接库\n- `test_cpu`：CPU 测试程序\n- `test_gpu`：若检测到 CUDA，将生成 GPU 测试程序\n\n### 4. 安装 Torch 绑定（可选）\n如果您使用 Torch 框架，可以通过 luarocks 安装绑定：\n\n**方式一：本地安装**\n```bash\nluarocks make torch_binding\u002Frocks\u002Fwarp-ctc-scm-1.rockspec\n```\n\n**方式二：远程安装（无需克隆仓库）**\n```bash\nluarocks install http:\u002F\u002Fraw.githubusercontent.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fmaster\u002Ftorch_binding\u002Frocks\u002Fwarp-ctc-scm-1.rockspec\n```\n\n## 基本使用\n\nwarp-ctc 提供了简洁的 C 接口（见 `include\u002Fctc.h`），可轻松集成到深度学习框架中。库内部不进行内存分配，以避免同步开销，调用前需自行管理输入输出内存。\n\n### C\u002FC++ 使用示例逻辑\n虽然具体代码取决于您的框架集成，但核心调用流程如下：\n\n1. **引入头文件**\n   ```c\n   #include \"ctc.h\"\n   ```\n\n2. **准备数据**\n   - `activations`: 神经网络输出的概率分布（形状：`[num_times, num_classes * minibatch_size]`）\n   - `labels`: 真实标签序列（扁平化存储）\n   - `label_lengths`: 每个样本的标签长度\n   - `input_lengths`: 每个样本的时间步长度\n\n3. **计算损失与梯度**\n   ```c\n   \u002F\u002F 初始化工作空间大小\n   size_t workspace_size;\n   compute_ctc_loss_workspace_size(..., &workspace_size);\n\n   \u002F\u002F 分配显存\u002F内存作为 workspace\n   void* workspace = malloc(workspace_size); \n\n   \u002F\u002F 执行损失计算\n   float loss;\n   compute_ctc_loss(activations, gradients, labels, label_lengths, \n                    input_lengths, alphabet_size, minibatch_size, \n                    workspace, &loss, stream);\n   ```\n   *注：`stream` 参数在 CPU 模式下可设为 NULL 或用于指定 OpenMP 线程，在 GPU 模式下传入 CUDA Stream。*\n\n### Torch 使用示例\n安装绑定后，可在 Lua 脚本中直接调用：\n\n```lua\nlocal ctc = require 'warp_ctc'\n\n-- 定义 CTC 模块\nlocal criterion = ctc.CTC()\n\n-- 前向传播计算损失\n-- input: [T, N, A] (Time, Batch, Alphabet)\n-- target: 标签张量\nlocal loss = criterion:forward(input, target)\n\n-- 反向传播计算梯度\nlocal gradInput = criterion:backward(input, target)\n```\n\n详细用法请参考官方教程：`torch_binding\u002FTUTORIAL.md`。\n\n> **注意**：运行测试或程序时，请确保动态库路径已加入环境变量：\n> - Linux: `export LD_LIBRARY_PATH=\u002Fpath\u002Fto\u002Fwarp-ctc\u002Fbuild:$LD_LIBRARY_PATH`\n> - macOS: `export DYLD_LIBRARY_PATH=\u002Fpath\u002Fto\u002Fwarp-ctc\u002Fbuild:$DYLD_LIBRARY_PATH`","某语音识别初创团队正在训练端到端的深度神经网络模型，需处理海量音频数据与文本标签的非对齐序列学习问题。\n\n### 没有 warp-ctc 时\n- **训练速度极慢**：使用传统的 CPU 版 CTC 实现（如 Stanford-CTC），无法利用 GPU 并行加速，导致每个 epoch 耗时过长，迭代周期以天计算。\n- **显存带宽浪费**：由于缺乏高效的 GPU 内核，数据必须在 CPU 和 GPU 间频繁传输，宝贵的互联带宽被数据传输占用，而非用于增加数据并行度。\n- **数值计算崩溃**：在处理长序列或低概率事件时，标准浮点计算容易发生下溢（underflow），导致损失值变为无穷大，训练过程意外中断。\n- **扩展性受限**：难以支持大规模 minibatch 训练，限制了模型收敛速度和最终识别准确率的上限。\n\n### 使用 warp-ctc 后\n- **训练效率飞跃**：warp-ctc 提供高度优化的 CUDA 并行实现，将 CTC 损失计算速度提升数倍，显著缩短模型训练时间。\n- **全链路 GPU 化**：所有计算均在显存内完成，消除了主机与设备间的数据拷贝开销，释放出的带宽可支持更大的数据并行规模。\n- **数值稳定可靠**：通过在 log 空间进行动态规划计算，warp-ctc 即使在单精度浮点数下也能避免下溢问题，确保训练过程平滑稳定。\n- **无缝集成框架**：提供简洁的 C 接口及 Torch 绑定，轻松嵌入现有的深度学习流水线，支持大规模 minibatch 高效训练。\n\nwarp-ctc 通过高性能并行计算与数值稳定性优化，解决了语音识别模型训练中 CTC 损失计算的瓶颈，让大规模端到端训练变得高效且可靠。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fbaidu-research_warp-ctc_a2fcea04.png","baidu-research","Baidu Research","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Fbaidu-research_faaa443a.png",null,"http:\u002F\u002Fusa.baidu.com\u002F","https:\u002F\u002Fgithub.com\u002Fbaidu-research",[79,83,87,91,95,98],{"name":80,"color":81,"percentage":82},"Cuda","#3A4E3A",50.3,{"name":84,"color":85,"percentage":86},"C++","#f34b7d",33.3,{"name":88,"color":89,"percentage":90},"Python","#3572A5",6.7,{"name":92,"color":93,"percentage":94},"CMake","#DA3434",3.9,{"name":96,"color":97,"percentage":94},"C","#555555",{"name":99,"color":100,"percentage":32},"Lua","#000080",4074,1034,"2026-03-24T09:19:51","Apache-2.0",4,"Linux (Ubuntu 14.04), macOS (10.10)","需要 NVIDIA GPU，计算能力 (Compute Capability) 至少 3.0，需安装 CUDA","未说明",{"notes":110,"python":108,"dependencies":111},"不支持 Windows 系统。GPU 实现要求标签长度最大为 639（时间步数无限制）。编译时需确保 'th' (Torch) 在 PATH 环境变量中，若 CUDA 非标准安装需设置 CUDA_BIN_PATH。该工具主要提供 C 接口及 Lua Torch 绑定，未提及原生 Python 支持。",[112,92,113,114],"CUDA","Torch (Lua)","OpenMP (CPU 并行可选)",[116,14],"音频","2026-03-27T02:49:30.150509","2026-04-19T03:05:05.015412",[120,125,130,135,140,145],{"id":121,"question_zh":122,"answer_zh":123,"source_url":124},41155,"为什么运行代码时 CTC 损失返回无穷大（inf），但梯度是正常的？","这通常是由于浮点数溢出引起的。虽然 Softmax 函数会通过减去最大值进行归一化，但如果输出值之间的差距过大，仍可能触发溢出。解决方案包括：\n1. 在网络早期使用裁剪策略，例如使用 `nn.HardTanh(0,20)` 来模拟 clipped ReLU。\n2. 尝试在 log 空间执行 Softmax（log_softmax），但这可能会降低精度并轻微影响训练性能。\n3. 检查预测张量的最大值，确认是否存在导致溢出的极大正数。","https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fissues\u002F23",{"id":126,"question_zh":127,"answer_zh":128,"source_url":129},41156,"Warp-CTC 有中文文档或教程吗？","有的，项目已提供中文文档和教程。您可以访问以下链接：\n1. 中文 README: https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fblob\u002Fmaster\u002FREADME.zh_cn.md\n2. Torch 绑定中文教程: https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fblob\u002Fmaster\u002Ftorch_binding\u002FTUTORIAL.zh_cn.md","https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fissues\u002F8",{"id":131,"question_zh":132,"answer_zh":133,"source_url":134},41157,"安装 TensorFlow 绑定时遇到 'undefined symbol: _ZTIN10tensorflow8OpKernelE' 错误怎么办？","这通常是由于编译时的 C++ ABI 不匹配导致的。如果您使用 gcc 5 或更高版本编译了 TensorFlow 源码，需要在运行 `setup.py` 之前设置环境变量 `TF_CXX11_ABI=1`。\n命令示例：\n`export TF_CXX11_ABI=1`\n然后再运行安装命令。如果使用的是二进制 pip 包，通常默认不需要此设置，但若出现该错误也可尝试设置。","https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fissues\u002F119",{"id":136,"question_zh":137,"answer_zh":138,"source_url":139},41158,"运行 `python setup.py test` 时出现 TensorFlow 测试错误，可能的原因是什么？","最常见的原因是环境变量 `TENSORFLOW_SRC_PATH` 指定的 TensorFlow 源码版本与系统中安装的 TensorFlow 版本不一致。请确保两者版本完全匹配。\n此外，还需检查：\n1. 代码是否针对正确的 GPU 架构进行了编译（Titan X 和 GTX960 通常没问题）。\n2. `ctc_op_kernel.cc` 中的 `REGISTER_KERNEL_BUILDER` 是否正常执行。\n3. 使用的 TensorFlow 版本是否过旧，建议升级到较新版本。","https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fissues\u002F55",{"id":141,"question_zh":142,"answer_zh":143,"source_url":144},41159,"安装过程中出现 'ValueError: list.remove(x): x not in list' 错误如何解决？","该错误常伴随关于 C++11 ABI 的警告出现。解决方法是正确设置 `TF_CXX11_ABI` 环境变量：\n1. 如果您使用 gcc >= 5 从源码编译了 TensorFlow 且未设置 `-D_GLIBCXX_USE_CXX11_ABI=0`，则需设置 `export TF_CXX11_ABI=1`。\n2. 如果使用二进制 pip 包，通常默认为 0，但若报错可尝试显式设置。\n3. 设置环境变量后，务必修改 `src` 目录下的某些文件以触发重新编译，然后再次运行安装命令。","https:\u002F\u002Fgithub.com\u002Fbaidu-research\u002Fwarp-ctc\u002Fissues\u002F139",{"id":146,"question_zh":147,"answer_zh":148,"source_url":144},41160,"如何在安装前判断是否需要设置 TF_CXX11_ABI 环境变量？","安装脚本通常会发出警告提示。如果看到类似 \"Assuming tensorflow was compiled without C++11 ABI\" 的警告，并且您满足以下条件之一，则需要设置该变量：\n1. 使用 gcc 5 或更高版本从源码编译了 TensorFlow。\n2. 编译时未指定 `-D_GLIBCXX_USE_CXX11_ABI=0`。\n3. 遇到了 \"undefined symbol: _ZN10tensorflow...\" 类似的链接错误。\n在这种情况下，请在运行 `setup.py` 前执行 `export TF_CXX11_ABI=1`。",[]]