@Dave是第一个发布答案（使用工作代码）的人，他的答案一直是我无耻的复制和粘贴灵感的宝贵来源。这篇文章最初是试图解释和完善@Dave的答案，但后来演变成自己的答案。
我的方法明显更快。根据jsPerf对随机生成的RGB颜色的基准测试，@Dave的算法在600毫秒内运行，而我的算法在30毫秒内运行。这绝对很重要，例如在加载时间，速度至关重要。
此外，对于某些颜色，我的算法性能更好：
- 因为，@Dave的农产品和矿山的农产品
rgb(0,255,0)rgb(29,218,34)rgb(1,255,0)
- 因为，@Dave的农产品和矿山的农产品
rgb(0,0,255)rgb(37,39,255)rgb(5,6,255)
- 因为，@Dave的农产品和矿山的农产品
rgb(19,11,118)rgb(36,27,102)rgb(20,11,112)
演示
"use strict";
class Color {
constructor(r, g, b) { this.set(r, g, b); }
toString() { return `rgb(${Math.round(this.r)}, ${Math.round(this.g)}, ${Math.round(this.b)})`; }
set(r, g, b) {
this.r = this.clamp(r);
this.g = this.clamp(g);
this.b = this.clamp(b);
}
hueRotate(angle = 0) {
angle = angle / 180 * Math.PI;
let sin = Math.sin(angle);
let cos = Math.cos(angle);
this.multiply([
0.213 + cos * 0.787 - sin * 0.213, 0.715 - cos * 0.715 - sin * 0.715, 0.072 - cos * 0.072 + sin * 0.928,
0.213 - cos * 0.213 + sin * 0.143, 0.715 + cos * 0.285 + sin * 0.140, 0.072 - cos * 0.072 - sin * 0.283,
0.213 - cos * 0.213 - sin * 0.787, 0.715 - cos * 0.715 + sin * 0.715, 0.072 + cos * 0.928 + sin * 0.072
]);
}
grayscale(value = 1) {
this.multiply([
0.2126 + 0.7874 * (1 - value), 0.7152 - 0.7152 * (1 - value), 0.0722 - 0.0722 * (1 - value),
0.2126 - 0.2126 * (1 - value), 0.7152 + 0.2848 * (1 - value), 0.0722 - 0.0722 * (1 - value),
0.2126 - 0.2126 * (1 - value), 0.7152 - 0.7152 * (1 - value), 0.0722 + 0.9278 * (1 - value)
]);
}
sepia(value = 1) {
this.multiply([
0.393 + 0.607 * (1 - value), 0.769 - 0.769 * (1 - value), 0.189 - 0.189 * (1 - value),
0.349 - 0.349 * (1 - value), 0.686 + 0.314 * (1 - value), 0.168 - 0.168 * (1 - value),
0.272 - 0.272 * (1 - value), 0.534 - 0.534 * (1 - value), 0.131 + 0.869 * (1 - value)
]);
}
saturate(value = 1) {
this.multiply([
0.213 + 0.787 * value, 0.715 - 0.715 * value, 0.072 - 0.072 * value,
0.213 - 0.213 * value, 0.715 + 0.285 * value, 0.072 - 0.072 * value,
0.213 - 0.213 * value, 0.715 - 0.715 * value, 0.072 + 0.928 * value
]);
}
multiply(matrix) {
let newR = this.clamp(this.r * matrix[0] + this.g * matrix[1] + this.b * matrix[2]);
let newG = this.clamp(this.r * matrix[3] + this.g * matrix[4] + this.b * matrix[5]);
let newB = this.clamp(this.r * matrix[6] + this.g * matrix[7] + this.b * matrix[8]);
this.r = newR; this.g = newG; this.b = newB;
}
brightness(value = 1) { this.linear(value); }
contrast(value = 1) { this.linear(value, -(0.5 * value) + 0.5); }
linear(slope = 1, intercept = 0) {
this.r = this.clamp(this.r * slope + intercept * 255);
this.g = this.clamp(this.g * slope + intercept * 255);
this.b = this.clamp(this.b * slope + intercept * 255);
}
invert(value = 1) {
this.r = this.clamp((value + (this.r / 255) * (1 - 2 * value)) * 255);
this.g = this.clamp((value + (this.g / 255) * (1 - 2 * value)) * 255);
this.b = this.clamp((value + (this.b / 255) * (1 - 2 * value)) * 255);
}
hsl() { // Code taken from https://stackoverflow.com/a/9493060/2688027, licensed under CC BY-SA.
let r = this.r / 255;
let g = this.g / 255;
let b = this.b / 255;
let max = Math.max(r, g, b);
let min = Math.min(r, g, b);
let h, s, l = (max + min) / 2;
if(max === min) {
h = s = 0;
} else {
let d = max - min;
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
switch(max) {
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
case g: h = (b - r) / d + 2; break;
case b: h = (r - g) / d + 4; break;
} h /= 6;
}
return {
h: h * 100,
s: s * 100,
l: l * 100
};
}
clamp(value) {
if(value > 255) { value = 255; }
else if(value < 0) { value = 0; }
return value;
}
}
class Solver {
constructor(target) {
this.target = target;
this.targetHSL = target.hsl();
this.reusedColor = new Color(0, 0, 0); // Object pool
}
solve() {
let result = this.solveNarrow(this.solveWide());
return {
values: result.values,
loss: result.loss,
filter: this.css(result.values)
};
}
solveWide() {
const A = 5;
const c = 15;
const a = [60, 180, 18000, 600, 1.2, 1.2];
let best = { loss: Infinity };
for(let i = 0; best.loss > 25 && i < 3; i++) {
let initial = [50, 20, 3750, 50, 100, 100];
let result = this.spsa(A, a, c, initial, 1000);
if(result.loss < best.loss) { best = result; }
} return best;
}
solveNarrow(wide) {
const A = wide.loss;
const c = 2;
const A1 = A + 1;
const a = [0.25 * A1, 0.25 * A1, A1, 0.25 * A1, 0.2 * A1, 0.2 * A1];
return this.spsa(A, a, c, wide.values, 500);
}
spsa(A, a, c, values, iters) {
const alpha = 1;
const gamma = 0.16666666666666666;
let best = null;
let bestLoss = Infinity;
let deltas = new Array(6);
let highArgs = new Array(6);
let lowArgs = new Array(6);
for(let k = 0; k < iters; k++) {
let ck = c / Math.pow(k + 1, gamma);
for(let i = 0; i < 6; i++) {
deltas[i] = Math.random() > 0.5 ? 1 : -1;
highArgs[i] = values[i] + ck * deltas[i];
lowArgs[i] = values[i] - ck * deltas[i];
}
let lossDiff = this.loss(highArgs) - this.loss(lowArgs);
for(let i = 0; i < 6; i++) {
let g = lossDiff / (2 * ck) * deltas[i];
let ak = a[i] / Math.pow(A + k + 1, alpha);
values[i] = fix(values[i] - ak * g, i);
}
let loss = this.loss(values);
if(loss < bestLoss) { best = values.slice(0); bestLoss = loss; }
} return { values: best, loss: bestLoss };
function fix(value, idx) {
let max = 100;
if(idx === 2 /* saturate */) { max = 7500; }
else if(idx === 4 /* brightness */ || idx === 5 /* contrast */) { max = 200; }
if(idx === 3 /* hue-rotate */) {
if(value > max) { value = value % max; }
else if(value < 0) { value = max + value % max; }
} else if(value < 0) { value = 0; }
else if(value > max) { value = max; }
return value;
}
}
loss(filters) { // Argument is array of percentages.
let color = this.reusedColor;
color.set(0, 0, 0);
color.invert(filters[0] / 100);
color.sepia(filters[1] / 100);
color.saturate(filters[2] / 100);
color.hueRotate(filters[3] * 3.6);
color.brightness(filters[4] / 100);
color.contrast(filters[5] / 100);
let colorHSL = color.hsl();
return Math.abs(color.r - this.target.r)
+ Math.abs(color.g - this.target.g)
+ Math.abs(color.b - this.target.b)
+ Math.abs(colorHSL.h - this.targetHSL.h)
+ Math.abs(colorHSL.s - this.targetHSL.s)
+ Math.abs(colorHSL.l - this.targetHSL.l);
}
css(filters) {
function fmt(idx, multiplier = 1) { return Math.round(filters[idx] * multiplier); }
return `filter: invert(${fmt(0)}%) sepia(${fmt(1)}%) saturate(${fmt(2)}%) hue-rotate(${fmt(3, 3.6)}deg) brightness(${fmt(4)}%) contrast(${fmt(5)}%);`;
}
}
$("button.execute").click(() => {
let rgb = $("input.target").val().split(",");
if (rgb.length !== 3) { alert("Invalid format!"); return; }
let color = new Color(rgb[0], rgb[1], rgb[2]);
let solver = new Solver(color);
let result = solver.solve();
let lossMsg;
if (result.loss < 1) {
lossMsg = "This is a perfect result.";
} else if (result.loss < 5) {
lossMsg = "The is close enough.";
} else if(result.loss < 15) {
lossMsg = "The color is somewhat off. Consider running it again.";
} else {
lossMsg = "The color is extremely off. Run it again!";
}
$(".realPixel").css("background-color", color.toString());
$(".filterPixel").attr("style", result.filter);
$(".filterDetail").text(result.filter);
$(".lossDetail").html(`Loss: ${result.loss.toFixed(1)}. <b>${lossMsg}</b>`);
});
.pixel {
display: inline-block;
background-color: #000;
width: 50px;
height: 50px;
}
.filterDetail {
font-family: "Consolas", "Menlo", "Ubuntu Mono", monospace;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<input class="target" type="text" placeholder="r, g, b" value="250, 150, 50" />
<button class="execute">Compute Filters</button>
<p>Real pixel, color applied through CSS <code>background-color</code>:</p>
<div class="pixel realPixel"></div>
<p>Filtered pixel, color applied through CSS <code>filter</code>:</p>
<div class="pixel filterPixel"></div>
<p class="filterDetail"></p>
<p class="lossDetail"></p>
用法
let color = new Color(0, 255, 0);
let solver = new Solver(color);
let result = solver.solve();
let filterCSS = result.css;
解释
我们将从一些Javascript开始。
"use strict";
class Color {
constructor(r, g, b) {
this.r = this.clamp(r);
this.g = this.clamp(g);
this.b = this.clamp(b);
} toString() { return `rgb(${Math.round(this.r)}, ${Math.round(this.g)}, ${Math.round(this.b)})`; }
hsl() { // Code taken from https://stackoverflow.com/a/9493060/2688027, licensed under CC BY-SA.
let r = this.r / 255;
let g = this.g / 255;
let b = this.b / 255;
let max = Math.max(r, g, b);
let min = Math.min(r, g, b);
let h, s, l = (max + min) / 2;
if(max === min) {
h = s = 0;
} else {
let d = max - min;
s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
switch(max) {
case r: h = (g - b) / d + (g < b ? 6 : 0); break;
case g: h = (b - r) / d + 2; break;
case b: h = (r - g) / d + 4; break;
} h /= 6;
}
return {
h: h * 100,
s: s * 100,
l: l * 100
};
}
clamp(value) {
if(value > 255) { value = 255; }
else if(value < 0) { value = 0; }
return value;
}
}
class Solver {
constructor(target) {
this.target = target;
this.targetHSL = target.hsl();
}
css(filters) {
function fmt(idx, multiplier = 1) { return Math.round(filters[idx] * multiplier); }
return `filter: invert(${fmt(0)}%) sepia(${fmt(1)}%) saturate(${fmt(2)}%) hue-rotate(${fmt(3, 3.6)}deg) brightness(${fmt(4)}%) contrast(${fmt(5)}%);`;
}
}
解释：
- 该类表示 RGB 颜色。
Color
- 其函数返回 CSS 颜色字符串中的颜色。
toString()rgb(...)
- 其函数返回颜色，转换为 HSL。
hsl()
- 其函数确保给定的颜色值在边界 （0-255） 范围内。
clamp()
- 该类将尝试求解目标颜色。
Solver
- 它的函数返回 CSS 筛选器字符串中的给定筛选器。
css()
实现 、 和grayscale()sepia()saturate()
CSS/SVG 滤镜的核心是滤镜基元，它们表示对图像的低级修改。
滤镜灰度 （）、sepia（） 和 saturate（） 由滤镜主<feColorMatrix>实现，它在滤镜指定的矩阵（通常动态生成）和从颜色创建的矩阵之间执行矩阵乘法。图：
我们可以在这里进行一些优化：
- 颜色矩阵的最后一个元素是 并且将永远是 。计算或存储它没有意义。
1
- 计算或存储 alpha/透明度值 （） 也没有意义，因为我们处理的是 RGB，而不是 RGBA。
A
-
因此，我们可以将滤镜矩阵从 5x5 修剪到 3x5，将颜色矩阵从 1x5 修剪到 1x3。这样可以节省一些工作。
- 所有筛选器都将列 4 和 5 保留为零。因此，我们可以进一步将滤波器矩阵减小到3x3。
<feColorMatrix>
- 由于乘法相对简单，因此无需为此拖入复杂的数学库。我们可以自己实现矩阵乘法算法。
实现：
function multiply(matrix) {
let newR = this.clamp(this.r * matrix[0] + this.g * matrix[1] + this.b * matrix[2]);
let newG = this.clamp(this.r * matrix[3] + this.g * matrix[4] + this.b * matrix[5]);
let newB = this.clamp(this.r * matrix[6] + this.g * matrix[7] + this.b * matrix[8]);
this.r = newR; this.g = newG; this.b = newB;
}
（我们使用临时变量来保存每行乘法的结果，因为我们不希望对 等进行更改，从而影响后续计算。this.r
现在我们已经实现了 ，我们可以实现 、 和 ，它们只需使用给定的滤清矩阵调用它：<feColorMatrix>grayscale()sepia()saturate()
function grayscale(value = 1) {
this.multiply([
0.2126 + 0.7874 * (1 - value), 0.7152 - 0.7152 * (1 - value), 0.0722 - 0.0722 * (1 - value),
0.2126 - 0.2126 * (1 - value), 0.7152 + 0.2848 * (1 - value), 0.0722 - 0.0722 * (1 - value),
0.2126 - 0.2126 * (1 - value), 0.7152 - 0.7152 * (1 - value), 0.0722 + 0.9278 * (1 - value)
]);
}
function sepia(value = 1) {
this.multiply([
0.393 + 0.607 * (1 - value), 0.769 - 0.769 * (1 - value), 0.189 - 0.189 * (1 - value),
0.349 - 0.349 * (1 - value), 0.686 + 0.314 * (1 - value), 0.168 - 0.168 * (1 - value),
0.272 - 0.272 * (1 - value), 0.534 - 0.534 * (1 - value), 0.131 + 0.869 * (1 - value)
]);
}
function saturate(value = 1) {
this.multiply([
0.213 + 0.787 * value, 0.715 - 0.715 * value, 0.072 - 0.072 * value,
0.213 - 0.213 * value, 0.715 + 0.285 * value, 0.072 - 0.072 * value,
0.213 - 0.213 * value, 0.715 - 0.715 * value, 0.072 + 0.928 * value
]);
}
实施hue-rotate()
hue-rotate（） 滤镜由 <feColorMatrix type=“hueRotate” /> 实现。
滤波器矩阵的计算方法如下所示：
例如，元素 00 的计算方式如下：
笔记：
- 旋转角度以度为单位，在传递给 或 之前，必须将其转换为弧度。
Math.sin()Math.cos()
-
Math.sin(angle)并且应计算一次，然后进行缓存。Math.cos(angle)
实现：
function hueRotate(angle = 0) {
angle = angle / 180 * Math.PI;
let sin = Math.sin(angle);
let cos = Math.cos(angle);
this.multiply([
0.213 + cos * 0.787 - sin * 0.213, 0.715 - cos * 0.715 - sin * 0.715, 0.072 - cos * 0.072 + sin * 0.928,
0.213 - cos * 0.213 + sin * 0.143, 0.715 + cos * 0.285 + sin * 0.140, 0.072 - cos * 0.072 - sin * 0.283,
0.213 - cos * 0.213 - sin * 0.787, 0.715 - cos * 0.715 + sin * 0.715, 0.072 + cos * 0.928 + sin * 0.072
]);
}
实施和brightness()contrast()
brightness（） 和 contrast（） 滤镜由 <feComponentTransfer> <feFuncX type=“linear” /> 实现。
每个元素都接受斜率和截距属性。然后，它通过一个简单的公式计算每个新的颜色值：<feFuncX type="linear" />
value = slope * value + intercept
这很容易实现：
function linear(slope = 1, intercept = 0) {
this.r = this.clamp(this.r * slope + intercept * 255);
this.g = this.clamp(this.g * slope + intercept * 255);
this.b = this.clamp(this.b * slope + intercept * 255);
}
一旦实现了这一点，也可以实现：brightness()contrast()
function brightness(value = 1) { this.linear(value); }
function contrast(value = 1) { this.linear(value, -(0.5 * value) + 0.5); }
实施invert()
invert（） 过滤器由 <feComponentTransfer> <feFuncX type=“table” /> 实现。
该规范指出：
在下文中，C是初始分量，C'是重新映射的分量;两者都在闭合区间 [0，1] 中。
对于“表”，该函数是通过属性表中值中给定的值之间的线性插值来定义的。该表具有 n + 1 个值（即 v0 到 vn），用于指定 n 个大小均匀的插值区域的开始和结束值。插值使用以下公式：
对于值 C，找到 k，使得：
k / n ≤ C < （k + 1） / n
结果 C' 由下式给出：
C' = vk + （C - k / n） * n * （vk+1 - vk)
此公式的解释：
- 筛选器定义此表：[值，1 - 值]。这是 tableValues 或 v。
invert()
- 该公式定义 n，使得 n + 1 是表的长度。由于表的长度为 2，因此 n = 1。
- 该公式定义 k，其中 k 和 k + 1 是表的索引。由于该表有 2 个元素，因此 k = 0。
因此，我们可以将公式简化为：
C' = v0 + C * （v1 - v0)
内联表的值，我们剩下：
C' = 值 + C * （1 - 值 - 值）
再简化一点：
C' = 值 + C * （1 - 2 * 值）
规范将 C 和 C' 定义为 RGB 值，在 0-1 的范围内（而不是 0-255）。因此，我们必须在计算之前缩小值，并在计算后重新缩放它们。
因此，我们到达了我们的实现：
function invert(value = 1) {
this.r = this.clamp((value + (this.r / 255) * (1 - 2 * value)) * 255);
this.g = this.clamp((value + (this.g / 255) * (1 - 2 * value)) * 255);
this.b = this.clamp((value + (this.b / 255) * (1 - 2 * value)) * 255);
}
插曲：@Dave的蛮力算法
@Dave的代码生成 176，660 种滤波器组合，包括：
- 11 个筛选器 （0%， 10%， 20%， ...， 100%）
invert()
- 11 个筛选器 （0%， 10%， 20%， ...， 100%）
sepia()
- 20 个过滤器 （5%， 10%， 15%， ...， 100%）
saturate()
- 73 个过滤器（0 度、5 度、10 度、...、360 度）
hue-rotate()
它按以下顺序计算筛选器：
filter: invert(a%) sepia(b%) saturate(c%) hue-rotate(θdeg);
然后，它循环访问所有计算的颜色。一旦在公差范围内找到生成的颜色（所有RGB值都距离目标颜色在5个单位以内），它就会停止。
但是，这是缓慢且低效的。因此，我提出我自己的答案。
实施 SPSA
首先，我们必须定义一个损失函数，该函数返回滤镜组合产生的颜色与目标颜色之间的差异。如果滤波器是完美的，则损失函数应返回0。
我们将色差测量为两个指标之和：
- RGB 差异，因为目标是生成最接近的 RGB 值。
- HSL 差异，因为许多 HSL 值对应于滤镜（例如，色调大致与 、 饱和度相关 等）这将指导算法。
hue-rotate()saturate()
loss 函数将采用一个参数 – 一个过滤器百分比数组。
我们将使用以下过滤顺序：
filter: invert(a%) sepia(b%) saturate(c%) hue-rotate(θdeg) brightness(e%) contrast(f%);
实现：
function loss(filters) {
let color = new Color(0, 0, 0);
color.invert(filters[0] / 100);
color.sepia(filters[1] / 100);
color.saturate(filters[2] / 100);
color.hueRotate(filters[3] * 3.6);
color.brightness(filters[4] / 100);
color.contrast(filters[5] / 100);
let colorHSL = color.hsl();
return Math.abs(color.r - this.target.r)
+ Math.abs(color.g - this.target.g)
+ Math.abs(color.b - this.target.b)
+ Math.abs(colorHSL.h - this.targetHSL.h)
+ Math.abs(colorHSL.s - this.targetHSL.s)
+ Math.abs(colorHSL.l - this.targetHSL.l);
}
我们将尝试最小化损失函数，以便：
loss([a, b, c, d, e, f]) = 0
SPSA算法（网站，更多信息，论文，实现论文，参考代码）在这方面非常擅长。它旨在优化具有局部最小值，噪声/非线性/多元损失函数等的复杂系统，它已被用于调整国际象棋引擎。与许多其他算法不同，描述它的论文实际上是可以理解的（尽管付出了很大的努力）。
实现：
function spsa(A, a, c, values, iters) {
const alpha = 1;
const gamma = 0.16666666666666666;
let best = null;
let bestLoss = Infinity;
let deltas = new Array(6);
let highArgs = new Array(6);
let lowArgs = new Array(6);
for(let k = 0; k < iters; k++) {
let ck = c / Math.pow(k + 1, gamma);
for(let i = 0; i < 6; i++) {
deltas[i] = Math.random() > 0.5 ? 1 : -1;
highArgs[i] = values[i] + ck * deltas[i];
lowArgs[i] = values[i] - ck * deltas[i];
}
let lossDiff = this.loss(highArgs) - this.loss(lowArgs);
for(let i = 0; i < 6; i++) {
let g = lossDiff / (2 * ck) * deltas[i];
let ak = a[i] / Math.pow(A + k + 1, alpha);
values[i] = fix(values[i] - ak * g, i);
}
let loss = this.loss(values);
if(loss < bestLoss) { best = values.slice(0); bestLoss = loss; }
} return { values: best, loss: bestLoss };
function fix(value, idx) {
let max = 100;
if(idx === 2 /* saturate */) { max = 7500; }
else if(idx === 4 /* brightness */ || idx === 5 /* contrast */) { max = 200; }
if(idx === 3 /* hue-rotate */) {
if(value > max) { value = value % max; }
else if(value < 0) { value = max + value % max; }
} else if(value < 0) { value = 0; }
else if(value > max) { value = max; }
return value;
}
}
我对SPSA进行了一些修改/优化：
- 使用产生的最佳结果，而不是最后一个。
- 重用所有数组 （， 、 ），而不是在每次迭代时重新创建它们。
deltashighArgslowArgs
- 对 a 使用值数组，而不是单个值。这是因为所有的滤波器都是不同的，因此它们应该以不同的速度移动/收敛。
- 在每次迭代后运行函数。它将所有值钳制在 0% 和 100% 之间，除非（最大值为 7500%）和（最大值为 200%）和（值环绕而不是钳位）。
fixsaturatebrightnesscontrasthueRotate
我在两个阶段的过程中使用 SPSA：
- “宽”阶段，试图“探索”搜索空间。如果结果不令人满意，它将对 SPSA 进行有限的重试。
- “窄”阶段，从宽阶段获得最佳结果，并试图“完善”它。它对 A 和 a 使用动态值。
实现：
function solve() {
let result = this.solveNarrow(this.solveWide());
return {
values: result.values,
loss: result.loss,
filter: this.css(result.values)
};
}
function solveWide() {
const A = 5;
const c = 15;
const a = [60, 180, 18000, 600, 1.2, 1.2];
let best = { loss: Infinity };
for(let i = 0; best.loss > 25 && i < 3; i++) {
let initial = [50, 20, 3750, 50, 100, 100];
let result = this.spsa(A, a, c, initial, 1000);
if(result.loss < best.loss) { best = result; }
} return best;
}
function solveNarrow(wide) {
const A = wide.loss;
const c = 2;
const A1 = A + 1;
const a = [0.25 * A1, 0.25 * A1, A1, 0.25 * A1, 0.2 * A1, 0.2 * A1];
return this.spsa(A, a, c, wide.values, 500);
}
调整 SPSA
警告：不要弄乱 SPSA 代码，尤其是其常量，除非您确定自己知道自己在做什么。
重要的常量是 A、a、c、初始值、重试阈值、in 的值以及每个阶段的迭代次数。所有这些值都经过精心调整以产生良好的结果，随机拧紧它们几乎肯定会降低算法的有用性。maxfix()
如果你坚持要改变它，你必须在“优化”之前进行衡量。
首先，应用此修补程序。
然后在 Node.js 中运行代码。经过相当长的时间，结果应该是这样的：
Average loss: 3.4768521401985275
Average time: 11.4915ms
现在，将常量调整到您的心中。
一些提示：
- 平均损失应在4左右。如果它大于 4，则它产生的结果相差太远，您应该调整准确性。如果小于 4，则浪费时间，应减少迭代次数。
- 如果增加/减少迭代次数，请适当调整 A。
- 如果增加/减少 A，请适当调整 a。
- 如果要查看每次迭代的结果，请使用该标志。
--debug
TL;DR
