[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-JasperSnoek--spearmint":3,"tool-JasperSnoek--spearmint":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 真正成长为懂上",157379,2,"2026-04-15T23:32:42",[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":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":75,"owner_company":75,"owner_location":75,"owner_email":75,"owner_twitter":75,"owner_website":75,"owner_url":76,"languages":77,"stars":107,"forks":108,"last_commit_at":109,"license":75,"difficulty_score":110,"env_os":111,"env_gpu":112,"env_ram":112,"env_deps":113,"category_tags":120,"github_topics":75,"view_count":32,"oss_zip_url":75,"oss_zip_packed_at":75,"status":17,"created_at":122,"updated_at":123,"faqs":124,"releases":160},7960,"JasperSnoek\u002Fspearmint","spearmint","Spearmint is a package to perform Bayesian optimization according to the algorithms outlined in the paper:  Practical Bayesian Optimization of Machine Learning Algorithms. Jasper Snoek, Hugo Larochelle and Ryan P. Adams.  Advances in Neural Information Processing Systems, 2012 ","Spearmint 是一款基于贝叶斯优化算法的开源工具，旨在帮助用户以最高的效率寻找机器学习模型或其他复杂系统的最佳参数配置。它核心解决的是“调参难、成本高”的问题：在传统方法需要大量试错实验的情况下，Spearmint 能够智能地迭代调整参数，用尽可能少的实验次数找到目标函数的最小值，从而大幅节省计算资源和时间。\n\n这款工具特别适合机器学习研究人员、数据科学家以及需要优化复杂实验流程的开发者使用。无论是单机环境还是集群部署，Spearmint 都能自动管理实验的启动与记录。其技术亮点在于模块化设计，支持多种采集函数（如期望改进、UCB 等），并提供两种运行模式：完整版可自动封装并执行代码实验；轻量版（Spearmint-lite）则通过文件交互提出建议，允许用户手动执行实验（甚至适用于非代码类实验），提供了极高的灵活性。\n\n需要注意的是，当前仓库主要处于维护状态，核心团队已转向开发功能更强大的新版本（采用非商业许可），但现有版本依然稳定可用，尤其适合希望免费使用且熟悉 Python 2.7 环境的用户。","New code repository!\nAs you might have noticed, the development of this repository has been limited to maintenance and bug fixes for some time now.  The reason is that there has been a collaborative effort to overhaul Spearmint into a new codebase.  This includes both algorithmic\u002Ftheoretical and engineering improvements.  Check it out at https:\u002F\u002Fgithub.com\u002FHIPS\u002FSpearmint.  Note that the new repository is under a non-commercial license with a contributor license agreement.  If you prefer not to agree to the license, you can freely use code here (though it is a bit older).\n\nSpearmint\n---------\n\nSpearmint is a package to perform Bayesian optimization according to the\nalgorithms outlined in the paper:  \n\n**Practical Bayesian Optimization of Machine Learning Algorithms**  \nJasper Snoek, Hugo Larochelle and Ryan P. Adams  \n*Advances in Neural Information Processing Systems*, 2012  \n\nThis code is designed to automatically run experiments (thus the code\nname 'spearmint') in a manner that iteratively adjusts a number of\nparameters so as to minimize some objective in as few runs as\npossible.\n\nSpearmint is the result of a collaboration primarily between machine learning researchers at [Harvard University](https:\u002F\u002Fhips.seas.harvard.edu\u002F) and the [University of Toronto](http:\u002F\u002Flearning.cs.toronto.edu\u002F).\n\nDependencies\n------------\nThis package requires:\n\n* Python 2.7\n\n* [Numpy](http:\u002F\u002Fwww.numpy.org\u002F) version 1.6.1+\nOn Ubuntu linux you can install this package using the command:\n\n\t\tapt-get install python-numpy\n\n* [Scipy](http:\u002F\u002Fwww.scipy.org\u002F) version 0.9.0+\nOn Ubuntu linux you can install this package using the command:\n\n\t\tapt-get install python-scipy\n\n* [Google Protocol Buffers](https:\u002F\u002Fdevelopers.google.com\u002Fprotocol-buffers\u002F) (for the fully automated code).\nNote that you should be able to install protocol-buffers from source without requiring administrator privileges.  Otherwise, on Ubuntu linux you can install this package using the command:\n\n\t\tapt-get install python-protobuf\n\t\t\t\t\t\t\n\tand on Mac (if you use homebrew) with:\n\n\t\tbrew install protobuf\n\n\tThen from within the spearmint sub-directory run the command:\n\n\t\tbin\u002Fmake_protobufs\n\nThis package has been tested on Ubuntu linux (versions 11.0+) and\nMac-OSX.\n\nThe code consists of several parts.  It is designed to be modular to\nallow swapping out various 'driver' and 'chooser' modules.  The\n'chooser' modules are implementations of acquisition functions such as\nexpected improvement, UCB or random.  The drivers determine how\nexperiments are distributed and run on the system.  As the code is\ndesigned to run experiments in parallel (spawning a new experiment as\nsoon a result comes in), this requires some engineering.  The current\nimplementations of these are in the 'spearmint' and 'spearmint-lite' subdirectories:\n\n**Spearmint** is designed to automatically manage the launching and associated bookkeeping \nof experiments in either a single machine or cluster environment.  This requires that you provide\na 'wrapper' in a supported language (currently Python or Matlab) and a configuration file detailing parameters\nto be tuned and their respective bounds. The wrapper must accept parameter values and then return simply a value which you wish to minimize with respect to the parameters. Spearmint will then iteratively call the wrapper with different \nparameter settings in an order that seeks to find the minimum value in as few evaluations (or cost) as possible.\n\n**Spearmint-lite** is the 'bare-bones' stripped version of the code.\nThis version is simply driven by a flat-file and does not\nautomatically run experiments.  Instead, it proposes new experiments\n(potentially multiple at a time) and requires that the user fill in\nthe result.  This is well suited to the case where writing a wrapper\naround the code doesn't make sense (e.g. if the experiments don't\ninvolve code at all) or if the user desires full control of the\nprocess.  Also, the dependency on Google protocol buffers is replaced\nwith JSON.\n\nRunning the automated code: Spearmint\n--------------------------------------------------------\n\nThe simplest way to get to know the code is probably to look at an\nexample.  In order to start a new experiment, you must create a directory \nthat includes a wrapper script and config file.\nWe have created one simple example for you that optimizes the\n'Braninhoo' benchmark in the subdirectory **examples\u002Fbraninpy**.  Take a look at\n**config.pb**.  It contains the specifications of the algorithm in\nprotocol buffer format.  In order to specify your optimization, you\nhave to fill in the variables 'language' (e.g. PYTHON or MATLAB) and\n'name' (the name of the wrapper function you want to optimize).\n\nFollowed by these is a list of 'variables', which specifies the name,\ntype and size of the variables you wish to optimize over.  Each\nvariable must be either a FLOAT, INT or ENUM type, corresponding to\ncontinuous real valued parameters, integer sequences and categorical\nvariables respectively.  MAX and MIN specify the bounds of the\nvariables over which to optimize and SIZE is the number of variables\nof this type with these bounds.  Spearmint will call your wrapper\nfunction with a dictionary type (in python) containing each of your\nvariables in a vector of size 'size', which you can access using the\nname specified.  \n\nNow take a look at branin.py (the wrapper which was\nspecified in the 'name' variable at the top of config.pb).  You will\nsee the file has a function 'main(job_id, params)'.  Your wrapper must\ninclude this function, which spearmint will call passing in a job_id\n(which is probably not interesting to you) and a dictionary, 'params',\ncontaining the parameter vectors of the next experiment spearmint\nwants to run.  The main function should take as input these parameters\nand return a single real valued number representing the observed\nfunction value (that is being optimized) at these inputs.\n\nTo install spearmint, go into the spearmint subdirectory and type (most likely preceded with 'sudo'):\n\n\tpython setup.py install\n\nYou should add the spearmint subdirectory to your PYTHONPATH directory.  Note that you can often avoid the above step, but may have to add all the relevant modules to your PYTHONPATH and call spearmint directory from the directory using main.py.\n\nTo run spearmint, go into the **\u002Fbin** subdirectory and type:\n\n\t.\u002Fspearmint ..\u002Fexamples\u002Fbraninpy\u002Fconfig.pb --driver=local --method=GPEIOptChooser --method-args=noiseless=1\n\nor alternatively in the **\u002Fspearmint** subdirectory:\n\n\tpython main.py --driver=local --method=GPEIOptChooser --method-args=noiseless=1 ..\u002Fexamples\u002Fbraninpy\u002Fconfig.pb\n\nThis will run spearmint according to the GP-EI MCMC strategy.  The code will sequentially spawn\nprocesses that call the wrapper function and it will poll for results.\nYou will see that the code prints out the current best (i.e. lowest)\nobservation seen thus far and sequences of numbers corresponding to GP\nhyperparameter samples and candidates it is optimizing over.  The\n'method' argument specifies the chooser module (acquisition function)\nto use and 'method-args' specifies chooser specific arguments.  In\nthis case, as braninhoo is an analytic function we tell the GP\nhyperparameter sampling routine to not try to estimate noise.  This parameter is very important to specify correctly for the optimization to proceed properly.  If your algorithm is entirely deterministic (e.g. analytic) then specifying that it is noiseless will speed up the optimization considerably.  If your algorithm is not deterministic, as we expect for most machine learning algorithms and indeed most expensive experiments, then you should leave this out or set noiseless=0.\n\nIf you let it run for a while you will see that the current-best\ndecreases, eventually reaching the minimum at ~0.39. You can kill the\nprocess (ctrl-c) at any time and you can restart from where it left off simply\nby rerunning the spearmint command.\n\nIf you go back in to the braninpy directory you will see a number of\nnew files that spearmint uses to do bookkeeping.  Of particular\ninterest are **trace.csv** and the **output** directory.  **trace.csv**\ncontains a record of the experiments run so far and the best result\n(and which experiment it came from) as a series over time.  Each line\nof trace.csv contains the following in csv format: a timestamp, the\nbest value observed up to that timestamp, the job-id of the best value\nobserved, the number of potential candidates left, the number of\npending (currently running) experiments, the number of experiments\ncompleted thus far.  The output directory contains a text file for\neach job-id, containing the output of that job.  So if you want to\nsee, e.g. what the output (i.e. standard out and standard error) was\nfor the best job (as obtained from trace.csv) you can look up\njob-id.txt in the output directory. \n\n If you are debugging your code,\nor the code is crashing for some reason, it's a good idea to look at\nthese files. Finally for ease of use, spearmint also prints out at\neach iteration a file called 'best_job_and_result.txt' that contains the\nbest result observed so far, the job-id it came from and a dump of \nthe names and values of all of the parameters corresponding to that result.\n\nA script, bin\u002Fcleanup, is provided to completely restart an experiment\nand delete all the results and intermediate files.  Simply run\n`bin\u002Fcleanup \u003Cexperiment_dir>`\n\nMatlab code can also be optimized using this package. To do so, you\nmust specify in config.pb \"type: Matlab\" and use a matlab wrapper with\nthe \"name\" specified in config.pb.  The matlab wrapper must have a\nfunction with the same name as the file name of the following form:\n\"function result = braninhoo(job_id, params)\" Above we assume the file\nname is \"braninhoo.m\".  Spearmint will pass in to this wrapper a\njob_id and a matlab struct 'params' where the fields are given by the\nvariables specified in config.pb.  See the subdirectory \"braninhoo\"\nfor a matlab example matching that of python 'braninpy' described\nabove.\n\nTo run multiple jobs in parallel, pass to spearmint the argument:\n`--max-concurrent=\u003C#jobs>`\n\nSpearmint is designed to be run in parallel either using multiple processors on a single machine or in a cluster environment.  These different environments, however, involve different queuing and fault-checking code and are thus coded as 'driver' modules.  Currently two drivers are available, but one can easily create a driver for a different environment by creating a new driver module (see the driver subdirectory for examples).\n\nUsing the `--driver=sge` flag, Spearmint can run on a system with Sun Grid Engine and it uses SGE to distribute experiments on a multi-node cluster in parallel using a queueing system in a fault-tolerant way.  It is particularly\nwell suited to the Amazon EC2 system.  Using [StarCluster](http:\u002F\u002Fstar.mit.edu\u002Fcluster\u002F) will allow you to set up a large cluster and start distributing experiments within minutes.\n\nUsing the `--driver=local` flag will run Spearmint on a single machine with potentially many cores.  This driver simply spawns a new process on the current machine to run a new experiment.  This does not allow you to distribute across multiple machines, however.\n\n### Web Status Page\nRunning spearmint with the flag `-w` will spawn a local web server that will display useful info and statistics about your optimization run in a much more interpretable and intuitive interface than the command line.  Spearmint will provide a link to the status page that you can simply paste into a browser window.\n\n\nRunning the basic code: Spearmint-lite \n---------------------------------------\n\nSpearmint-lite is designed to be simple.  To run an experiment in\nspearmint-lite, create a subdirectory as explained above.  Again, the\nbraninpy directory is provided as a demonstration.  In this case, the\nexperiment specification, which must be provided in config.json, is in\nJSON format.  You must specify your problem as a sequence of JSON\nobjects.  As in the protocol buffer format above, each object must\nhave a name, a type (float, int or enum), a 'min', a 'max' and a\n'size'. Nothing else needs to be specified.  \n\nGo back to the top-level directory and run: \n\n\tpython spearmint-lite.py braninpy\n\nSpearmint-lite will run one iteration of Bayesian\noptimization and write out to a file named results.dat in the braninpy\nsubdirectory.  results.dat will contain a white-space delimited line\nfor each experiment, of the format: \n`\u003Cresult> \u003Ctime-taken> \u003Clist of parameters in the same order as config.json>`\n\nSpearmint will propose new experiments and append them to results.dat each \ntime it is run. Each proposed experiment will have a 'pending' result and \ntime-taken, indicated by the letter P. The user must then run the experiment \nand fill in these values. Note that the time can safely be set to an arbitrary\nvalue if the chooser module does not use it (only GPEIperSecChooser currently \ndoes). Spearmint will condition on the pending experiments when proposing new \nones, so any number of experiments can be conducted in parallel.\n\nA script, **cleanup.sh**, is provided to completely clean up all the intermediate\nfiles and results in an experimental directory and restart the\nexperiment from scratch.\n\nChooser modules:\n--------------- \n\nThe chooser modules implement functions that tell spearmint which next\njob to run.  Some correspond to 'acquisition functions' in the\nBayesian optimization literature.  Spearmint takes as an argument\n`--method=ChooserModule` which allows one to easy swap out acquisition\nfunctions. Choosers may optionally include parameters that can be\npassed to spearmint using the argument\n`--method-args=argument1,argument2,etc`.  These include, for example, the\nnumber of GP hyperparameter samples to use. See the comments in\nchooser files for chooser dependent arguments.  Below are described\nthe choosers provided in this package:\n\n* **SequentialChooser:** Chooses the next experiment using a high\ndiscrepancy Sobol sequence.  Experiments are taken sequentially from a\ncoarse-to-fine grid.\n\n* **RandomChooser**: Experiments are sampled randomly from the unit hypercube.\n\n* **GPEIOptChooser:** The GP EI MCMC algorithm from the paper. Jobs \nare first sampled densely from a dense grid on the unit hypercube\nand then the best candidates are optimized 'fine-tuned' according\nto EI.\n\n* **GPEIperSecChooser:** The GP EI per Second algorithm from the paper.\nSimilar to GPEIOptChooser except points are optimized and evaluated\nbased on the EI per Second criterion, where each job is weighted\nby the expected running time of the experiment.\n\n* **GPEIChooser:** Points are densely sampled on the unit hypercube and the\nbest is returned according to the EI criterion.  This is considerably\nfaster than the GPEIOptChooser and works well in low-dimensional cases\nwhere the grid covers the search space densely.\n\n**IMPORTANT!**\n\nWhen estimating noise, the Gaussian process prior over noise assumes\nthat the noise level is 'low' (e.g. between -1 to 1). If this is not\nthe case, make sure to rescale your function to make this true\n(e.g. to approximately be between -1 and 1).  Otherwise, the algorithm\nwill find a bad high-noise mode that will result in bad performance.\n","新的代码仓库！\n正如你可能已经注意到的那样，这个仓库的开发在一段时间内仅限于维护和修复 bug。原因是大家正在共同努力，将 Spearmint 重构为一个新的代码库。这包括算法\u002F理论层面以及工程实现上的改进。你可以在 https:\u002F\u002Fgithub.com\u002FHIPS\u002FSpearmint 上查看新仓库。请注意，新仓库采用非商业许可，并要求签署贡献者许可协议。如果你不愿意接受该许可，仍然可以自由使用这里的代码（尽管它稍显陈旧）。\n\nSpearmint\n---------\n\nSpearmint 是一个用于执行贝叶斯优化的软件包，其算法基于以下论文：\n\n**机器学习算法的实用贝叶斯优化**  \nJasper Snoek, Hugo Larochelle 和 Ryan P. Adams  \n*神经信息处理系统进展*, 2012  \n\n该代码旨在以自动化的实验方式运行（因此得名“spearmint”），通过迭代调整多个参数，在尽可能少的试验次数内最小化某个目标函数。\n\nSpearmint 是由 [哈佛大学](https:\u002F\u002Fhips.seas.harvard.edu\u002F) 和 [多伦多大学](http:\u002F\u002Flearning.cs.toronto.edu\u002F) 的机器学习研究人员合作开发的成果。\n\n依赖项\n------------\n本软件包需要以下依赖：\n\n* Python 2.7\n\n* [Numpy](http:\u002F\u002Fwww.numpy.org\u002F) 版本 1.6.1+\n在 Ubuntu Linux 上，你可以使用以下命令安装该包：\n\n\t\tapt-get install python-numpy\n\n* [Scipy](http:\u002F\u002Fwww.scipy.org\u002F) 版本 0.9.0+\n在 Ubuntu Linux 上，你可以使用以下命令安装该包：\n\n\t\tapt-get install python-scipy\n\n* [Google Protocol Buffers](https:\u002F\u002Fdevelopers.google.com\u002Fprotocol-buffers\u002F)（用于完全自动化版本）。\n请注意，你应该能够从源码编译安装 protocol-buffers，而无需管理员权限。否则，在 Ubuntu Linux 上，你可以使用以下命令安装该包：\n\n\t\tapt-get install python-protobuf\n\t\t\t\t\t\t\n而在 Mac 上（如果你使用 homebrew），则可以使用：\n\n\t\tbrew install protobuf\n\n然后在 spearmint 子目录下运行以下命令：\n\n\t\tbin\u002Fmake_protobufs\n\n本软件包已在 Ubuntu Linux（11.0 及以上版本）和 Mac OS X 上进行过测试。\n\n该代码由多个部分组成。它被设计为模块化结构，允许替换不同的“驱动器”和“选择器”模块。“选择器”模块实现了诸如期望改进、UCB 或随机等采集函数。“驱动器”则决定了实验如何在系统上分布和运行。由于该代码旨在并行运行实验（一旦有结果就立即启动新实验），因此需要一定的工程实现。目前的实现位于“spearmint”和“spearmint-lite”子目录中：\n\n**Spearmint** 旨在自动管理单机或集群环境中的实验启动及相应记录工作。为此，你需要提供一种受支持的语言（当前为 Python 或 Matlab）的“包装器”，以及一个配置文件，详细说明待调优的参数及其取值范围。包装器必须接受参数值，并返回一个你希望针对这些参数最小化的数值。Spearmint 将以一种寻求用最少评估次数（或成本）找到最小值的顺序，反复调用包装器，尝试不同的参数设置。\n\n**Spearmint-lite** 是代码的精简版。\n此版本仅通过一个平面文件驱动，不会自动运行实验。相反，它会提出新的实验方案（可能一次提出多个），并要求用户填写实验结果。这非常适合那些不适合编写包装器的情况（例如，实验根本不涉及代码），或者用户希望对整个过程拥有完全控制权的情形。此外，对 Google protocol buffers 的依赖也被 JSON 替代。\n\n运行自动化代码：Spearmint\n--------------------------------------------------------\n\n了解该代码最简单的方式可能是先看一个示例。要开始一项新实验，你需要创建一个包含包装器脚本和配置文件的目录。\n我们为你准备了一个简单的示例，用于优化 **examples\u002Fbraninpy** 子目录下的“Braninhoo”基准测试。请查看 **config.pb** 文件。它以 protocol buffer 格式包含了算法的规范。为了指定你的优化任务，你需要填写 “language”（例如 PYTHON 或 MATLAB）和 “name”（即你要优化的包装器函数名称）这两个变量。\n\n接下来是一份“variables”列表，指定了你希望优化的变量名称、类型和数量。每个变量必须是 FLOAT、INT 或 ENUM 类型，分别对应连续实值参数、整数序列和分类变量。MAX 和 MIN 指定了优化变量的取值范围，而 SIZE 则表示具有这些范围和类型的变量数量。Spearmint 将以字典形式调用你的包装器函数，其中包含按“size”大小排列的各变量值，你可以通过指定的名称来访问它们。\n\n现在请查看 branin.py（即 config.pb 顶部 “name” 变量中指定的包装器）。你会看到该文件包含一个函数 “main(job_id, params)”。你的包装器必须包含此函数，Spearmint 会在调用时传入一个 job_id（对你来说可能并不重要）和一个名为 “params”的字典，其中包含了 Spearmint 计划运行的下一次实验的参数向量。主函数应接收这些参数，并返回一个代表在这些输入下观测到的目标函数值的实数。\n\n要安装 Spearmint，请进入 spearmint 子目录并输入以下命令（通常需要加上 sudo）：\n\n\tpython setup.py install\n\n你应该将 spearmint 子目录添加到你的 PYTHONPATH 环境变量中。需要注意的是，你有时可以省略上述步骤，但可能需要手动将所有相关模块添加到 PYTHONPATH，并通过 main.py 从该目录调用 spearmint。\n\n要运行 Spearmint，请进入 **\u002Fbin** 子目录并输入以下命令：\n\n\t.\u002Fspearmint ..\u002Fexamples\u002Fbraninpy\u002Fconfig.pb --driver=local --method=GPEIOptChooser --method-args=noiseless=1\n\n或者在 **\u002Fspearmint** 子目录中运行：\n\n\tpython main.py --driver=local --method=GPEIOptChooser --method-args=noiseless=1 ..\u002Fexamples\u002Fbraninpy\u002Fconfig.pb\n\n这将以 GP-EI MCMC 策略运行 Spearmint。代码将依次启动调用包装函数的进程，并轮询结果。\n\n你会看到，代码会打印出当前已知的最佳（即最低）观测值，以及与高斯过程超参数采样和待优化候选点相关的数字序列。“method”参数指定了要使用的采集函数模块，“method-args”则用于传递该采集函数特有的参数。在本例中，由于 Branin 函数是解析函数，我们告诉高斯过程超参数采样过程不要尝试估计噪声。正确设置这一参数对于优化的顺利进行至关重要。如果你的算法是完全确定性的（例如解析函数），那么将其指定为无噪声将显著加快优化速度。然而，如果你的算法并非确定性（正如大多数机器学习算法及昂贵实验通常所具备的特性），则应省略此参数或将其设为 noiseless=0。\n\n让程序运行一段时间后，你会发现当前最佳值逐渐下降，最终达到约 0.39 的最小值。你可以随时通过 Ctrl+C 来终止进程，并且只需重新运行 Spearmint 命令即可从上次中断的地方继续执行。\n\n回到 braninpy 目录，你会看到 Spearmint 生成的若干新文件，用于记录和管理优化过程。其中值得关注的是 trace.csv 文件和 output 目录。“trace.csv”记录了迄今为止所有运行过的实验及其最佳结果（以及该结果对应的实验编号），按时间顺序排列。文件的每一行以 CSV 格式包含以下信息：时间戳、截至该时间戳的最佳观测值、对应的最佳观测值的作业 ID、剩余的潜在候选点数量、正在运行（未完成）的实验数量，以及已完成的实验总数。output 目录则为每个作业 ID 保存了一个文本文件，内容是该作业的输出（标准输出和标准错误）。因此，如果你想查看最佳作业的输出（如 trace.csv 所示），只需在 output 目录中查找对应的 job-id.txt 文件即可。\n\n如果你正在调试代码，或者代码因某种原因崩溃，查看这些文件将非常有帮助。此外，为了方便起见，Spearmint 每次迭代还会生成一个名为 best_job_and_result.txt 的文件，其中包含当前最佳结果、其对应的作业 ID，以及与该结果相关的所有参数名称和取值的完整列表。\n\n我们还提供了一个名为 bin\u002Fcleanup 的脚本，用于彻底重启一次实验并删除所有结果及中间文件。只需运行 `bin\u002Fcleanup \u003Cexperiment_dir>` 即可。\n\nMatlab 代码同样可以使用本工具包进行优化。为此，你需要在 config.pb 文件中指定 “type: Matlab”，并使用一个与 config.pb 中“name”字段一致的 Matlab 包装函数。该包装函数必须定义一个与文件名相同的函数，格式如下：“function result = braninhoo(job_id, params)”。上述示例假设文件名为 “braninhoo.m”。Spearmint 将向该包装函数传递一个作业 ID 和一个名为 “params”的 Matlab 结构体，其字段由 config.pb 中指定的变量决定。有关与上述 Python 示例 brinapy 对应的 Matlab 示例，请参阅 braninhoo 子目录。\n\n若需并行运行多个作业，可在运行 Spearmint 时添加参数：`--max-concurrent=\u003C#jobs>`。\n\nSpearmint 设计为可在单机多核处理器或多节点集群环境中并行运行。不过，不同环境需要不同的任务队列管理和故障检测机制，因此分别以“驱动器”模块的形式实现。目前提供了两种驱动器模块，用户也可以根据特定环境的需求轻松开发新的驱动器模块（请参阅驱动器子目录中的示例）。\n\n通过使用 `--driver=sge` 参数，Spearmint 可以在配备 Sun Grid Engine 的系统上运行，并利用 SGE 的队列机制，在多节点集群上以容错方式并行分配实验任务。该模式尤其适用于 Amazon EC2 环境。结合 [StarCluster](http:\u002F\u002Fstar.mit.edu\u002Fcluster\u002F) 工具，你可以在几分钟内搭建一个大型集群并开始分配实验任务。\n\n而使用 `--driver=local` 参数，则可在单台具有多核处理器的机器上运行 Spearmint。该驱动器会在当前机器上直接启动新进程来执行新实验。不过，这种方式无法实现跨多台机器的任务分配。\n\n### 网页状态页面\n使用标志 `-w` 运行 Spearmint 会启动一个本地 Web 服务器，该服务器将以比命令行界面更加易懂和直观的方式显示有关优化运行的有用信息和统计数据。Spearmint 将提供一个指向状态页面的链接，您可以直接将其粘贴到浏览器窗口中。\n\n\n运行基础代码：Spearmint-lite \n---------------------------------------\n\nSpearmint-lite 的设计旨在简单易用。要在 spearmint-lite 中运行实验，请按照上述说明创建一个子目录。同样地，braninpy 目录被用作演示示例。在这种情况下，必须以 JSON 格式在 config.json 文件中提供实验规范。您需要将问题表示为一系列 JSON 对象。与上述 Protocol Buffers 格式一样，每个对象都必须包含名称、类型（浮点数、整数或枚举）、最小值、最大值和大小。除此之外无需再指定其他内容。\n\n返回顶级目录并运行：\n\n\tpython spearmint-lite.py braninpy\n\nSpearmint-lite 将执行一次贝叶斯优化迭代，并将结果写入 braninpy 子目录下的 results.dat 文件中。results.dat 文件中的每一行都由空格分隔，格式如下：\n\n`\u003C结果> \u003C耗时> \u003C参数列表，顺序与 config.json 中一致>`\n\n每次运行 Spearmint 时，它都会提出新的实验并将其追加到 results.dat 文件中。每个新提出的实验都会有一个标记为“pending”的结果和耗时，用字母 P 表示。用户随后需要执行该实验并填写这些值。请注意，如果选择器模块不使用耗时信息（目前只有 GPEIperSecChooser 使用），则可以安全地将耗时设置为任意值。Spearmint 在提出新实验时会基于待处理的实验进行条件判断，因此可以并行进行任意数量的实验。\n\n此外，还提供了一个脚本 **cleanup.sh**，用于彻底清理实验目录中的所有中间文件和结果，并从头开始重新启动实验。\n\n选择器模块：\n--------------- \n\n选择器模块实现了用于指示 Spearmint 下一步应运行哪个任务的功能。其中一些对应于贝叶斯优化文献中的“采集函数”。Spearmint 接受 `--method=ChooserModule` 参数，允许轻松切换不同的采集函数。选择器还可以选择性地包含一些参数，这些参数可以通过 `--method-args=argument1,argument2,etc` 参数传递给 Spearmint。例如，这些参数可能包括要使用的高斯过程超参数样本数量。有关特定选择器的参数说明，请参阅选择器文件中的注释。以下是本软件包中提供的选择器模块描述：\n\n* **SequentialChooser:** 使用高差异性的 Sobol 序列选择下一个实验。实验按从粗到细的网格顺序依次进行。\n\n* **RandomChooser**: 实验从单位超立方体中随机采样。\n\n* **GPEIOptChooser:** 来自论文中的 GP EI MCMC 算法。首先在单位超立方体上的密集网格上对任务进行密集采样，然后根据 EI 准则对最佳候选者进行“微调”优化。\n\n* **GPEIperSecChooser:** 来自论文中的每秒 EI 值算法。与 GPEIOptChooser 类似，但不同之处在于，点是根据每秒 EI 值准则进行优化和评估的，每个任务都根据预期的实验运行时间进行了加权。\n\n* **GPEIChooser:** 在单位超立方体上对点进行密集采样，并根据 EI 准则返回最佳点。此方法比 GPEIOptChooser 快得多，在搜索空间被网格密集覆盖的低维情况下表现良好。\n\n**重要提示！**\n\n在估计噪声时，关于噪声的高斯过程先验假设噪声水平“较低”（例如介于 -1 到 1 之间）。如果实际情况并非如此，请务必对您的函数进行缩放，使其满足这一假设（例如使函数值大致位于 -1 到 1 之间）。否则，算法可能会陷入错误的高噪声模式，从而导致性能不佳。","# Spearmint 快速上手指南\n\nSpearmint 是一个用于执行贝叶斯优化（Bayesian Optimization）的 Python 包，旨在通过最少的实验次数自动调整参数以最小化目标函数。它特别适用于机器学习算法的超参数调优。\n\n> **注意**：本仓库为旧版维护版本（基于 Python 2.7）。新版 Spearmint 已迁移至新仓库并采用非商业许可证。如需商业使用或最新特性，请查阅新版；若需自由使用旧代码，可继续参考本指南。\n\n## 环境准备\n\n### 系统要求\n- **操作系统**：Ubuntu Linux (11.0+) 或 Mac OS X\n- **Python 版本**：Python 2.7\n\n### 前置依赖\n请确保安装以下依赖库：\n\n1. **Numpy** (版本 1.6.1+)\n   - Ubuntu: `apt-get install python-numpy`\n   - *国内加速建议*：可使用清华或阿里镜像源配置 pip 安装。\n\n2. **Scipy** (版本 0.9.0+)\n   - Ubuntu: `apt-get install python-scipy`\n\n3. **Google Protocol Buffers** (用于全自动模式)\n   - Ubuntu: `apt-get install python-protobuf`\n   - Mac (Homebrew): `brew install protobuf`\n   - 安装后需在 spearmint 子目录下运行编译命令：`bin\u002Fmake_protobufs`\n\n## 安装步骤\n\n1. 进入 `spearmint` 子目录。\n2. 执行安装命令（可能需要 sudo 权限）：\n   ```bash\n   python setup.py install\n   ```\n3. **配置环境变量**：\n   将 `spearmint` 子目录添加到 `PYTHONPATH` 中，或者直接在该项目目录下运行。\n\n## 基本使用\n\n最简单的方式是运行自带的示例（优化 Branin 基准函数）。\n\n### 1. 准备配置文件\n示例位于 `examples\u002Fbraninpy` 目录。核心文件是 `config.pb`，你需要确认以下字段：\n- `language`: 设置为 `PYTHON` 或 `MATLAB`。\n- `name`: 你的包装器函数名（例如 `branin`）。\n- `variables`: 定义待优化参数的名称、类型（FLOAT\u002FINT\u002FENUM）、范围（MIN\u002FMAX）和数量（SIZE）。\n\n### 2. 编写包装器脚本\n创建一个 Python 文件（如 `branin.py`），必须包含名为 `main` 的函数：\n```python\ndef main(job_id, params):\n    # params 是一个字典，包含当前实验的参数值\n    # 返回一个需要最小化的实数值\n    result = ... \n    return result\n```\n\n### 3. 运行优化\n进入 `bin` 目录或 `spearmint` 目录执行以下命令：\n\n**方式 A（推荐，从 bin 目录运行）：**\n```bash\n.\u002Fspearmint ..\u002Fexamples\u002Fbraninpy\u002Fconfig.pb --driver=local --method=GPEIOptChooser --method-args=noiseless=1\n```\n\n**方式 B（从 spearmint 目录运行）：**\n```bash\npython main.py --driver=local --method=GPEIOptChooser --method-args=noiseless=1 ..\u002Fexamples\u002Fbraninpy\u002Fconfig.pb\n```\n\n**参数说明：**\n- `--driver=local`: 在单机多核环境下运行。若在集群环境可使用 `--driver=sge`。\n- `--method=GPEIOptChooser`: 使用高斯过程 - 期望改进（GP-EI）策略。\n- `--method-args=noiseless=1`: 如果目标函数是确定性的（无噪声解析函数），设为 1 可加速优化；若是随机性实验（如机器学习训练），请去掉此参数或设为 0。\n\n### 4. 查看结果\n- **实时监控**：运行时会打印当前最优值。添加 `-w` 参数可启动本地 Web 服务器查看可视化状态页。\n- **结果文件**：\n  - `trace.csv`: 记录每次实验的时间戳、当前最优值、任务 ID 等。\n  - `output\u002F`: 包含每个任务的标准输出和错误日志。\n  - `best_job_and_result.txt`: 实时更新的最优结果及对应参数。\n\n### 5. 清理实验\n若要重置实验并删除所有中间文件，运行：\n```bash\nbin\u002Fcleanup \u003Cexperiment_dir>\n```\n\n### 并行运行\n若需在同一台机器上并行运行多个任务，添加参数：\n```bash\n--max-concurrent=\u003C任务数量>\n```","某深度学习团队正在训练一个复杂的卷积神经网络，急需找到最优的超参数组合以在有限算力下最大化模型准确率。\n\n### 没有 spearmint 时\n- 研究人员依赖人工经验或简单的网格搜索调整学习率、动量等参数，往往需要数百次试错才能碰巧接近最优解。\n- 每次实验需手动修改配置文件并重启训练脚本，大量时间浪费在重复的启动操作和结果记录上，效率极低。\n- 由于缺乏智能引导，许多计算资源被消耗在明显表现不佳的参数区域，导致昂贵的 GPU 算力被严重浪费。\n- 团队成员难以并行协作，多人同时调整参数时容易发生冲突，且无法实时共享最新的实验进展数据。\n\n### 使用 spearmint 后\n- spearmint 基于贝叶斯优化算法自动推断下一个最有希望的参数组合，将寻找最优解所需的实验次数从数百次缩减至几十次。\n- 通过编写简单的包装器脚本，spearmint 自动接管实验的启动、参数注入及结果回传流程，实现了全流程无人值守运行。\n- 系统能智能避开低效参数空间，优先探索高潜力区域，确保每一次 GPU 运行都产生最大化的信息增益。\n- 支持集群环境下的并行调度，自动管理多个并发实验的任务队列，让团队成员能专注于模型架构设计而非调参琐事。\n\nspearmint 的核心价值在于将盲目且耗时的超参数搜索转化为一种高效、自动化的科学实验过程，极大降低了机器学习模型的迭代成本。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002FJasperSnoek_spearmint_2839ba3c.png","JasperSnoek","Jasper Snoek","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002FJasperSnoek_c34ab008.jpg",null,"https:\u002F\u002Fgithub.com\u002FJasperSnoek",[78,82,86,90,94,98,102,104],{"name":79,"color":80,"percentage":81},"Python","#3572A5",89.1,{"name":83,"color":84,"percentage":85},"MATLAB","#e16737",9.1,{"name":87,"color":88,"percentage":89},"HTML","#e34c26",0.6,{"name":91,"color":92,"percentage":93},"JavaScript","#f1e05a",0.5,{"name":95,"color":96,"percentage":97},"Shell","#89e051",0.3,{"name":99,"color":100,"percentage":101},"PureBasic","#5a6986",0.1,{"name":103,"color":75,"percentage":101},"Protocol Buffer",{"name":105,"color":106,"percentage":101},"CSS","#663399",1393,332,"2026-03-20T06:41:33",4,"Linux (Ubuntu 11.0+), macOS","未说明",{"notes":114,"python":115,"dependencies":116},"该工具主要支持 Python 和 Matlab 作为包装器语言。自动化版本（Spearmint）依赖 Google Protocol Buffers，而轻量版（Spearmint-lite）使用 JSON 替代。支持在单机多核或集群环境（如 Sun Grid Engine）下并行运行实验。注意：新版代码库已采用非商业许可证，当前文档描述的是较旧的开源版本。","2.7",[117,118,119],"Numpy>=1.6.1","Scipy>=0.9.0","Google Protocol Buffers",[14,121],"其他","2026-03-27T02:49:30.150509","2026-04-16T08:12:12.397226",[125,130,135,140,145,150,155],{"id":126,"question_zh":127,"answer_zh":128,"source_url":129},35632,"为什么程序一直在运行但没有找到任何最佳候选点（Current best: No results returned yet）？","这通常是因为错误信息没有被打印到标准输出（stdout），而是写入了日志文件。请进入 Spearmint 的输出子目录（通常是 logs 或 output 文件夹），查看其中的模型文件以获取具体错误信息。此外，有用户反馈将 protobuf 版本降级为 2.5.0 解决了该问题。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F69",{"id":131,"question_zh":132,"answer_zh":133,"source_url":134},35633,"如何在 Spearmint 中指定初始点的数量？","可以通过在命令行中使用 `--grid-size` 标志来设置初始网格的大小。另外，也可以使用 `spearmint-lite` 分支，通过直接编辑扁平文件来初始化实验结果。注意：较新的 PESC 分支可能更适合用作基准测试。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F60",{"id":136,"question_zh":137,"answer_zh":138,"source_url":139},35634,"为什么在 Spearmint 中运行训练脚本比单独运行时慢很多？","这可能是由于 Python 多进程（multiprocessing）或全局解释器锁（GIL）导致的开销。Spearmint 默认每 5 秒轮询一次任务状态，频繁轮询可能影响性能。建议在 `config.json` 配置文件中增加 `polling-time` 的值（例如设置为 120 秒）以减少轮询频率：`\"polling-time\": 120`。如果问题依旧，可以考虑不使用本地模式，转而使用集群或 Whetlab。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F45",{"id":141,"question_zh":142,"answer_zh":143,"source_url":144},35635,"为什么 Spearmint 在完成 128 个任务后会崩溃？","这可能与多进程处理或 numpy 的底层线性代数库有关。尝试禁用多进程功能，添加参数 `-method-args=use_multiprocessing=0` 运行。另外，有用户反馈在使用虚拟机并将 numpy 编译为链接 OpenBLAS 库后解决了该问题。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F47",{"id":146,"question_zh":147,"answer_zh":148,"source_url":149},35636,"遇到内存泄漏（memory leak）导致内存占用随迭代次数增加而飙升怎么办？","该问题曾由 `np.diag` 函数在特定版本的 numpy（如 1.7.0）中引起。建议升级 numpy 到最新版本。如果在调试时发现加上 `@profile` 装饰器后泄漏消失，这通常意味着垃圾回收机制在某些情况下未能正确释放引用，更新依赖库通常能解决此问题。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F16",{"id":151,"question_zh":152,"answer_zh":153,"source_url":154},35637,"Spearmint 是否有自动停止条件？如何设置收敛条件？","Spearmint 本身主要依赖用户设定的最大任务数（如 `max_finished_jobs`）来停止，而不是基于收敛条件的自动停止。对于未知函数的优化，你需要编写一个包装器（wrapper）脚本来定义目标函数，该脚本接收参数并返回评估结果。如果没有明确的停止需求，通常需要手动停止或预设足够的迭代次数。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F54",{"id":156,"question_zh":157,"answer_zh":158,"source_url":159},35638,"项目主页或文档中的链接失效了怎么办？","部分旧链接（如多伦多大学服务器上的链接）可能已失效。维护者通常会修复这些链接。如果遇到问题，可以尝试访问维护者在哈佛大学的主页（http:\u002F\u002Fpeople.seas.harvard.edu\u002F~jsnoek\u002F）或直接查看 GitHub 仓库页面获取最新资源和代码下载链接。","https:\u002F\u002Fgithub.com\u002FJasperSnoek\u002Fspearmint\u002Fissues\u002F23",[]]