经过万能近似定理的铺垫,我们知道理论上如何实现万能近似函数了,接下来我们常识用 TS 实现它,不用任何库函数,只用最原生的代码编写所有逻辑。
再次强调,就像看再多全栈入门到精通也不如自己从零写一套博客系统一样,虽然现在机器学习的 python 库非常多,但自己动手从零开始实现程序对学习新知识来说非常重要。理论与实践要相互结合。
首先,我们考虑 API 如何设计。
API 设计
API 设计是开发任何接口的第一步,我们要实现的万能近似函数包括两个过程,第一是创建神经网络,第二是训练(可以训练任意多次,每次训练得到此时的 loss)。
先定义训练。为了训练,首先要定义 Training data 的结构,它由神经网络的输入输出决定。假定我们要实现的万能近似函数的输入输出都是数字,即可以表示一个高维函数,那么 Training data 的类型可以这么定义:
type TrainingData = TrainingItem[]
type TrainingItem = [number[], number[]]
也就是说,输入与输出可以是任意数量的数字,并且长度可以不等。
比如对于一个一元方程的 Training data 可以这么表示:
const trainingData: TrainingData = [
[[1], [3]],
[[2], [6]],
[[3], [9]],
];
每组 Training data input 和 output 的数量越多,表示的函数图像维度就越高,这里为了方便理解,我们用了单输入与单输出举例。
再定义创建神经网络。神经网络的架构包括该神经网络有几层,每层有几个神经元,每个神经元的启动函数是怎样的。为了简化,我们假设神经网络是 full connected(全连接) 的,即每个神经元的输入来自上一层所有神经元的输入。
每个输入层的定义如下:
interface Layer {
count: number;
activation: "sigmoid" | "relu"; // 支持 sigmoid 和 relu 两种启动函数
inputCount?: number; // 输入长度,仅第一层需要
}
一个最简单的神经网络创建函数设计如下:
const neuralNetwork = new NeuralNetwork({
trainingData: trainingData,
layers: [
{ count: 4, activation: "sigmoid", inputCount: 1 },
{ count: 1, activation: "sigmoid" },
],
});
上面的 layers
描述了两层神经网络,输入层有 1 个节点,中间层有 4 个节点,输出层有 1 个节点(只有第一个层需要定义 inputCount
,因为输入长度是未知的)。
一个最小化神经网络,至少要定义 training data 与神经网络每一层的结构,其中每一层结构的 count
代表神经元的数量,activation
代表启动函数类型。当然这样设计有一个小瑕疵,即每个 layer 的神经元启动函数都相同。
接着,就可以调用 fit()
进行训练:
neuralNetwork.fit(); // { loss: .. }
调用几次就训练几次,每次都返回当前的 loss 值,以判断训练是否有效收敛。
神经网络对象实体的设计
接下我们讨论 NeuralNetwork
类的实现。首先这个函数显然包含以下几个要素:
- 定义神经网络对象实体,并存储各节点参数,以便训练时可以不断调整该网络的参数。
- 定义 model function。
- 定义 loss function。
- 定义 optimization。
其中 optimization 环节是最难的,因为我们要根据输出的结果,对每一个参数求导,这个过程被称为 “反向传播”,我们后续单开一篇文章来说明。
这次我们先采用一种模拟的方式绕过反向传播的具体实现,让代码能跑起来,方便理解全流程。
回到神经网络对象实体的设计,我们再来看一次神经网络的结构图:
可以看到从第二层网络开始,每一层网络的值都是上一层所有节点分别乘以不同的 w 系数,再加上 b 系数,最后乘以 c 系数,因此我们可以把参数存在第二层节点上,分别是:
- w:
number[]
,表示上一层每个节点连接到该节点乘以的系数 w。 - b:
number
,表示该节点的常数系数 b。 - c:
number
,表示该节点的常数系数 c。
我们可以定义神经网络数据结构如下:
type NetworkStructor = Array<{
// 启动函数类型
activation: "sigmoid" | "relu";
// 节点
neurals: Array<{
/** 当前该节点的值 */
value: number | undefined;
/** 上一层每个节点连接到该节点乘以的系数 w */
w: Array<number>;
/** 该节点的常数系数 b */
b: number;
/** 该节点的常数系数 c */
c: number;
}>;
}>;
则我们根据用户传入的 layers
来初始化神经网络对象,并对每个参数赋予一个初始值:
class NeuralNetwork {
// 输入长度
private inputCount = 0;
// 网络结构
private networkStructor: NetworkStructor;
// 训练数据
private trainingData: TraningData;
constructor({
trainingData,
layers,
}: {
trainingData: TraningData;
layers: Layer[];
}) {
this.trainingData = trainingData;
this.inputCount = layers[0].inputCount!;
this.networkStructor = layers.map(({ activation, count }, index) => ({
activation,
neurals: Array.from({ length: count }).map(() => ({
value: undefined,
w: Array.from({
length: index === 0 ? this.inputCount : layers[index - 1].count,
}).map(() => getRandomNumber()),
b: getRandomNumber(),
c: getRandomNumber(),
})),
}));
}
}
如上代码所示,将参数中输入长度、神经网络结构、训练数据都分别记录了下来,其中给每个神经节点 w、b、c 从 [-3, 3] 的随机初始值。
这样,我们就拥有了包含完整信息的神经网络结构,接下来只要分别实现 model function、loss function、optimization 就行了。
model function 的设计
梳理一下 model function 的逻辑:Training data 每一条输入的长度为 inputCount
,它们 full connect 到 networkStructor
的第一层,然后经过后续所有层的处理最后达到输出层,输出层是一个数组。
modelFunction
的输入就是一个训练数据,输出是一个字符串数组,TraningItem
的结构上面已经提过:
type TrainingItem = [number[], number[]]
所以拿 traningItem
的第 0 项就是输入,modelFunction
就是根据输入得到预测的输出。
class NeuralNetwork {
/** 获取上一层神经网络各节点的值 */
private getPreviousLayerValues(layerIndex: number, trainingItem: TraningItem) {
if (layerIndex >= 0) {
return this.networkStructor[layerIndex].neurals.map((neural) => neural.value);
}
return trainingItem[0];
}
private modelFunction(trainingItem: TraningItem) {
this.networkStructor.forEach((layer, layerIndex) => {
layer.neurals.forEach((neural) => {
// 前置节点的值 * w 的总和
let weightCount = 0;
this.getPreviousLayerValues(layerIndex - 1, trainingItem).forEach(
(value, index) => {
weightCount += value * neural.w[index];
},
);
const activateResult = activate(layer.activation)(weightCount + neural.b);
neural.value = neural.c * activateResult;
});
});
// 输出最后一层网络的值
return this.networkStructor[this.networkStructor.length - 1].neurals.map(
(neural) => neural.value
);
}
}
modelFunction
函数的流程很简单,首先遍历类神经网络的每一层,计算其中每个神经元的值。
而计算这个值,取决于该网络上一层的每一个值,乘以权重 w,加上系数 b,并通过启动函数(activate
实现我们待会说)后再乘以系数 c。
第一层类神经网络的上一层来自于输入,从第二层开始,输入就来自于上一层神经网络,所以为了方便统一处理,定义了 visitPreviousLayerInputs
函数拿到上一层输入,兼容了第一层要从输入(Training data)拿的情况。
接下来是 activate
函数,它可以根据启动函数名生成对应的启动函数实现,代码如下:
const functionByType = (functionType: ActivationType) => (x: number) => {
switch (functionType) {
case "sigmoid":
return sigmoid(x);
// ...
}
};
const sigmoid = (z: number) => {
return 1 / (1 + Math.pow(Math.E, -z));
};
loss function 的设计
loss function 的输入也是 Training item,输出也是一个数字,这个数字就是 loss,越小越好。
计算 loss 有很多种选择,我们选择一种最简单的均方差:
class NeuralNetwork {
private lossFunction(trainingItem: TraningItem) {
// 预测值
const y = this.modelFunction(trainingItem);
// 实际值
const t = trainingItem[1];
// loss 最终值
let loss = 0;
for (let i = 0; i < y.length; i++) {
// l(t,y) = (t-y)²
loss += Math.pow(t[i] - y[i]!, 2);
}
return loss / y.length;
}
}
首先执行 modelFunction
拿到预测值,再把与实际值的平方差加总,除以 Training item 的长度,就得到了均方差。
optimization 的设计(模拟实现)
本来 optimazation 应该使用反向传播来实现,但因为实现比较复杂,我们在下一篇文章再说明。
但为了让故事完整,我们也可以采用迂回手段模拟 optimization 实现的:模拟求导。
把要求导的参数增加一个极小的值,其他参数不变,此时得到函数的输出减去上一次的函数值,就可以作为近似的偏导值,它反而最符合求导的本质:
optimization 的入参是 traningData
,返回值是此时的 loss。入参和出参与 lossFunction
一样,但这个函数是真的有在做优化,而 lossFunction
仅仅计算 loss。
模拟求导的实现有两个问题:
- 性能差,需要反复执行函数。
- 结果不精确,训练效果不好。
我们下一篇就来介绍反向传播。
总结
我们从零到一构建一个神经网络,包括以下几个部分:
- 神经网络 API 的设计。
- 神经网络类的框架实现。
- model function、loss function 的实现。
我们把 Training data 的每一项命名为 Training item,其中 model function、loss function 的入参是 Training item, optimization 的入参是 Training data,它们的含义分别如下:
modelFunction(traningItem)
: 输入一项训练数据,输出预测结果。lossFunction(traningItem)
: 输入一项训练数据,输出当前神经网络的 loss。optimization(traningData)
: 输入一组训练数据,让神经网络对该组训练数据进行一次 fit。
可以看到,神经网络训练好后,只需要调用 modelFunction
即可,不再需要求导,也不需要大量训练,调用成本相比训练时下降了好几个数量级。
因为篇幅问题,我们没有详细介绍 optimization
阶段,下一篇文章我们进入反向传播知识点。
原文链接:https://juejin.cn/post/7347229062164840457 作者:黄子毅