Cogitare - 用于Python的现代,快速和模块化深度学习和机器学习框架

Song • 867 次浏览 • 0 个回复 • 2018年02月23日

1.关于About

Cogitare通过简单的界面来使用PyTorchDaskNumPy和其他工具中最好的工具来训练,评估,测试模型等等。

借助Cogitare,您可以使用高性能的经典机器学习算法并快速开发最先进的模型。

具体查看http://tutorials.cogitare-ai.org/上的教程。

Cogitare的主要目标是:

  • 提供易用的界面来训练和评估模型;
  • 提供调试和分析模型的工具;
  • 提供最先进的模型(常见任务的模型,准备好训练并准备使用)的实现;
  • 提供直接和经典模型(如LogisticRegression)的即用型实现;
  • 与广泛问题的模型兼容;
  • 与其他工具兼容(scikit-learn等);
  • 与社区保持共同发展:接受尽可能多的新功能;
  • 为初学者提供友好的界面,并为专家提供强大的功能;
  • 通过多进程和多线程充分利用硬件;
  • 和别的。 目前,这是一个正在进行的项目,旨在为机器学习和深度学习开发提供完整的工具链,充分利用cuda和多核处理能力。

2.安装

  • 通过pytorch官网安装PyTorch
  • 使用PIP安装Cogitare
    pip install cogitare
  • Cogitare正在开发中,因此建议从GitHub获取最新版本。要直接从GitHub安装,请使用:
    pip install -e git+https://github.com/cogitare-ai/cogitare#egg=cogitare

    3.快速入门

    这是开始使用Cogitare主要功能的简单教程。

在本教程中,我们将编写一个卷积神经网络(CNN)来对手写数字进行分类(MNIST)。

3.1 Model

我们首先定义我们的CNN模型。

使用Cogitare开发模型时,您的模型必须扩展cogitare.Model类。这个类提供了模型接口,它允许你有效地训练和评估模型。

要实现一个模型,你必须扩展cogitare.Model类并实现forward()loss()方法。forward方法将收到该批次。这样就有必要在这个方法中实现网络的正向传递,然后返回网络的输出。loss方法将接收forward()从迭代器收到的批处理和批处理的输出,应用loss函数,计算并返回它。

Model接口将遍历数据集,并在forwardlossbackward上执行每批次。

# adapted from https://github.com/pytorch/examples/blob/master/mnist/main.py
from cogitare import Model
from cogitare import utils
from cogitare.data import DataSet, AsyncDataLoader
from cogitare.plugins import EarlyStopping
from cogitare.metrics.classification import accuracy
import cogitare

import torch.nn as nn
import torch
import torch.nn.functional as F
from torch.nn.utils import clip_grad_norm
import torch.optim as optim

from sklearn.datasets import fetch_mldata

import numpy as np

CUDA = True

cogitare.utils.set_cuda(CUDA)
class CNN(Model):

    def __init__(self):
        super(CNN, self).__init__()

        # define the model
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, batch):
        # in this sample, each batch will be a tuple containing (input_batch, expected_batch)
        # in forward in are only interested in input so that we can ignore the second item of the tuple
        input, _ = batch

        # batch X flat tensor -> batch X 1 channel (gray) X width X heigth
        input = input.view(32, 1, 28, 28)

        # pass the data in the net
        x = F.relu(F.max_pool2d(self.conv1(input), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)

        # return the model output
        return F.log_softmax(x, dim=1)

    def loss(self, output, batch):
        # in this sample, each batch will be a tuple containing (input_batch, expected_batch)
        # in loss in are only interested in expected so that we can ignore the first item of the tuple
        _, expected = batch

        return F.nll_loss(output, expected)

模型类很简单; 它只需要forwardloss方法。默认情况下,Cogitare将倒退该loss()方法返回的损失,并优化模型参数。如果您想禁用Cogitare backward和优化步骤,只需返回None丢失功能。如果您返回None,则您需要对参数进行backwarding和优化。

3.2数据加载

在这一步中,我们将从sklearn包加载数据。

mnist = fetch_mldata('MNIST original')
mnist.data = (mnist.data / 255).astype(np.float32)

Cogitare提供了一个工具箱来为您的模型加载和预处理数据。在这个介绍中,我们将使用DataSetAsyncDataLoader作为例子。

DataSet是通过遍历倍数的数据迭代器负责(在我们的例子中,我们有两个数据迭代器:输入样本,预计样本)。

# as input, the DataSet is expected a list of iterators. In our case, the first iterator is the input 
# data and the second iterator is the target data

# also, we set the batch size to 32 and enable the shuffling

# drop the last batch if its size is different of 32
data = DataSet([mnist.data, mnist.target.astype(int)], batch_size=32, shuffle=True, drop_last=True)

# then, we split our dataset into a train and into a validation sets, by a ratio of 0.8
data_train, data_validation = data.split(0.8)

请注意,Cogitare接受任何迭代器作为输入。您可以使用mnist.data本身,PyTorch的数据加载器或任何其他用作迭代器的输入来代替使用我们的DataSet

在某些情况下,我们可以通过使用多线程/进程加载数据或在模型请求之前预加载数据来提高模型性能。

有了AsyncDataLoader,我们可以在并行的模型执行之前加载N个批次。我们在本示例中介绍了此技术,因为它可以提高各种模型(数据加载或预处理比模型执行速度慢)中的性能。

def pre_process(batch):
    input, expected = batch

    # the data is a numpy.ndarray (loaded from sklearn), so we need to convert it to Variable
    input = utils.to_variable(input, dtype=torch.FloatTensor)  # converts to a torch Variable of LongTensor
    expected = utils.to_variable(expected, dtype=torch.LongTensor)  # converts to a torch Variable of LongTensor
    return input, expected

# we wrap our data_train and data_validation iterators over the async data loader.
# each loader will load 16 batches ahead of the model execution using 8 workers (8 threads, in this case).
# for each batch, it will be pre-processed in parallel with the preprocess function, that will load the data
# on GPU
data_train = AsyncDataLoader(data_train, buffer_size=16, mode='threaded', workers=8, on_batch_loaded=pre_process)
data_validation = AsyncDataLoader(data_validation, buffer_size=16, mode='threaded', workers=8, on_batch_loaded=pre_process)

在训练之前缓存异步缓冲区,我们可以:

data_train.cache()
data_validation.cache()

3.3 训练模型

现在,我们可以训练我们的模型。

首先,让我们创建模型实例并添加默认插件来观察训练状态。默认插件包括:

  • 每批次和时代的进度条
  • 绘制训练和验证损失(如果存在validation_dataset)
  • 记录训练损失
    model = CNN()
    model.register_default_plugins()

    除此之外,我们可能还想添加一些额外的插件,例如EarlyStopping。因此,如果模型N个批次后没有减少损失,那么将会停止训练并使用最佳模型。

要添加早期停止算法,您可以使用:

early = EarlyStopping(max_tries=10, path='/tmp/model.pt')
# after 10 epochs without decreasing the loss, stop the training and the best model is saved at /tmp/model.pt

# the plugin will execute in the end of each epoch
model.register_plugin(early, 'on_end_epoch')

另外,常见的技术是在训练过程中剪切梯度。如果你想剪切梯度,你可以使用:

model.register_plugin(lambda *args, **kw: clip_grad_norm(model.parameters(), 1.0), 'before_step')
# will execute the clip_grad_norm before each optimization step

现在,我们定义优化器,然后开始模型训练:

optimizer = optim.Adam(model.parameters(), lr=0.001)

if CUDA:
    model = model.cuda()
model.learn(data_train, optimizer, data_validation, max_epochs=100)
2018-02-02 20:59:23 sprawl cogitare.core.model[2443] INFO Model: 

CNN(
  (conv1): Conv2d (1, 10, kernel_size=(5, 5), stride=(1, 1))
  (conv2): Conv2d (10, 20, kernel_size=(5, 5), stride=(1, 1))
  (conv2_drop): Dropout2d(p=0.5)
  (fc1): Linear(in_features=320, out_features=50)
  (fc2): Linear(in_features=50, out_features=10)
)

2018-02-02 20:59:23 sprawl cogitare.core.model[2443] INFO Training data: 

DataSet with:
    containers: [
        TensorHolder with 1750x32 samples
    TensorHolder with 1750x32 samples
    ],
    batch size: 32

2018-02-02 20:59:23 sprawl cogitare.core.model[2443] INFO Number of trainable parameters: 21,840
2018-02-02 20:59:23 sprawl cogitare.core.model[2443] INFO Number of non-trainable parameters: 0
2018-02-02 20:59:23 sprawl cogitare.core.model[2443] INFO Total number of parameters: 21,840
2018-02-02 20:59:23 sprawl cogitare.core.model[2443] INFO Starting the training ...
2018-02-02 21:02:04 sprawl cogitare.core.model[2443] INFO Training finished

Stopping training after 10 tries. Best score 0.0909
Model restored from: /tmp/model.pt

检查验证数据集上的模型损失和准确性:

Cogitare - 用于Python的现代,快速和模块化深度学习和机器学习框架

def model_accuracy(output, data):
    _, indices = torch.max(output, 1)

    return accuracy(indices, data[1])

# evaluate the model loss and accuracy over the validation dataset
metrics = model.evaluate_with_metrics(data_validation, {'loss': model.metric_loss, 'accuracy': model_accuracy})

# the metrics is an dict mapping the metric name (loss or accuracy, in this sample) to a list of the accuracy output
# we have a measurement per batch. So, to have a value of the full dataset, we take the mean value:

metrics_mean = {'loss': 0, 'accuracy': 0}
for loss, acc in zip(metrics['loss'], metrics['accuracy']):
    metrics_mean['loss'] += loss
    metrics_mean['accuracy'] += acc.data[0]

qtd = len(metrics['loss'])

print('Loss: {}'.format(metrics_mean['loss'] / qtd))
print('Accuracy: {}'.format(metrics_mean['accuracy'] / qtd))
Loss: 0.10143917564566948
Accuracy: 0.9846252860411899

Cogitare的优势之一就是即插即用的API,它可以让您轻松添加/删除功能。通过这个样本,我们很容易地训练了一个带有训练进度条,误差绘图,提前停止,修剪和模型评估的模型。


原创文章,转载请注明 :Cogitare - 用于Python的现代,快速和模块化深度学习和机器学习框架 - pytorch中文网
原文出处: https://ptorch.com/news/130.html
问题交流群 :168117787
提交评论
要回复文章请先登录注册
用户评论
  • 没有评论
Pytorch是什么?关于Pytorch! PyTorch聚类算法实现及其优化的扩展库(pytorch_cluster)