关于人工智能:Keras-vs-PyTorch-vs-CaffeCNN实现对比

作者 |PRUDHVI VARMA
编译 |VK
起源 |Analytics Indiamag

在当今世界，人工智能已被大多数商业运作所利用，而且因为先进的深度学习框架，它非常容易部署。这些深度学习框架提供了高级编程接口，帮忙咱们设计深度学习模型。应用深度学习框架，它通过提供内置的库函数来缩小开发人员的工作，从而使咱们可能更快更容易地构建模型。

在本文中，咱们将构建雷同的深度学习框架，即在 Keras、PyTorch 和 Caffe 中对同一数据集进行卷积神经网络图像分类，并对所有这些办法的实现进行比拟。最初，咱们将看到 PyTorch 构建的 CNN 模型如何优于内置 Keras 和 Caffe 的同行。

如何抉择深度学习框架。
Keras 的优缺点
PyTorch 的优缺点
Caffe 的优缺点
在 Keras、PyTorch 和 Caffe 实现 CNN 模型。

在抉择深度学习框架时，有一些指标能够找到最好的框架，它应该提供并行计算、良好的运行模型的接口、大量内置的包，它应该优化性能，同时也要思考咱们的业务问题和灵活性，这些是咱们在抉择深度学习框架之前要思考的根本问题。让咱们比拟三个最罕用的深度学习框架 Keras、Pytorch 和 Caffe。

Keras 是一个开源框架，由 Google 工程师 Francois Chollet 开发，它是一个深度学习框架，咱们只需编写几行代码，就能够轻松地应用和评估咱们的模型。

如果你不相熟深度学习，Keras 是初学者最好的入门框架，Keras 对初学者非常敌对，并且易于与 python 一起工作，并且它有许多预训练模型（VGG、Inception 等）。不仅易于学习，而且它反对 Tensorflow 作为后端。

Keras 须要改良一些个性
咱们须要就义速度来换取它的用户敌对性
有时甚至应用 gpu 也须要很长时间。

在上面的代码片段中，咱们将导入所需的库。

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K

超参数：

batch_size = 128
num_classes = 10
epochs = 12
img_rows, img_cols = 28, 28
(x_train, y_train), (x_test, y_test) = mnist.load_data()

在上面的代码片段中，咱们将构建一个深度学习模型，其中蕴含几个层，并调配优化器、激活函数和损失函数。

model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adam(),
              metrics=['accuracy'])

在上面的代码片段中，咱们将训练和评估模型。

model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

PyTorch 是一个由 Facebook 钻研团队开发的开源框架，它是深度学习模型的一种实现，它提供了 python 环境提供的所有服务和性能，它容许主动微分，有助于减速反向流传过程，PyTorch 提供了各种模块，如 torchvision，torchaudio，torchtext，能够灵便地在 NLP 中工作，计算机视觉。PyTorch 对于钻研人员比开发人员更灵便。

PyTorch 在钻研人员中比在开发人员中更受欢迎。
它不足生产力。

装置所需的库

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.data.dataloader as dataloader
import torch.optim as optim
from torch.utils.data import TensorDataset
from torchvision import transforms
from torchvision.datasets import MNIST

在上面的代码片段中，咱们将加载数据集并将其拆分为训练集和测试集。

train = MNIST('./data', train=True, download=True, transform=transforms.Compose([transforms.ToTensor(), 
]), )
test = MNIST('./data', train=False, download=True, transform=transforms.Compose([transforms.ToTensor(),
]), )
dataloader_args = dict(shuffle=True, batch_size=64,num_workers=1, pin_memory=True)
train_loader = dataloader.DataLoader(train, **dataloader_args)
test_loader = dataloader.DataLoader(test, **dataloader_args)
train_data = train.train_data
train_data = train.transform(train_data.numpy())

在上面的代码片段中，咱们将构建咱们的模型，并设置激活函数和优化器。

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.fc1 = nn.Linear(784, 548)
        self.bc1 = nn.BatchNorm1d(548) 
        self.fc2 = nn.Linear(548, 252)
        self.bc2 = nn.BatchNorm1d(252)
        self.fc3 = nn.Linear(252, 10)              
    def forward(self, x):
        a = x.view((-1, 784))
        b = self.fc1(a)
        b = self.bc1(b)
        b = F.relu(b)
        b = F.dropout(b, p=0.5) 
        b = self.fc2(b)
        b = self.bc2(b)
        b = F.relu(b)
        b = F.dropout(b, p=0.2)
        b = self.fc3(b)
        out = F.log_softmax(b)
        return out
model = Model()
model.cuda()
optimizer = optim.SGD(model.parameters(), lr=0.001)

在上面的代码片段中，咱们将训练咱们的模型，在训练时，咱们将指定损失函数，即穿插熵。

model.train()
losses = []
for epoch in range(12):
    for batch_idx, (data,data_1) in enumerate(train_loader):
        data,data_1 = Variable(data.cuda()), Variable(target.cuda())
        optimizer.zero_grad()
        y_pred = model(data) 
        loss = F.cross_entropy(y_pred, target)
        losses.append(loss.data[0])
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 1:
            print('\r Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, 
                batch_idx * len(data), 
                len(train_loader.dataset), 100. * batch_idx / len(train_loader),
                                loss.data[0]), 
                end='')         
    print()

# 评估模型

evaluate=Variable(test_loader.dataset.test_data.type_as(torch.FloatTensor())).cuda()
output = model(evaluate)
predict = output.data.max(1)[1]
pred = pred.eq(evaluate.data)
accuracy = pred.sum()/pred.size()[0]
print('Accuracy:', accuracy)

Caffe（Convolutional Architecture for Fast Feature Embedding）是 Yangqing Jia 开发的开源深度学习框架。该框架反对人工智能畛域的钻研人员和工业利用。

大部分开发者应用 Caffe 是因为它的速度，它应用一个 NVIDIA K40 GPU 每天能够解决 6000 万张图像。Caffe 有很多贡献者来更新和保护框架，而且与深度学习的其余畛域相比，Caffe 在计算机视觉模型方面工作得很好。

Caffe 没有更高级别的 API，所以很难做试验。

在 Caffe 中，为了部署咱们的模型，咱们须要编译源代码。

!apt install -y caffe-tools-cpu

import os
import numpy as np
import math
import caffe
import lmdb

在上面的代码片段中，咱们将指定硬件环境。

os.environ["GLOG_minloglevel"] = '2'
CAFFE_ROOT="/caffe"
os.chdir(CAFFE_ROOT) 
USE_GPU = True
if USE_GPU:
    caffe.set_device(0)
    caffe.set_mode_gpu()
else:
    caffe.set_mode_cpu()
caffe.set_random_seed(1) 
np.random.seed(24)

在上面的代码片段中，咱们将定义有助于数据转换的 image_generator 和 batch_generator。

def image_generator(db_path):
    db_handle = lmdb.open(db_path, readonly=True) 
    with db_handle.begin() as db:
        cur = db.cursor() 
        for _, value in cur: 
            datum = caffe.proto.caffe_pb2.Datum()
            datum.ParseFromString(value) 
            int_x = caffe.io.datum_to_array(datum) 
            x = np.asfarray(int_x, dtype=np.float32) t
            yield x - 128 

def batch_generator(shape, db_path):
    gen = image_generator(db_path)
    res = np.zeros(shape) 
    while True: 
        for i in range(shape[0]):
            res[i] = next(gen) 

        yield res

在上面的代码片段中，咱们将给出 MNIST 数据集的门路。

num_epochs = 0 
iter_num = 0 
db_path = "content/mnist/mnist_train_lmdb"
db_path_test = "content/mnist/mnist_test_lmdb"
base_lr = 0.01
gamma = 1e-4
power = 0.75

for epoch in range(num_epochs):
    print("Starting epoch {}".format(epoch))
    input_shape = net.blobs["data"].data.shape
    for batch in batch_generator(input_shape, db_path):
        iter_num += 1
        net.blobs["data"].data[...] = batch
        net.forward()
        for name, l in zip(net._layer_names, net.layers):
            for b in l.blobs:
                b.diff[...] = net.blob_loss_weights[name]
        net.backward()
        learning_rate = base_lr * math.pow(1 + gamma * iter_num, - power)
        for l in net.layers:
            for b in l.blobs:
                b.data[...] -= learning_rate * b.diff
        if iter_num % 50 == 0:
            print("Iter {}: loss={}".format(iter_num, net.blobs["loss"].data))
        if iter_num % 200 == 0:
            print("Testing network: accuracy={}, loss={}".format(*test_network(test_net, db_path_test)))

应用上面的代码片段，咱们将取得最终的准确性。

print("Training finished after {} iterations".format(iter_num))
print("Final performance: accuracy={}, loss={}".format(*test_network(test_net, db_path_test)))

在本文中，咱们演示了应用三个驰名框架：Keras、PyTorch 和 Caffe 实现 CNN 图像分类模型的。咱们能够看到，PyTorch 开发的 CNN 模型在精确度和速度方面都优于在 Keras 和 Caffe 开发的 CNN 模型。

作为一个初学者，我一开始应用 Keras，这对于初学者是一个非常简单的框架，但它的利用是无限的。然而 PyTorch 和 Caffe 在速度、优化和并行计算方面是十分弱小的框架。

原文链接：https://analyticsindiamag.com…

欢送关注磐创 AI 博客站：
http://panchuang.net/

sklearn 机器学习中文官网文档：
http://sklearn123.com/

欢送关注磐创博客资源汇总站：
http://docs.panchuang.net/

关于人工智能:Keras-vs-PyTorch-vs-CaffeCNN实现对比

本文波及的主题

抉择深度学习框架

Keras

应用 Keras 的局限性

应用 Keras 框架的理论实现

PyTorch

PyTorch 的局限性

应用 PyTorch 框架实现

Caffe

Caffe 的局限性

装置 Caffe

导入所需的库

论断