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)))