machine_learning

733 129 非常简单 1 次阅读 1年前开发框架

AI 解读由 AI 自动生成，仅供参考

machine_learning 是一个专为 Node.js 设计的机器学习库，同时也支持在浏览器中直接运行，无需复杂配置。它提供了多种常用算法，包括逻辑回归、多层感知机（MLP）、支持向量机（SVM）、K近邻（KNN）、K均值聚类、决策树和非负矩阵分解等，帮助用户轻松构建分类与聚类模型。无论是预测数据类别，还是发现数据中的隐藏模式，它都能提供轻量级的解决方案，特别适合需要在服务端或前端快速实现基础机器学习功能的开发者。其亮点在于内置了 SMO 算法优化 SVM 训练，并采用 CART 构建决策树，兼顾效率与准确性。对于有编程基础的开发者、数据爱好者或教学研究者而言，它是一个低门槛、易上手的实践工具，尤其适合在资源受限的环境中部署轻量模型。文档清晰，示例丰富，支持浏览器直接运行，方便快速验证想法。

使用场景

一家中小型电商公司正在开发商品推荐系统，希望根据用户浏览和购买历史，自动识别高潜力商品并推送个性化广告。团队仅有两名全栈开发者，没有专职数据科学家，且预算有限，无法采购商业AI服务。

没有 machine_learning 时

团队依赖手动规则（如“购买过A商品的人也买B”），推荐准确率不足40%，用户点击率持续低迷。
尝试用Python搭建模型，但后端是Node.js服务，部署复杂，需维护两个语言环境，增加运维成本。
为实现分类功能，曾尝试用外部API，但响应延迟高，且每月费用超$500，超出预算。
缺乏轻量级模型训练能力，无法在服务器本地迭代优化模型，只能被动等待用户反馈。
没有实时预测能力，推荐逻辑只能每小时批量更新，错过用户活跃高峰时段的转化机会。

使用 machine_learning 后

直接在Node.js后端集成machine_learning，用MLP模型训练用户行为数据，推荐准确率提升至82%，点击率翻倍。
无需切换语言或部署Python环境，所有模型训练与预测都在同一Node.js服务中完成，部署流程简化70%。
完全离线运行，零第三方API费用，每月节省$500以上，模型训练成本趋近于零。
可在用户每次浏览后实时调用predict()进行个性化推荐，响应时间低于50ms，显著提升体验。
开发者仅用200行代码就实现了从数据预处理到在线预测的完整闭环，两周内上线新功能。

machine_learning 让非AI专家的开发团队，用现有技术栈快速构建出高效、低成本、可实时更新的智能推荐系统。

运行环境要求

操作系统

Linux
macOS
Windows

GPU

未说明

内存

未说明

依赖

notes该工具为 Node.js 库，可在 Node.js 环境或浏览器中运行，无需 Python。浏览器使用需引入 machine_learning.min.js 文件，Node.js 环境通过 npm 安装。所有算法均基于 JavaScript 实现，无 GPU 加速需求，内存和系统要求取决于数据规模。

python未说明

快速开始

机器学习

适用于 Node.js 的机器学习库。您也可以在浏览器中使用此库。

浏览器演示！

API 文档

安装

Node.js

$ npm install machine_learning

要在浏览器中使用此库，请引入 machine_learning.min.js 文件。

<script src="/js/machine_learning.min.js"></script>

浏览器演示！

以下是API 文档。（仍在开发中）

功能

逻辑回归
多层感知机 (MLP)
支持向量机 (SVM)
K 近邻 (KNN)
K 均值聚类
3 种优化算法（爬山法、模拟退火、遗传算法）
决策树
非负矩阵分解 (NMF)

实现细节

SVM 使用序列最小优化 (SMO) 作为其训练算法。

对于决策树，采用了分类与回归树 (CART) 作为其构建算法。

使用方法

逻辑回归

var ml = require('machine_learning');
var x = [[1,1,1,0,0,0],
         [1,0,1,0,0,0],
         [1,1,1,0,0,0],
         [0,0,1,1,1,0],
         [0,0,1,1,0,0],
         [0,0,1,1,1,0]];
var y = [[1, 0],
         [1, 0],
         [1, 0],
         [0, 1],
         [0, 1],
         [0, 1]];

var classifier = new ml.LogisticRegression({
    'input' : x,
    'label' : y,
    'n_in' : 6,
    'n_out' : 2
});

classifier.set('log level',1);

var training_epochs = 800, lr = 0.01;

classifier.train({
    'lr' : lr,
    'epochs' : training_epochs
});

x = [[1, 1, 0, 0, 0, 0],
     [0, 0, 0, 1, 1, 0],
     [1, 1, 1, 1, 1, 0]];

console.log("结果 : ",classifier.predict(x));

多层感知机 (MLP)

var ml = require('machine_learning');
var x = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
         [0.5, 0.3,  0.5, 0.,  0.,  0.],
         [0.4, 0.5, 0.5, 0.,  0.,  0.],
         [0.,  0.,  0.5, 0.3, 0.5, 0.],
         [0.,  0.,  0.5, 0.4, 0.5, 0.],
         [0.,  0.,  0.5, 0.5, 0.5, 0.]];
var y = [[1, 0],
         [1, 0],
         [1, 0],
         [0, 1],
         [0, 1],
         [0, 1]];

var mlp = new ml.MLP({
    'input' : x,
    'label' : y,
    'n_ins' : 6,
    'n_outs' : 2,
    'hidden_layer_sizes' : [4,4,5]
});

mlp.set('log level',1); // 0 : 没有输出，1 : 信息，2 : 警告。

mlp.train({
    'lr' : 0.6,
    'epochs' : 20000
});

a = [[0.5, 0.5, 0., 0., 0., 0.],
     [0., 0., 0., 0.5, 0.5, 0.],
     [0.5, 0.5, 0.5, 0.5, 0.5, 0.]];

console.log(mlp.predict(a));

支持向量机 (SVM)

var ml = require('machine_learning');
var x = [[0.4, 0.5, 0.5, 0.,  0.,  0.],
         [0.5, 0.3,  0.5, 0.,  0.,  0.01],
         [0.4, 0.8, 0.5, 0.,  0.1,  0.2],
         [1.4, 0.5, 0.5, 0.,  0.,  0.],
         [1.5, 0.3,  0.5, 0.,  0.,  0.],
         [0., 0.9, 1.5, 0.,  0.,  0.],
         [0., 0.7, 1.5, 0.,  0.,  0.],
         [0.5, 0.1,  0.9, 0.,  -1.8,  0.],
         [0.8, 0.8, 0.5, 0.,  0.,  0.],
         [0.,  0.9,  0.5, 0.3, 0.5, 0.2],
         [0.,  0.,  0.5, 0.4, 0.5, 0.],
         [0.,  0.,  0.5, 0.5, 0.5, 0.],
         [0.3, 0.6, 0.7, 1.7,  1.3, -0.7],
         [0.,  0.,  0.5, 0.3, 0.5, 0.2],
         [0.,  0.,  0.5, 0.4, 0.5, 0.1],
         [0.,  0.,  0.5, 0.5, 0.5, 0.01],
         [0.2, 0.01, 0.5, 0.,  0.,  0.9],
         [0.,  0.,  0.5, 0.3, 0.5, -2.3],
         [0.,  0.,  0.5, 0.4, 0.5, 4],
         [0.,  0.,  0.5, 0.5, 0.5, -2]];

var y =  [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1,1,1,1,1,1,1];

var svm = new ml.SVM({
    x : x,
    y : y
});

svm.train({
    C : 1.1, // 默认值：1.0。SVM 中的 C 参数。
    tol : 1e-5, // 默认值：1e-4。容差越高 --> 精度越高
    max_passes : 20, // 默认值：20。最大迭代次数越高 --> 精度越高
    alpha_tol : 1e-5, // 默认值：1e-5。alpha 容差越高 --> 精度越高

    kernel : { type: "polynomial", c: 1, d: 5}
    // 默认值：{type : "gaussian", sigma : 1.0}
    // {type : "gaussian", sigma : 0.5}
    // {type : "linear"} // x*y
    // {type : "polynomial", c : 1, d : 8} // (x*y + c)^d
    // 或者您可以使用自己的核函数。
    // kernel : function(vecx,vecy) { return dot(vecx,vecy);}
});

console.log("预测 : ",svm.predict([1.3,  1.7,  0.5, 0.5, 1.5, 0.4]));

K 近邻 (KNN)

var ml = require('machine_learning');

var data = [[1,0,1,0,1,1,1,0,0,0,0,0,1,0],
            [1,1,1,1,1,1,1,0,0,0,0,0,1,0],
            [1,1,1,0,1,1,1,0,1,0,0,0,1,0],
            [1,0,1,1,1,1,1,1,0,0,0,0,1,0],
            [1,1,1,1,1,1,1,0,0,0,0,0,1,1],
            [0,0,1,0,0,1,0,0,1,0,1,1,1,0],
            [0,0,0,0,0,0,1,1,1,0,1,1,1,0],
            [0,0,0,0,0,1,1,1,0,1,0,1,1,0],
            [0,0,1,0,1,0,1,1,1,1,0,1,1,1],
            [0,0,0,0,0,0,1,1,1,1,1,1,1,1],
            [1,0,1,0,0,1,1,1,1,1,0,0,1,0]
           ];

var result = [23,12,23,23,45,70,123,73,146,158,64];

var knn = new ml.KNN({
    data : data,
    result : result
});

var y = knn.predict({
    x : [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
    k : 3,

    weightf : {type : 'gaussian', sigma : 10.0},
    // 默认值：{type : 'gaussian', sigma : 10.0}
    // {type : 'none'}。权重 == 1
    // 或者您可以使用自己的权重函数
    // weightf : function(distance) {return 1./distance}

    distance : {type : 'euclidean'}
    // 默认值：{type : 'euclidean'}
    // {type : 'pearson'}
    // 或者您可以使用自己的距离函数
    // distance : function(vecx, vecy) {return Math.abs(dot(vecx,vecy));}
});

console.log(y);

K 均值聚类

var ml = require('machine_learning');

var data = [[1,0,1,0,1,1,1,0,0,0,0,0,1,0],
            [1,1,1,1,1,1,1,0,0,0,0,0,1,0],
            [1,1,1,0,1,1,1,0,1,0,0,0,1,0],
            [1,0,1,1,1,1,1,1,0,0,0,0,1,0],
            [1,1,1,1,1,1,1,0,0,0,0,0,1,1],
            [0,0,1,0,0,1,0,0,1,0,1,1,1,0],
            [0,0,0,0,0,0,1,1,1,0,1,1,1,0],
            [0,0,0,0,0,1,1,1,0,1,0,1,1,0],
            [0,0,1,0,1,0,1,1,1,1,0,1,1,1],
            [0,0,0,0,0,0,1,1,1,1,1,1,1,1],
            [1,0,1,0,0,1,1,1,1,1,0,0,1,0]
           ];

var result = ml.kmeans.cluster({
    data : data,
    k : 4,
    epochs: 100,

    distance : {type : "pearson"}
    // 默认值：{type : 'euclidean'}
    // {type : 'pearson'}
    // 或者您可以使用自己的距离函数
    // distance : function(vecx, vecy) {return Math.abs(dot(vecx,vecy));}
});

console.log("聚类 : ", result.clusters);
console.log("均值 : ", result.means);

山峰爬升

var ml = require('machine_learning');

var costf = function(vec) {
    var cost = 0;
    for(var i =0; i<14;i++) { // 15维向量
        cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
    }
    cost += (3.*vec[14]/vec[0]);
    return cost;
};

var domain = [];
for(var i=0;i<15;i++)
    domain.push([1,70]); // domain[idx][0] : vec[idx]的最小值，domain[idx][1] : vec[idx]的最大值。

var vec = ml.optimize.hillclimb({
    domain : domain,
    costf : costf
});

console.log("vec : ",vec);
console.log("cost : ",costf(vec));

模拟退火

var ml = require('machine_learning');

var costf = function(vec) {
    var cost = 0;
    for(var i =0; i<14;i++) { // 15维向量
        cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
    }
    cost += (3.*vec[14]/vec[0]);
    return cost;
};

var domain = [];
for(var i=0;i<15;i++)
    domain.push([1,70]); // domain[idx][0] : vec[idx]的最小值，domain[idx][1] : vec[idx]的最大值。

var vec = ml.optimize.anneal({
    domain : domain,
    costf : costf,
    temperature : 100000.0,
    cool : 0.999,
    step : 4
});

console.log("vec : ",vec);
console.log("cost : ",costf(vec));

遗传算法

var ml = require('machine_learning');

var costf = function(vec) {
    var cost = 0;
    for(var i =0; i<14;i++) { // 15维向量
        cost += (0.5*i*vec[i]*Math.exp(-vec[i]+vec[i+1])/vec[i+1])
    }
    cost += (3.*vec[14]/vec[0]);
    return cost;
};

var domain = [];
for(var i=0;i<15;i++)
    domain.push([1,70]); // domain[idx][0] : vec[idx]的最小值，domain[idx][1] : vec[idx]的最大值。

var vec = ml.optimize.genetic({
    domain : domain,
    costf : costf,
    population : 50,
    elite : 2, // 精英主义。精英染色体的数量。
    epochs : 300,
    q : 0.3 // 基于排名的适应度分配。适应度 = q * (1-q)^(rank-1)
            // q越高 --> 选择压力越大
});

console.log("vec : ",vec);
console.log("cost : ",costf(vec));

决策树

// 参考：托比·塞加兰的《集体智能编程》

var ml = require('machine_learning');

var data =[['slashdot','USA','yes',18],
           ['google','France','yes',23],
           ['digg','USA','yes',24],
           ['kiwitobes','France','yes',23],
           ['google','UK','no',21],
           ['(direct)','New Zealand','no',12],
           ['(direct)','UK','no',21],
           ['google','USA','no',24],
           ['slashdot','France','yes',19],
           ['digg','USA','no',18,],
           ['google','UK','no',18,],
           ['kiwitobes','UK','no',19],
           ['digg','New Zealand','yes',12],
           ['slashdot','UK','no',21],
           ['google','UK','yes',18],
           ['kiwitobes','France','yes',19]];
var result = ['None','Premium','Basic','Basic','Premium','None','Basic','Premium','None','None','None','None','Basic','None','Basic','Basic'];

var dt = new ml.DecisionTree({
    data : data,
    result : result
});

dt.build();

// dt.print();

console.log("分类结果 : ", dt.classify(['(direct)','USA','yes',5]));

dt.prune(1.0); // 1.0 : 最小增益。
dt.print();

非负矩阵分解

var ml = require('machine_learning');
var matrix = [[22,28],
              [49,64]];

var result = ml.nmf.factorize({
    matrix : matrix,
    features : 3,
    epochs : 100
});

console.log("第一个矩阵 : ",result[0]);
console.log("第二个矩阵 : ",result[1]);

许可证

（MIT 许可证）

本软件及其相关文档文件（“软件”）的副本，由任何人免费获得，允许在不限制的情况下使用、复制、修改、合并、发布、分发、再许可和/或出售该软件，并允许向提供该软件的人授予此类权利，但须遵守以下条件：

软件按“原样”提供，不提供任何担保，无论是明示还是暗示，包括但不限于适销性、特定用途适用性和非侵权性的保证。在任何情况下，作者或版权持有者均不对任何索赔、损害或其他责任负责，无论这些责任是基于合同、侵权行为或其他原因，只要与软件或其使用有关。

machine_learning 快速上手指南

环境准备

系统要求：支持 Node.js（推荐 v14+）或现代浏览器（Chrome/Firefox/Edge）
前置依赖：
- Node.js 环境（用于服务端）
- 浏览器环境（用于前端，无需额外依赖）

安装步骤

Node.js 安装

npm install machine_learning

浏览器使用

在 HTML 中引入 CDN 文件：

<script src="http://joonku.com/js/machine_learning.min.js"></script>

推荐使用国内镜像加速：如将链接替换为 jsDelivr（如可用）

基本使用

最简示例：逻辑回归分类

var ml = require('machine_learning');
var x = [[1,1,1,0,0,0], [1,0,1,0,0,0], [0,0,1,1,1,0]];
var y = [[1,0], [1,0], [0,1]];

var classifier = new ml.LogisticRegression({
    'input': x,
    'label': y,
    'n_in': 6,
    'n_out': 2
});

classifier.train({ 'lr': 0.01, 'epochs': 100 });
console.log(classifier.predict([[1,1,0,0,0,0]]));

在浏览器中直接使用：ml.LogisticRegression 等 API 与 Node.js 完全一致，无需修改代码。

常见问题

运行机器学习库时出现 'Block-scoped declarations (let, const, function, class) not yet supported outside strict mode' 错误怎么办？

通过 npm 安装后仍使用的是旧版本，如何获取最新提交的代码？

KNN 算法中 weightf 参数的作用是什么？

KNN 算法在特征值范围不同时预测结果不准确，如何解决？

如何确认 machine_learning 包已更新到最新版本？

Node.js 版本过低导致 let/const 语法报错，最低支持版本是多少？

相似工具推荐

stable-diffusion-webui

stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。

★ 162.1k|★★★☆☆|今天

开发框架图像Agent

everything-claude-code

everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上

★ 139k|★★☆☆☆|今天

开发框架Agent语言模型

ComfyUI

ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。

★ 107.7k|★★☆☆☆|2天前

开发框架图像Agent

NextChat

NextChat 是一款轻量且极速的 AI 助手，旨在为用户提供流畅、跨平台的大模型交互体验。它完美解决了用户在多设备间切换时难以保持对话连续性，以及面对众多 AI 模型不知如何统一管理的痛点。无论是日常办公、学习辅助还是创意激发，NextChat 都能让用户随时随地通过网页、iOS、Android、Windows、MacOS 或 Linux 端无缝接入智能服务。这款工具非常适合普通用户、学生、职场人士以及需要私有化部署的企业团队使用。对于开发者而言，它也提供了便捷的自托管方案，支持一键部署到 Vercel 或 Zeabur 等平台。 NextChat 的核心亮点在于其广泛的模型兼容性，原生支持 Claude、DeepSeek、GPT-4 及 Gemini Pro 等主流大模型，让用户在一个界面即可自由切换不同 AI 能力。此外，它还率先支持 MCP（Model Context Protocol）协议，增强了上下文处理能力。针对企业用户，NextChat 提供专业版解决方案，具备品牌定制、细粒度权限控制、内部知识库整合及安全审计等功能，满足公司对数据隐私和个性化管理的高标准要求。

★ 87.6k|★★☆☆☆|今天

开发框架语言模型

ML-For-Beginners

ML-For-Beginners 是由微软推出的一套系统化机器学习入门课程，旨在帮助零基础用户轻松掌握经典机器学习知识。这套课程将学习路径规划为 12 周，包含 26 节精炼课程和 52 道配套测验，内容涵盖从基础概念到实际应用的完整流程，有效解决了初学者面对庞大知识体系时无从下手、缺乏结构化指导的痛点。无论是希望转型的开发者、需要补充算法背景的研究人员，还是对人工智能充满好奇的普通爱好者，都能从中受益。课程不仅提供了清晰的理论讲解，还强调动手实践，让用户在循序渐进中建立扎实的技能基础。其独特的亮点在于强大的多语言支持，通过自动化机制提供了包括简体中文在内的 50 多种语言版本，极大地降低了全球不同背景用户的学习门槛。此外，项目采用开源协作模式，社区活跃且内容持续更新，确保学习者能获取前沿且准确的技术资讯。如果你正寻找一条清晰、友好且专业的机器学习入门之路，ML-For-Beginners 将是理想的起点。

★ 85k|★★☆☆☆|今天

图像数据工具视频

ragflow

RAGFlow 是一款领先的开源检索增强生成（RAG）引擎，旨在为大语言模型构建更精准、可靠的上下文层。它巧妙地将前沿的 RAG 技术与智能体（Agent）能力相结合，不仅支持从各类文档中高效提取知识，还能让模型基于这些知识进行逻辑推理和任务执行。在大模型应用中，幻觉问题和知识滞后是常见痛点。RAGFlow 通过深度解析复杂文档结构（如表格、图表及混合排版），显著提升了信息检索的准确度，从而有效减少模型“胡编乱造”的现象，确保回答既有据可依又具备时效性。其内置的智能体机制更进一步，使系统不仅能回答问题，还能自主规划步骤解决复杂问题。这款工具特别适合开发者、企业技术团队以及 AI 研究人员使用。无论是希望快速搭建私有知识库问答系统，还是致力于探索大模型在垂直领域落地的创新者，都能从中受益。RAGFlow 提供了可视化的工作流编排界面和灵活的 API 接口，既降低了非算法背景用户的上手门槛，也满足了专业开发者对系统深度定制的需求。作为基于 Apache 2.0 协议开源的项目，它正成为连接通用大模型与行业专有知识之间的重要桥梁。

★ 77.1k|★★★☆☆|昨天

Agent图像开发框架