由核心机器驱动的连接模型。
kerNET的Python项目详细描述
kernet
kernet是一个简单的、高级的、基于pytorch的api，可以帮助您轻松构建由内核机器驱动的连接模型。它基于[pytorch]（http://pytorch.org/）以便使gpu加速成为可能（就像神经网络一样，这些模型需要在大矩阵上操作）。
内核本质上是pytorch加上一些额外的层，这些层是此类模型的构建块。
为了方便起见，还提供了一些更高级别的模型抽象，包括[本文]（https://arxiv.org/abs/1802.03774）中提出的多层内核网络（mlkn）。
教程]（http://pytorch.org/tutorials/beginner/blitz/neural嫒networks嫒tutorial.html嫒sphx glr初学者blitz神经网络教程py）。
希望您喜欢，任何建议或贡献将不胜感激！
——
多层核网络
在这个存储库中，您会发现一个预先构建但仍然高度可定制的mlkn模型。您可以像使用任何其他高级神经网络api一样，轻松配置网络的大小和一些其他特性。为了培训，除了Pythorch的所有本地方法外，我们还为您实现了[建议的分层方法]（https://arxiv.org/abs/1802.03774），因此您只需在几行代码中指定一些超参数就可以工作。本文中使用的一些数据集也很容易供您测试模型。
sklearn.datasets从sklearn.preprocessing导入标准scaler导入torch
从torch.autograd导入变量导入torch
=torch.cuda.floattensor
x=变量（torch.from_numpy（x）.type（dtype），需要_grad=false）
y=变量（torch.from_numpy（y）.type（dtype），需要_grad=false）
y[新的索引]
将数据平均分割成训练和测试
索引=len（x）//2
x训练，y训练=x[：索引]，y[：索引]
x测试，y测试=x[索引]，y[索引：
````
mlknassifier是一个预先构建的mlkn模型，已经配置了分层训练。它是为使用任意数量的类进行分类而实现的。
``python
from models.mlkn import mlknclassier
mlkn=mlknclassier（）
````
稍后运行并将第二层训练为rbfn）。``` kerlinear```是一个`` torch.nn.module``对象，它表示使用相同高斯核``k（x，y）=exp（` u 2^2/（2*sigma^2））```的一层内核机器。```西格玛控制s内核宽度。对于输入层中的``x```来说，传递给它一个随机样本（通常是训练集），您希望将内核机器放在它的中心，即``f（u）=∑i a（x，u）i k（x，u）+b``中的``{x，i}```。然后，这个集合是这个layer对象的一个属性，可以作为``layer.x```访问。对于非输入层，传递给``x``要将内核机器置于其中心的原始数据。在运行时，对于"n`````````````````````````````````````````````````````````````````````````````````````````````````````````````````python
mlkn.add````````````````````````````````````````````````````````````````````（x=x_列，out_dim=n_级，sigma=.1，bias=true））
```
对于大型数据集，由于内存不足，可能无法对整个训练集进行操作。在这种情况下，可以通过将训练集分解为几个较小的子集，并在每个子集上集中一个单独的"kerlinear"对象来交换并行性以获得足够的内存。这和把gram矩阵分解成一堆子矩阵是一样的，对数值结果没有任何影响。我们已经实现了一个``kerlinearsemble``类和一个helper函数```到`集成```来简化这个过程。下面的脚本将产生与前面添加层的方法相同的网络和计算结果。``` layer0``和`` layer1``被分成许多较小的网络，每个网络有30个中心，权重和偏差不变。
`` python
来自层。kerlinear import kerlinear
来自层。ensemble import kerlinearensemble
import backend as k
ensemble=true
批处理大小=30
layer0=kerlinear（x=x_train，外调=15，sigma=5，偏倚=true）
layer1=kerlinear（x=x火车，外调=n类，sigma=0.1，偏倚=true）
>如果不合拍：
mlkn.增加一层（layer0）
mlkn.增加一层（layer1）
else：
创建等价的合拍层，以便大数据集能够被装入内存
mlkn。增加一层（k.to _合拍（layer0，layer0，layer0，layer1，偏倚=true是的批处理大小）
mlkn.添加层（k.to_集成（layer1，批处理大小））
````
然后为每个层添加优化器。这适用于任何"torch.optim.optimizer"。每个优化器负责一个层，其添加顺序与层的顺序相同，即第一个添加的优化器将被分配到第一层（最接近输入的层）。对于每个优化器，可以将"params"指定给任何对象，当调用"fit"时，在训练网络之前，它将被自动覆盖为正确层的权重。让我们使用[adam]作为这个例子的优化器（https://arxiv.org/pdf/1412.6980.pdf）。注意，对于pytorch优化器，`` weight_decay``是l2范数正则化系数。
`` python
mlkn.add_优化器（torch.optim.adam（params=mlkn.parameters（），lr=1e-3，weight_decay=0.1））
mlkn.add_优化器（torch.optim.adam（params=mlkn.parameters（），lr=1e-3，weight_decay=.1））
```
指定输出层的损失函数，这与任何pytorch损失函数都适用，但让我们使用```torch.nn.crossentropyloss```来执行此分类任务。
``python
mlkn.add_loss（torch.nn.crossentropyloss（））
````
对于``n_epoch````，应该传递一个``int``元组，其中第一个数字指定用于训练第一层的时期数，等等。如果在每个时期对整个数据集进行随机洗牌，则``shuffle``将起作用。如果"accumulate-grad"为"true"，则权重仅在每个历元更新，而不是使用该历元中所有小批次的累积梯度更新每个小批次。如果设置为``false``，则每个小批量都会有一个更新。请注意，``fit```中的参数``x``是您希望在其上训练模型的训练集，它可能与您的内核机器以（初始化``kerlinear```对象时的参数``x```为中心）。
``python
mlkn.fit（
n撸epoch=（30，30），
batch撸size=30，
shuffle=true，
x=x撸train，
y=y撸train，
n撸class=n撸class，
cumulate撸grad=false
````对测试集和打印错误的预测。
``python
y_pred=mlkn.predict（x_test=x_test，batch_size=15）
err=mlkn.get_error（y_pred，y_test）
print（'错误率：{.2f}%'。格式（err.data[0]*100））
````
此示例可在[examples/mlkn_classifier.py]（https://github.com/michaelshiyu/kernet/tree/master/examples）上找到。我们还有更多的分类数据集供您试用。
——
使用反向传播训练mlkn
也就是说，它没有预先配置贪婪训练，因此更容易用标准的反向传播和一些基于梯度的优化来训练它。此外，它并没有被定义为分类器，而是一个通用的学习机器：无论你用mlp做什么，你都可以用mlkn做。
首先我们实例化一个模型。
``python
import torch
from models.mlkn import mlkn
mlkn=mlkn（）
````
也支持集成层。
`` python
来自层。kerlinear导入kerlinear
mlkn。添加层（kerlinear（x=x~u列，out~dim=15，sigma=5，bias=true））
mlkn。添加层（kerlinear（x=x~u列，out~dim=n~u类，sigma=1，bias=true））
````
对于回归，维度应调整输出层。
``python
mlkn.add_layer（kerlinear（keru dim=x_train.shape[0]，out_dim=y_train.shape[1]，sigma=.1，bias=true））
```
这适用于任何"torch.optim.optimizer"。与分层训练不同，这里有一个优化器负责整个网络的训练，因为我们使用反向传播。当然，这并不意味着所有层都必须在完全相同的设置下进行训练：您仍然可以为每一层指定[每参数选项]（http://pytorch.org/docs/master/optim.html）。
`` python
mlkn.add_optimizer（torch.optim.adam（params=mlkn.parameters（），lr=1e-3，重量衰减=0.1）
````
指定损失函数。对于分类，`` torch.nn.crossentropyloss``可能是一个理想的选项，而对于回归，`` torch.nn.mseloss``则是一个常见的选项。
`` python
mlkn.add庀loss（torch.nn.crossentropyloss（））
````
，或者对于回归，
`` python
mlkn.添加损耗（torch.n n.mseloss（））
````
训练模型并评估给定测试集的输出。
`` python
mlkn.fit（
n-epoch=30，
批大小=30，
shuffle=true，
x=x-u-train，
y=y-train，
累加梯度=true
）
y_raw=mlkn.evaluate（x_test=x_test，批处理大小=15）
````
尺寸=1）
y_pred=y_pred.type_as（y_test）
err=（y_pred！=y庠test.sum（）.type（torch.floattensor.floattensor.div（y庠test.shape[0]）
print（'错误率：{.2f}%'.format（err.data[0]*100]
````
/>``回归，
``python
mse=torch.nn.mseless.mseless（）
print（'mse：{.4f}.format（mse（y庠raw，y_test test.y数据[0]））
```` ` ` ` `/>此示例可用在[examples/mlkn_generic.py]（https://github.com/michaelshiyu/kernet/tree/master/examples）。一些分类和回归数据集可供您试用。
欢迎加入QQ群-->： 979659372
