[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-zhihu--cuBERT":3,"tool-zhihu--cuBERT":64},[4,17,27,35,43,56],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":16},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,3,"2026-04-05T11:01:52",[13,14,15],"开发框架","图像","Agent","ready",{"id":18,"name":19,"github_repo":20,"description_zh":21,"stars":22,"difficulty_score":23,"last_commit_at":24,"category_tags":25,"status":16},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 真正成长为懂上",140436,2,"2026-04-05T23:32:43",[13,15,26],"语言模型",{"id":28,"name":29,"github_repo":30,"description_zh":31,"stars":32,"difficulty_score":23,"last_commit_at":33,"category_tags":34,"status":16},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 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",107662,"2026-04-03T11:11:01",[13,14,15],{"id":36,"name":37,"github_repo":38,"description_zh":39,"stars":40,"difficulty_score":23,"last_commit_at":41,"category_tags":42,"status":16},3704,"NextChat","ChatGPTNextWeb\u002FNextChat","NextChat 是一款轻量且极速的 AI 助手，旨在为用户提供流畅、跨平台的大模型交互体验。它完美解决了用户在多设备间切换时难以保持对话连续性，以及面对众多 AI 模型不知如何统一管理的痛点。无论是日常办公、学习辅助还是创意激发，NextChat 都能让用户随时随地通过网页、iOS、Android、Windows、MacOS 或 Linux 端无缝接入智能服务。\n\n这款工具非常适合普通用户、学生、职场人士以及需要私有化部署的企业团队使用。对于开发者而言，它也提供了便捷的自托管方案，支持一键部署到 Vercel 或 Zeabur 等平台。\n\nNextChat 的核心亮点在于其广泛的模型兼容性，原生支持 Claude、DeepSeek、GPT-4 及 Gemini Pro 等主流大模型，让用户在一个界面即可自由切换不同 AI 能力。此外，它还率先支持 MCP（Model Context Protocol）协议，增强了上下文处理能力。针对企业用户，NextChat 提供专业版解决方案，具备品牌定制、细粒度权限控制、内部知识库整合及安全审计等功能，满足公司对数据隐私和个性化管理的高标准要求。",87618,"2026-04-05T07:20:52",[13,26],{"id":44,"name":45,"github_repo":46,"description_zh":47,"stars":48,"difficulty_score":23,"last_commit_at":49,"category_tags":50,"status":16},2268,"ML-For-Beginners","microsoft\u002FML-For-Beginners","ML-For-Beginners 是由微软推出的一套系统化机器学习入门课程，旨在帮助零基础用户轻松掌握经典机器学习知识。这套课程将学习路径规划为 12 周，包含 26 节精炼课程和 52 道配套测验，内容涵盖从基础概念到实际应用的完整流程，有效解决了初学者面对庞大知识体系时无从下手、缺乏结构化指导的痛点。\n\n无论是希望转型的开发者、需要补充算法背景的研究人员，还是对人工智能充满好奇的普通爱好者，都能从中受益。课程不仅提供了清晰的理论讲解，还强调动手实践，让用户在循序渐进中建立扎实的技能基础。其独特的亮点在于强大的多语言支持，通过自动化机制提供了包括简体中文在内的 50 多种语言版本，极大地降低了全球不同背景用户的学习门槛。此外，项目采用开源协作模式，社区活跃且内容持续更新，确保学习者能获取前沿且准确的技术资讯。如果你正寻找一条清晰、友好且专业的机器学习入门之路，ML-For-Beginners 将是理想的起点。",84991,"2026-04-05T10:45:23",[14,51,52,53,15,54,26,13,55],"数据工具","视频","插件","其他","音频",{"id":57,"name":58,"github_repo":59,"description_zh":60,"stars":61,"difficulty_score":10,"last_commit_at":62,"category_tags":63,"status":16},3128,"ragflow","infiniflow\u002Fragflow","RAGFlow 是一款领先的开源检索增强生成（RAG）引擎，旨在为大语言模型构建更精准、可靠的上下文层。它巧妙地将前沿的 RAG 技术与智能体（Agent）能力相结合，不仅支持从各类文档中高效提取知识，还能让模型基于这些知识进行逻辑推理和任务执行。\n\n在大模型应用中，幻觉问题和知识滞后是常见痛点。RAGFlow 通过深度解析复杂文档结构（如表格、图表及混合排版），显著提升了信息检索的准确度，从而有效减少模型“胡编乱造”的现象，确保回答既有据可依又具备时效性。其内置的智能体机制更进一步，使系统不仅能回答问题，还能自主规划步骤解决复杂问题。\n\n这款工具特别适合开发者、企业技术团队以及 AI 研究人员使用。无论是希望快速搭建私有知识库问答系统，还是致力于探索大模型在垂直领域落地的创新者，都能从中受益。RAGFlow 提供了可视化的工作流编排界面和灵活的 API 接口，既降低了非算法背景用户的上手门槛，也满足了专业开发者对系统深度定制的需求。作为基于 Apache 2.0 协议开源的项目，它正成为连接通用大模型与行业专有知识之间的重要桥梁。",77062,"2026-04-04T04:44:48",[15,14,13,26,54],{"id":65,"github_repo":66,"name":67,"description_en":68,"description_zh":69,"ai_summary_zh":70,"readme_en":71,"readme_zh":72,"quickstart_zh":73,"use_case_zh":74,"hero_image_url":75,"owner_login":76,"owner_name":77,"owner_avatar_url":78,"owner_bio":79,"owner_company":80,"owner_location":80,"owner_email":81,"owner_twitter":80,"owner_website":82,"owner_url":83,"languages":84,"stars":109,"forks":110,"last_commit_at":111,"license":112,"difficulty_score":113,"env_os":114,"env_gpu":115,"env_ram":116,"env_deps":117,"category_tags":128,"github_topics":129,"view_count":23,"oss_zip_url":80,"oss_zip_packed_at":80,"status":16,"created_at":138,"updated_at":139,"faqs":140,"releases":176},2132,"zhihu\u002FcuBERT","cuBERT","Fast implementation of BERT inference directly on NVIDIA (CUDA, CUBLAS) and Intel MKL","cuBERT 是一款专为加速 BERT 模型推理而打造的高性能开源工具。它摒弃了 TensorFlow 等重型框架的冗余开销，直接基于 NVIDIA CUDA\u002FCUBLAS 或 Intel MKL 底层库进行高度定制化开发，从而显著提升了运行效率。\n\n在实际应用中，cuBERT 有效解决了传统框架在部署 BERT 时存在的延迟高、资源占用大等痛点。测试数据显示，无论是在 GPU 还是 CPU 环境下，其推理速度均大幅优于原生 TensorFlow 实现，特别是在小批量或单次请求场景下，响应时间可缩短数倍。此外，cuBERT 还支持混合精度计算，利用 NVIDIA Tensor Core 技术，在保持误差低于 1% 的前提下，进一步将运算速度提升两倍以上。\n\n这款工具非常适合需要高效部署 NLP 模型的后端工程师、算法研究人员以及对推理延迟敏感的开发团队。虽然它目前仅支持标准的 BERT（Transformer）架构，但提供了灵活的池化方法和多样的输出接口，并附带便捷的 Python 封装，方便用户快速集成到现有系统中。如果你正在寻求轻量级、极速的 BERT 推理方案，cuBERT 是一","cuBERT 是一款专为加速 BERT 模型推理而打造的高性能开源工具。它摒弃了 TensorFlow 等重型框架的冗余开销，直接基于 NVIDIA CUDA\u002FCUBLAS 或 Intel MKL 底层库进行高度定制化开发，从而显著提升了运行效率。\n\n在实际应用中，cuBERT 有效解决了传统框架在部署 BERT 时存在的延迟高、资源占用大等痛点。测试数据显示，无论是在 GPU 还是 CPU 环境下，其推理速度均大幅优于原生 TensorFlow 实现，特别是在小批量或单次请求场景下，响应时间可缩短数倍。此外，cuBERT 还支持混合精度计算，利用 NVIDIA Tensor Core 技术，在保持误差低于 1% 的前提下，进一步将运算速度提升两倍以上。\n\n这款工具非常适合需要高效部署 NLP 模型的后端工程师、算法研究人员以及对推理延迟敏感的开发团队。虽然它目前仅支持标准的 BERT（Transformer）架构，但提供了灵活的池化方法和多样的输出接口，并附带便捷的 Python 封装，方便用户快速集成到现有系统中。如果你正在寻求轻量级、极速的 BERT 推理方案，cuBERT 是一个值得尝试的专业选择。","Fast implementation of BERT inference directly on NVIDIA (CUDA, CUBLAS) and Intel MKL\n=====================================================================================\n\n[![Build Status](https:\u002F\u002Ftravis-ci.org\u002Fzhihu\u002FcuBERT.svg?branch=master)](https:\u002F\u002Ftravis-ci.org\u002Fzhihu\u002FcuBERT)\n\nHighly customized and optimized BERT inference directly on NVIDIA (CUDA,\nCUBLAS) or Intel MKL, *without* tensorflow and its framework overhead.\n\n**ONLY** BERT (Transformer) is supported.\n\n# Benchmark\n\n### Environment\n\n* Tesla P4\n* 28 * Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz\n* Debian GNU\u002FLinux 8 (jessie)\n* gcc (Debian 4.9.2-10+deb8u1) 4.9.2\n* CUDA: release 9.0, V9.0.176\n* MKL: 2019.0.1.20181227\n* tensorflow: 1.12.0\n* BERT: seq_length = 32\n\n### GPU (cuBERT)\n\n|batch size|128 (ms) |32 (ms) |\n|---       |---      |---     |\n|tensorflow|255.2    |70.0    |\n|cuBERT    |**184.6**|**54.5**|\n\n### CPU (mklBERT)\n\n|batch size|128 (ms) |1 (ms)  |\n|---       |---      |---     |\n|tensorflow|1504.0   |69.9    |\n|mklBERT   |**984.9**|**24.0**|\n\nNote: MKL should be run under `OMP_NUM_THREADS=?` to control its thread\nnumber. Other environment variables and their possible values includes:\n\n* `KMP_BLOCKTIME=0`\n* `KMP_AFFINITY=granularity=fine,verbose,compact,1,0`\n\n### Mixed Precision\n\ncuBERT can be accelerated by [Tensor Core](https:\u002F\u002Fdeveloper.nvidia.com\u002Ftensor-cores)\nand [Mixed Precision](https:\u002F\u002Fdevblogs.nvidia.com\u002Ftensor-cores-mixed-precision-scientific-computing)\non NVIDIA Volta and Turing GPUs. We support mixed precision as variables\nstored in fp16 with computation taken in fp32. The typical accuracy error\nis less than 1% compared with single precision inference, while the speed\nachieves more than 2x acceleration.\n\n# API\n\n[API .h header](\u002Fsrc\u002FcuBERT.h)\n\n### Pooler\n\nWe support following 2 pooling method.\n\n* The standard BERT pooler, which is defined as:\n\n```python\nwith tf.variable_scope(\"pooler\"):\n  # We \"pool\" the model by simply taking the hidden state corresponding\n  # to the first token. We assume that this has been pre-trained\n  first_token_tensor = tf.squeeze(self.sequence_output[:, 0:1, :], axis=1)\n  self.pooled_output = tf.layers.dense(\n    first_token_tensor,\n    config.hidden_size,\n    activation=tf.tanh,\n    kernel_initializer=create_initializer(config.initializer_range))\n```\n\n* Simple average pooler:\n\n```python\nself.pooled_output = tf.reduce_mean(self.sequence_output, axis=1)\n```\n\n### Output\n\nFollowing outputs are supported:\n\n|cuBERT_OutputType      |python code                   |\n|---                    |---                           |\n|cuBERT_LOGITS          |[`model.get_pooled_output() * output_weights + output_bias`](https:\u002F\u002Fgithub.com\u002Fgoogle-research\u002Fbert\u002Fblob\u002Fd66a146741588fb208450bde15aa7db143baaa69\u002Frun_classifier.py#L607)|\n|cuBERT_PROBS           |`probs = tf.nn.softmax(logits, axis=-1)`|\n|cuBERT_POOLED_OUTPUT   |`model.get_pooled_output()`   |\n|cuBERT_SEQUENCE_OUTPUT |`model.get_sequence_output()` |\n|cuBERT_EMBEDDING_OUTPUT|`model.get_embedding_output()`|\n\n# Build from Source\n\n```shell\nmkdir build && cd build\n# if build with CUDA\ncmake -DCMAKE_BUILD_TYPE=Release -DcuBERT_ENABLE_GPU=ON -DCUDA_ARCH_NAME=Common ..\n# or build with MKL\ncmake -DCMAKE_BUILD_TYPE=Release -DcuBERT_ENABLE_MKL_SUPPORT=ON ..\nmake -j4\n\n# install to \u002Fusr\u002Flocal\n# it will also install MKL if -DcuBERT_ENABLE_MKL_SUPPORT=ON\nsudo make install\n```\n\nIf you would like to run tfBERT_benchmark for performance comparison,\nplease first install tensorflow C API from https:\u002F\u002Fwww.tensorflow.org\u002Finstall\u002Flang_c.\n\n### Run Unit Test\n\nDownload BERT test model `bert_frozen_seq32.pb` and `vocab.txt` from\n[Dropbox](https:\u002F\u002Fwww.dropbox.com\u002Fsh\u002Fulcdmu9ysyg5lk7\u002FAADndzKXOrHIXLYRc5k60Q-Ta?dl=0), \nand put them under dir `build` before run `make test` or `.\u002FcuBERT_test`.\n\n### Python\n\nWe provide simple Python wrapper by Cython, and it can be built and \ninstalled after C++ building as follows:\n\n```shell\ncd python\npython setup.py bdist_wheel\n\n# install\npip install dist\u002FcuBERT-xxx.whl\n\n# test\npython cuBERT_test.py\n```\n\nPlease check the Python API usage and examples at [cuBERT_test.py](\u002Fpython\u002FcuBERT_test.py)\t\nfor more details.\n\n### Java\n\nJava wrapper is implemented through [JNA](https:\u002F\u002Fgithub.com\u002Fjava-native-access\u002Fjna)\n. After installing maven and C++ building, it can be built as follows:\n\n```shell\ncd java\nmvn clean package # -DskipTests\n```\n\nWhen using Java JAR, you need to specify `jna.library.path` to the \nlocation of `libcuBERT.so` if it is not installed to the system path.\nAnd `jna.encoding` should be set to UTF8 as `-Djna.encoding=UTF8`\nin the JVM start-up script.\n\nPlease check the Java API usage and example at [ModelTest.java](\u002Fjava\u002Fsrc\u002Ftest\u002Fjava\u002Fcom\u002Fzhihu\u002Fcubert\u002FModelTest.java)\nfor more details.\n\n# Install\n\nPre-built python binary package (currently only with MKL on Linux) can\nbe installed as follows:\n\n* Download and install [MKL](https:\u002F\u002Fgithub.com\u002Fintel\u002Fmkl-dnn\u002Freleases)\nto system path.\n\n* Download the wheel package and `pip install cuBERT-xxx-linux_x86_64.whl`\n\n* run `python -c 'import libcubert'` to verify your installation.\n\n# Dependency\n\n### Protobuf\n\ncuBERT is built with [protobuf-c](https:\u002F\u002Fgithub.com\u002Fprotobuf-c\u002Fprotobuf-c) to \navoid version and code conflicting with tensorflow protobuf.\n\n### CUDA\n\nLibraries compiled by CUDA with different versions are not compatible.\n\n### MKL\n\nMKL is dynamically linked. We install both cuBERT and MKL in `sudo make install`.\n\n# Threading\n\nWe assume the typical usage case of cuBERT is for online serving, where\nconcurrent requests of different batch_size should be served as fast as\npossible. Thus, throughput and latency should be balanced, especially in\npure CPU environment.\n\nAs the vanilla [class Bert](\u002Fsrc\u002FcuBERT\u002FBert.h) is not thread-safe\nbecause of its internal buffers for computation, a wrapper [class BertM](\u002Fsrc\u002FcuBERT\u002FBertM.h)\nis written to hold locks of different `Bert` instances for thread safety.\n`BertM` will choose one underlying `Bert` instance by a round-robin\nmanner, and consequence requests of the same `Bert` instance might be\nqueued by its corresponding lock.\n\n### GPU\n\nOne `Bert` is placed on one GPU card. The maximum concurrent requests is\nthe number of usable GPU cards on one machine, which can be controlled\nby `CUDA_VISIBLE_DEVICES` if it is specified.\n\n### CPU\n\nFor pure CPU environment, it is more complicate than GPU. There are 2\nlevel of parallelism:\n\n1. Request level. Concurrent requests will compete CPU resource if the\nonline server itself is multi-threaded. If the server is single-threaded\n(for example some server implementation in Python), things will be much\neasier.\n\n2. Operation level. The matrix operations are parallelized by OpenMP and\nMKL. The maximum parallelism is controlled by `OMP_NUM_THREADS`,\n`MKL_NUM_THREADS`, and many other environment variables. We refer our\nusers to first read [Using Threaded Intel® MKL in Multi-Thread Application](https:\u002F\u002Fsoftware.intel.com\u002Fen-us\u002Farticles\u002Fusing-threaded-intel-mkl-in-multi-thread-application)\n and [Recommended settings for calling Intel MKL routines from multi-threaded applications](https:\u002F\u002Fsoftware.intel.com\u002Fen-us\u002Farticles\u002Frecommended-settings-for-calling-intel-mkl-routines-from-multi-threaded-applications)\n.\n\nThus, we introduce `CUBERT_NUM_CPU_MODELS` for better control of request\nlevel parallelism. This variable specifies the number of `Bert` instances\ncreated on CPU\u002Fmemory, which acts same like `CUDA_VISIBLE_DEVICES` for\nGPU.\n\n* If you have limited number of CPU cores (old or desktop CPUs, or in\nDocker), it is not necessary to use `CUBERT_NUM_CPU_MODELS`. For example\n4 CPU cores, a request-level parallelism of 1 and operation-level\nparallelism of 4 should work quite well.\n\n* But if you have many CPU cores like 40, it might be better to try with\nrequest-level parallelism of 5 and operation-level parallelism of 8.\n\nIn summary, `OMP_NUM_THREADS` or `MKL_NUM_THREADS` defines how many threads\none model could use, and `CUBERT_NUM_CPU_MODELS` defines how many models in\ntotal.\n\nAgain, the per request latency and overall throughput should be balanced,\nand it diffs from model `seq_length`, `batch_size`, your CPU cores, your\nserver QPS, and many many other things. You should take a lot benchmark\nto achieve the best trade-off. Good luck!\n\n# Authors\n\n* fanliwen\n* wangruixin\n* fangkuan\n* sunxian\n","在 NVIDIA（CUDA、CUBLAS）和 Intel MKL 上直接快速实现 BERT 推理\n=====================================================================================\n\n[![构建状态](https:\u002F\u002Ftravis-ci.org\u002Fzhihu\u002FcuBERT.svg?branch=master)](https:\u002F\u002Ftravis-ci.org\u002Fzhihu\u002FcuBERT)\n\n高度定制化且优化的 BERT 推理，直接运行在 NVIDIA（CUDA、CUBLAS）或 Intel MKL 上，*无需* TensorFlow 及其框架开销。\n\n**仅**支持 BERT（Transformer）模型。\n\n# 基准测试\n\n### 环境\n\n* Tesla P4\n* 28 核 Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz\n* Debian GNU\u002FLinux 8 (jessie)\n* gcc (Debian 4.9.2-10+deb8u1) 4.9.2\n* CUDA：版本 9.0，V9.0.176\n* MKL：2019.0.1.20181227\n* tensorflow：1.12.0\n* BERT：序列长度 = 32\n\n### GPU（cuBERT）\n\n|批大小|128（毫秒） |32（毫秒） |\n|---       |---      |---     |\n|tensorflow|255.2    |70.0    |\n|cuBERT    |**184.6**|**54.5**|\n\n### CPU（mklBERT）\n\n|批大小|128（毫秒） |1（毫秒）  |\n|---       |---      |---     |\n|tensorflow|1504.0   |69.9    |\n|mklBERT   |**984.9**|**24.0**|\n\n注意：MKL 应在 `OMP_NUM_THREADS=?` 下运行以控制线程数。其他环境变量及其可能取值包括：\n\n* `KMP_BLOCKTIME=0`\n* `KMP_AFFINITY=granularity=fine,verbose,compact,1,0`\n\n### 混合精度\n\ncuBERT 可以利用 NVIDIA Volta 和 Turing 架构 GPU 上的 [Tensor Core](https:\u002F\u002Fdeveloper.nvidia.com\u002Ftensor-cores) 和 [混合精度计算](https:\u002F\u002Fdevblogs.nvidia.com\u002Ftensor-cores-mixed-precision-scientific-computing) 来加速推理。我们支持将变量存储为 fp16 格式，并以 fp32 进行计算的混合精度模式。与单精度推理相比，典型精度误差小于 1%，而速度则可提升至两倍以上。\n\n# API\n\n[API .h 头文件](\u002Fsrc\u002FcuBERT.h)\n\n### Pooler\n\n我们支持以下两种池化方法：\n\n* 标准 BERT pooler，定义如下：\n\n```python\nwith tf.variable_scope(\"pooler\"):\n  # 我们通过简单地取第一个 token 对应的隐藏状态来“池化”模型。我们假设该模型已预训练过。\n  first_token_tensor = tf.squeeze(self.sequence_output[:, 0:1, :], axis=1)\n  self.pooled_output = tf.layers.dense(\n    first_token_tensor,\n    config.hidden_size,\n    activation=tf.tanh,\n    kernel_initializer=create_initializer(config.initializer_range))\n```\n\n* 简单平均池化器：\n\n```python\nself.pooled_output = tf.reduce_mean(self.sequence_output, axis=1)\n```\n\n### 输出\n\n支持以下输出类型：\n\n|cuBERT_OutputType      |python代码                   |\n|---                    |---                           |\n|cuBERT_LOGITS          |[`model.get_pooled_output() * output_weights + output_bias`](https:\u002F\u002Fgithub.com\u002Fgoogle-research\u002Fbert\u002Fblob\u002Fd66a146741588fb208450bde15aa7db143baaa69\u002Frun_classifier.py#L607)|\n|cuBERT_PROBS           |`probs = tf.nn.softmax(logits, axis=-1)`|\n|cuBERT_POOLED_OUTPUT   |`model.get_pooled_output()`   |\n|cuBERT_SEQUENCE_OUTPUT |`model.get_sequence_output()` |\n|cuBERT_EMBEDDING_OUTPUT|`model.get_embedding_output()`|\n\n# 从源码构建\n\n```shell\nmkdir build && cd build\n# 如果使用 CUDA 构建\ncmake -DCMAKE_BUILD_TYPE=Release -DcuBERT_ENABLE_GPU=ON -DCUDA_ARCH_NAME=Common ..\n# 或者使用 MKL 构建\ncmake -DCMAKE_BUILD_TYPE=Release -DcuBERT_ENABLE_MKL_SUPPORT=ON ..\nmake -j4\n\n# 安装到 \u002Fusr\u002Flocal\n# 如果指定了 -DcuBERT_ENABLE_MKL_SUPPORT=ON，也会同时安装 MKL\nsudo make install\n```\n\n如果您想运行 tfBERT_benchmark 进行性能对比，请先从 https:\u002F\u002Fwww.tensorflow.org\u002Finstall\u002Flang_c 安装 TensorFlow C API。\n\n### 运行单元测试\n\n从 [Dropbox](https:\u002F\u002Fwww.dropbox.com\u002Fsh\u002Fulcdmu9ysyg5lk7\u002FAADndzKXOrHIXLYRc5k60Q-Ta?dl=0) 下载 BERT 测试模型 `bert_frozen_seq32.pb` 和 `vocab.txt`，并将它们放置在 `build` 目录下，然后运行 `make test` 或 `.\u002FcuBERT_test`。\n\n### Python\n\n我们提供了基于 Cython 的简单 Python 封装，可以在 C++ 构建完成后按以下步骤进行构建和安装：\n\n```shell\ncd python\npython setup.py bdist_wheel\n\n# 安装\npip install dist\u002FcuBERT-xxx.whl\n\n# 测试\npython cuBERT_test.py\n```\n\n更多详细信息和 Python API 的使用示例，请参阅 [cuBERT_test.py](\u002Fpython\u002FcuBERT_test.py)。\n\n### Java\n\nJava 封装通过 [JNA](https:\u002F\u002Fgithub.com\u002Fjava-native-access\u002Fjna) 实现。在安装 Maven 并完成 C++ 构建后，可以按以下步骤进行构建：\n\n```shell\ncd java\nmvn clean package # -DskipTests\n```\n\n使用 Java JAR 文件时，如果 `libcuBERT.so` 未安装到系统路径中，需要指定 `jna.library.path` 为该库的路径。此外，应在 JVM 启动脚本中设置 `jna.encoding=UTF8`。\n\n更多关于 Java API 的使用和示例，请参阅 [ModelTest.java](\u002Fjava\u002Fsrc\u002Ftest\u002Fjava\u002Fcom\u002Fzhihu\u002Fcubert\u002FModelTest.java)。\n\n# 安装\n\n预编译的 Python 二进制包（目前仅适用于 Linux 上的 MKL）可以按以下步骤安装：\n\n* 下载并安装 [MKL](https:\u002F\u002Fgithub.com\u002Fintel\u002Fmkl-dnn\u002Freleases) 到系统路径。\n\n* 下载 wheel 包并运行 `pip install cuBERT-xxx-linux_x86_64.whl`。\n\n* 运行 `python -c 'import libcubert'` 以验证安装是否成功。\n\n# 依赖项\n\n### Protobuf\n\ncuBERT 使用 [protobuf-c](https:\u002F\u002Fgithub.com\u002Fprotobuf-c\u002Fprotobuf-c) 构建，以避免与 TensorFlow 的 protobuf 版本和代码发生冲突。\n\n### CUDA\n\n不同版本的 CUDA 编译的库之间不兼容。\n\n### MKL\n\nMKL 是动态链接的。我们在执行 `sudo make install` 时会同时安装 cuBERT 和 MKL。\n\n# 多线程\n\n我们假设 cuBERT 的典型用法是用于在线服务，在这种情况下，需要尽可能快速地处理不同批大小的并发请求。因此，在纯 CPU 环境下，吞吐量和延迟之间需要取得平衡。\n\n由于原生的 [Bert 类](\u002Fsrc\u002FcuBERT\u002FBert.h) 因其内部计算缓冲区而不具备线程安全性，因此我们编写了一个包装类 [BertM 类](\u002Fsrc\u002FcuBERT\u002FBertM.h)，用于为不同的 `Bert` 实例加锁以确保线程安全。`BertM` 会以轮询方式选择一个底层的 `Bert` 实例，因此对同一 `Bert` 实例的后续请求可能会被其对应的锁阻塞排队。\n\n### GPU\n\n每个 `Bert` 实例都部署在一个 GPU 卡上。最大并发请求数等于一台机器上可用的 GPU 数量，可以通过设置 `CUDA_VISIBLE_DEVICES` 来控制。\n\n### CPU\n\n对于纯 CPU 环境，情况比 GPU 更为复杂。并行性可以分为两个层次：\n\n1. 请求级并行：在多线程的在线服务中，并发请求会竞争 CPU 资源。如果服务器是单线程的（例如某些 Python 实现的服务器），则处理起来会简单得多。\n\n2. 操作级并行：矩阵运算由 OpenMP 和 MKL 进行并行化。最大并行度受 `OMP_NUM_THREADS`、`MKL_NUM_THREADS` 以及其他多个环境变量的控制。我们建议用户先阅读 [在多线程应用程序中使用线程化的 Intel® MKL](https:\u002F\u002Fsoftware.intel.com\u002Fen-us\u002Farticles\u002Fusing-threaded-intel-mkl-in-multi-thread-application) 和 [从多线程应用程序调用 Intel MKL 例程的推荐设置](https:\u002F\u002Fsoftware.intel.com\u002Fen-us\u002Farticles\u002Frecommended-settings-for-calling-intel-mkl-routines-from-multi-threaded-applications)。\n\n因此，我们引入了 `CUBERT_NUM_CPU_MODELS`，以便更好地控制请求级并行度。该变量指定了在 CPU\u002F内存上创建的 `Bert` 实例数量，其作用类似于 GPU 上的 `CUDA_VISIBLE_DEVICES`。\n\n* 如果您的 CPU 核心数量有限（例如旧式 CPU、桌面 CPU 或 Docker 容器中），则无需设置 `CUBERT_NUM_CPU_MODELS`。例如，在 4 核 CPU 上，将请求级并行度设为 1、操作级并行度设为 4，通常就能取得不错的效果。\n\n* 但如果您拥有大量 CPU 核心（如 40 核），则可以尝试将请求级并行度设为 5、操作级并行度设为 8。\n\n总之，`OMP_NUM_THREADS` 或 `MKL_NUM_THREADS` 决定单个模型可使用的线程数，而 `CUBERT_NUM_CPU_MODELS` 则决定总的模型数量。\n\n再次强调，每次请求的延迟和整体吞吐量需要权衡，这与模型的序列长度、批大小、CPU 核心数、服务器 QPS 以及许多其他因素有关。您应当进行充分的基准测试，以找到最佳的平衡点。祝您成功！\n\n# 作者\n\n* fanliwen\n* wangruixin\n* fangkuan\n* sunxian","# cuBERT 快速上手指南\n\ncuBERT 是一个高度定制和优化的 BERT 推理引擎，直接基于 NVIDIA CUDA\u002FCUBLAS 或 Intel MKL 实现，**无需依赖 TensorFlow** 及其框架开销，显著提升推理速度并降低延迟。仅支持 BERT (Transformer) 模型。\n\n## 环境准备\n\n### 系统要求\n*   **操作系统**: Linux (推荐 Debian\u002FUbuntu)\n*   **编译器**: GCC 4.9+\n*   **硬件加速**:\n    *   **GPU 方案**: NVIDIA GPU (支持 CUDA 9.0+)，Volta\u002FTuring 架构显卡可开启混合精度加速。\n    *   **CPU 方案**: Intel CPU (需安装 Intel MKL)。\n\n### 前置依赖\n根据选择的加速后端，需安装以下依赖：\n\n1.  **通用依赖**:\n    *   `protobuf-c` (用于避免与 TensorFlow 的 protobuf 版本冲突)\n    *   `cmake`, `make`\n\n2.  **GPU 方案 (cuBERT)**:\n    *   NVIDIA CUDA Toolkit (版本需与编译环境一致，如 9.0)\n    *   CUBLAS\n\n3.  **CPU 方案 (mklBERT)**:\n    *   Intel MKL (Math Kernel Library)\n    *   OpenMP\n\n> **注意**: 若需进行性能对比测试，可额外安装 TensorFlow C API，但运行 cuBERT 本身不需要。\n\n## 安装步骤\n\n### 方式一：源码编译（推荐）\n\n此方法可同时安装 cuBERT 及所需的 MKL 库。\n\n```shell\nmkdir build && cd build\n\n# 选项 A: 编译 GPU 版本 (CUDA)\ncmake -DCMAKE_BUILD_TYPE=Release -DcuBERT_ENABLE_GPU=ON -DCUDA_ARCH_NAME=Common ..\n\n# 选项 B: 编译 CPU 版本 (MKL)\n# cmake -DCMAKE_BUILD_TYPE=Release -DcuBERT_ENABLE_MKL_SUPPORT=ON ..\n\nmake -j4\n\n# 安装到系统目录 (\u002Fusr\u002Flocal)，若选择 MKL 方案也会一并安装 MKL\nsudo make install\n```\n\n### 方式二：Python 预编译包安装 (仅限 Linux + MKL)\n\n如果你只需要在 Python 中使用 CPU 版本：\n\n1.  下载并安装 [Intel MKL](https:\u002F\u002Fgithub.com\u002Fintel\u002Fmkl-dnn\u002Freleases) 到系统路径。\n2.  下载对应的 wheel 包 (`cuBERT-xxx-linux_x86_64.whl`)。\n3.  执行安装：\n\n```shell\npip install cuBERT-xxx-linux_x86_64.whl\n```\n\n4.  验证安装：\n\n```shell\npython -c 'import libcubert'\n```\n\n### 语言绑定构建 (可选)\n\n*   **Python Wrapper**:\n    ```shell\n    cd python\n    python setup.py bdist_wheel\n    pip install dist\u002FcuBERT-xxx.whl\n    ```\n*   **Java Wrapper** (需 Maven):\n    ```shell\n    cd java\n    mvn clean package\n    # 运行时需指定 -Djna.library.path 指向 libcuBERT.so\n    ```\n\n## 基本使用\n\n### 1. 准备模型文件\n下载冻结的 BERT 模型文件 (`bert_frozen_seq32.pb`) 和词表 (`vocab.txt`)。\n*   下载地址：[Dropbox 链接](https:\u002F\u002Fwww.dropbox.com\u002Fsh\u002Fulcdmu9ysyg5lk7\u002FAADndzKXOrHIXLYRc5k60Q-Ta?dl=0)\n*   将文件放置在构建目录或代码可访问的路径下。\n\n### 2. Python 使用示例\n\ncuBERT 提供了简洁的 Cython 封装。以下是加载模型并进行推理的最小化示例：\n\n```python\nimport cubert\n\n# 初始化模型\n# model_path: .pb 模型文件路径\n# vocab_path: vocab.txt 路径\n# seq_length: 序列长度 (需与模型训练时一致，如 32)\n# output_type: 输出类型 (LOGITS, PROBS, POOLED_OUTPUT 等)\nmodel = cubert.Bert(\n    model_path=\"bert_frozen_seq32.pb\",\n    vocab_path=\"vocab.txt\",\n    seq_length=32,\n    output_type=cubert.cuBERT_PROBS \n)\n\n# 准备输入数据 (列表形式)\ntexts = [\"你好，世界\", \"cuBERT 推理速度很快\"]\n\n# 执行推理\n# 返回结果为 numpy 数组\nresults = model.predict(texts)\n\nprint(results)\n```\n\n### 3. 多线程与并发配置 (重要)\n\ncuBERT 专为在线服务设计，针对多线程环境做了特殊优化：\n\n*   **GPU 环境**:\n    每个 `Bert` 实例占用一张显卡。最大并发数等于可用显卡数。可通过 `CUDA_VISIBLE_DEVICES` 控制。\n\n*   **CPU 环境**:\n    需平衡“请求级并行”与“运算级并行”。\n    *   `OMP_NUM_THREADS` \u002F `MKL_NUM_THREADS`: 控制**单个模型**内部矩阵运算使用的线程数。\n    *   `CUBERT_NUM_CPU_MODELS`: 控制创建的**模型实例总数**（即请求级并行度）。\n\n    **配置建议**:\n    *   **少核环境 (如 4 核)**: 设置 `CUBERT_NUM_CPU_MODELS=1`, `OMP_NUM_THREADS=4`。\n    *   **多核环境 (如 40 核)**: 尝试设置 `CUBERT_NUM_CPU_MODELS=5`, `OMP_NUM_THREADS=8`。\n    \n    *请根据实际压测结果调整这两个参数以获得最佳吞吐量和延迟平衡。*\n\n### 4. 混合精度加速 (GPU)\n在 NVIDIA Volta 或 Turing 架构显卡上，cuBERT 自动支持 Tensor Core 混合精度计算（变量存为 fp16，计算用 fp32），通常可获得 2 倍以上加速，精度损失小于 1%。无需额外代码配置，编译时确保开启 CUDA 支持即可。","某电商平台的算法团队需要在高并发场景下，实时对海量用户评论进行情感分析与垃圾内容过滤。\n\n### 没有 cuBERT 时\n- **推理延迟过高**：依赖 TensorFlow 框架运行 BERT 模型，单次请求耗时较长，在流量高峰期导致用户评论审核出现明显积压。\n- **资源浪费严重**：框架本身的开销占用了大量 GPU 显存和计算资源，导致服务器无法部署更多实例，硬件利用率低下。\n- **低延迟场景受限**：在 CPU 环境下处理单条请求时响应缓慢（约 70ms），难以满足即时互动的严苛要求。\n- **混合精度支持复杂**：想要利用 NVIDIA Tensor Core 加速需繁琐配置，且难以在保证精度的前提下实现倍级提速。\n\n### 使用 cuBERT 后\n- **推理速度显著提升**：去除 TensorFlow 冗余开销，直接基于 CUDA\u002FCUBLAS 优化，GPU 批量处理速度提升约 28%，单条处理更快。\n- **硬件成本大幅降低**：更高效的资源占用允许在同等算力下部署更多服务实例，显著降低了服务器扩容成本。\n- **极致低延迟响应**：在 CPU 端利用 MKL 优化后，单条请求耗时从 69.9ms 降至 24.0ms，实现了毫秒级实时反馈。\n- **自动混合精度加速**：原生支持 FP16 存储与 FP32 计算，在误差小于 1% 的前提下，借助 Tensor Core 实现超过 2 倍的加速效果。\n\ncuBERT 通过剥离重型框架依赖并深度优化底层算子，让 BERT 模型在生产环境中实现了极致的推理速度与资源效率。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fzhihu_cuBERT_0c918d47.png","zhihu","Zhihu","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Fzhihu_19b2121c.png","知乎 GitHub 官方帐号 ，欢迎关注我们的技术专栏 https:\u002F\u002Fzhuanlan.zhihu.com\u002Fhackers",null,"jobs+github@zhihu.com","https:\u002F\u002Fzhuanlan.zhihu.com\u002Fhackers","https:\u002F\u002Fgithub.com\u002Fzhihu",[85,89,93,97,101,105],{"name":86,"color":87,"percentage":88},"C++","#f34b7d",80.8,{"name":90,"color":91,"percentage":92},"CMake","#DA3434",6.4,{"name":94,"color":95,"percentage":96},"Python","#3572A5",6.3,{"name":98,"color":99,"percentage":100},"Cuda","#3A4E3A",3.4,{"name":102,"color":103,"percentage":104},"Java","#b07219",2.6,{"name":106,"color":107,"percentage":108},"Dockerfile","#384d54",0.5,548,84,"2026-03-15T14:13:41","MIT",4,"Linux","可选（支持 CPU 模式）。若使用 GPU，需 NVIDIA GPU（基准测试使用 Tesla P4），支持 Volta 和 Turing 架构以启用 Tensor Core 混合精度加速。CUDA 版本需与编译环境一致（基准测试使用 CUDA 9.0）。","未说明",{"notes":118,"python":119,"dependencies":120},"1. 该工具不依赖 TensorFlow，直接基于 CUDA\u002FCUBLAS 或 Intel MKL 实现 BERT 推理。\n2. 仅支持 BERT (Transformer) 模型。\n3. CPU 模式下需通过环境变量（如 OMP_NUM_THREADS, CUBERT_NUM_CPU_MODELS）精细调整线程数以平衡延迟和吞吐量。\n4. 预编译的 Python 包目前仅支持 Linux 且基于 MKL。\n5. 多线程安全性通过内部的 BertM 类包装器实现，采用轮询方式分配模型实例。","未说明（提供 Cython 封装，需自行构建 wheel）",[121,122,123,90,124,125,126,127],"CUDA (可选，版本需匹配)","Intel MKL (可选，用于 CPU 加速)","protobuf-c","GCC","OpenMP","Cython (Python 绑定)","JNA (Java 绑定)",[26,13],[130,131,132,133,134,135,136,137],"tensorflow","bert","cuda","mkl","deep-learning","inference","predict","transformer","2026-03-27T02:49:30.150509","2026-04-06T08:40:43.989798",[141,146,151,156,161,166,171],{"id":142,"question_zh":143,"answer_zh":144,"source_url":145},9815,"从源码构建时遇到 CUDA 或 TensorFlow 相关报错怎么办？","如果是 CUDA 9.0 版本，必须安装后续的补丁（Patch 1-4），否则可能导致编译失败。下载地址：https:\u002F\u002Fdeveloper.nvidia.com\u002Fcuda-90-download-archive。此外，如果提示找不到 TensorFlow，请确保已正确安装 TensorFlow 并设置了相应的库路径和头文件路径。为了简化环境配置，也可以直接使用官方提供的 Docker 镜像：docker pull levyfan\u002Fcubert。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F53",{"id":147,"question_zh":148,"answer_zh":149,"source_url":150},9816,"如何在 CPU 上运行 cuBERT（默认似乎只支持 GPU 或半精度）？","若要在 CPU 上运行，需要修改 benchmark 代码中的数据类型和计算类型配置。具体步骤如下：\n1. 将 `benchmark\u002Fbenchmark_cu.cpp` 第 8 行的 `typedef half Dtype;` 改为 `typedef float Dtype;`。\n2. 将第 11 行的计算类型改为 `cuBERT_ComputeType compute_type = cuBERT_COMPUTE_FLOAT;`。\n3. 如果运行自己的模型，还需根据模型输出调整 `output_type` 并为输出数组分配足够的内存空间。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F8",{"id":152,"question_zh":153,"answer_zh":154,"source_url":155},9817,"Java 调用 compute 方法多次后导致 JVM 崩溃或输出维度不对怎么办？","这通常是因为输出数组 `Float[] output` 的长度设置不正确。示例代码中使用的预训练模型 `bert_frozen_seq32.pb` 是在 `num_labels=1` 的情况下训练的，因此输出长度为 2（对应正负类）。如果您使用的是其他分类任务（`num_labels != 1`），必须手动将 `Float[] output` 的长度修改为对应的类别数量，否则会导致内存越界从而引发 JVM 崩溃。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F32",{"id":157,"question_zh":158,"answer_zh":159,"source_url":160},9818,"cuBERT 是否支持多分类任务？为什么预测结果与 TensorFlow 不一致？","支持多分类。如果发现使用 `cuBERT_LOGITS` 输出的结果与 TensorFlow 不一致，早期版本可能存在一个 Bug：在计算输出时少乘了 `num_labels`（类别数），导致数据拷贝错误。该问题已在后续更新中修复。如果您遇到此问题，请确保拉取了最新代码，或者检查源码中 `Bert.cpp` 关于输出维度的计算逻辑是否正确处理了 `num_labels`。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F17",{"id":162,"question_zh":163,"answer_zh":164,"source_url":165},9819,"推理结果不稳定或存在随机波动是什么原因？","结果不稳定通常是由于代码中某些层未正确调用 `_pre_compute` 导致的异步执行问题。在 cuBERT 中，`_pre_compute` 用于将 GPU 操作发送出去并立即返回（非阻塞），以缩短响应时间。如果遗漏调用，可能导致数据竞争或未就绪读取。该问题已在 PR #24 中修复，确保所有相关层都调用了 `additional_output_layer._pre_compute` 即可解决。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F21",{"id":167,"question_zh":168,"answer_zh":169,"source_url":170},9820,"如何提取 BERT 的倒数第二层隐藏状态（second-to-last hidden layer）作为特征？","可以通过传递 `num_hidden_layers` 参数来控制输出的层数。对于标准的 BERT-Base 模型，倒数第二层对应的层索引是 11；对于 BERT-Large 模型，则是 23。在 FAQ 匹配等任务中，使用倒数第二层往往比最后一层效果更好。您可以参考 bert-as-service 的相关文档进行配置。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F25",{"id":172,"question_zh":173,"answer_zh":174,"source_url":175},9821,"多个 Bert 实例是否共享 Embedding 表以节省内存？","默认情况下，每个 Bert 实例会独立分配内存（包括 Embedding 表和内部 OP 的输入输出 Buffer），其中 Buffer 的大小由 `max_batch_size` 决定。虽然共享模型参数（如 Embedding 表）在技术上可行且能节省内存（例如将裸指针改为智能指针 `std::shared_ptr`），但维护者认为在现代大内存服务器环境下，这部分内存开销（约几百兆）并不显著。此外，每个线程独享实例的无锁模式可能会放弃 OpenMP\u002FMKL 的并行优势并增加延迟，因此目前未作为默认实现。","https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F27",[177,181,185,189,194],{"id":178,"version":179,"summary_zh":80,"released_at":180},116851,"v0.0.5","2019-12-27T02:19:19",{"id":182,"version":183,"summary_zh":80,"released_at":184},116852,"v0.0.4","2019-12-18T10:11:54",{"id":186,"version":187,"summary_zh":80,"released_at":188},116853,"v0.0.3","2019-08-16T09:06:39",{"id":190,"version":191,"summary_zh":192,"released_at":193},116854,"v0.0.2","Fix Issues:\r\n* https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F17\r\n* https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F21\r\n* https:\u002F\u002Fgithub.com\u002Fzhihu\u002FcuBERT\u002Fissues\u002F22\r\n\r\nThanks @xuqiang for contributing.","2019-06-05T03:39:06",{"id":195,"version":196,"summary_zh":80,"released_at":197},116855,"v0.0.1","2019-05-27T08:15:27"]