Keras vs PyTorch vs Caffe：CNN实现对比

时间 2020-08-28

标签 keras pytorch caffe cnn 实现对比繁體版

原文原文链接

做者|PRUDHVI VARMA
编译|VK
来源|Analytics Indiamagpython

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

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

本文涉及的主题

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

选择深度学习框架

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

Keras

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

若是你不熟悉深度学习，Keras是初学者最好的入门框架，Keras对初学者十分友好，而且易于与python一块儿工做，而且它有许多预训练模型（VGG、Inception等）。不只易于学习，并且它支持Tensorflow做为后端。框架

使用Keras的局限性

Keras须要改进一些特性
咱们须要牺牲速度来换取它的用户友好性
有时甚至使用gpu也须要很长时间。

使用Keras框架的实际实现

在下面的代码片断中，咱们将导入所需的库。dom

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

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

PyTorch的局限性

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

Caffe（Convolutional Architecture for Fast Feature Embedding）是Yangqing Jia开发的开源深度学习框架。该框架支持人工智能领域的研究人员和工业应用。

大部分开发者使用Caffe是由于它的速度，它使用一个NVIDIA K40 GPU天天能够处理6000万张图像。Caffe有不少贡献者来更新和维护框架，并且与深度学习的其余领域相比，Caffe在计算机视觉模型方面工做得很好。

Caffe的局限性

Caffe没有更高级别的API，因此很难作实验。

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

安装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/