在前面幾篇文章中詳細介紹了MXNet的一些特點以及入門基礎知識，本篇文章主要介紹如何使用MXNet來訓練模型、加載模型進行預測、預訓練模型以及MXNet中GPU使用的相關知識。
在介紹訓練模型之前，先介紹MXNet如何使用GPU，因為后面訓練模型需要利用GPU來加速訓練。
在訓練神經網絡的時候，為了獲取一個效果比較好的模型通常都需要上萬級，甚至上億級的數據量，所以這需要強大的計算力，通過使用GPU能極大的提升計算機的運算速度，減少訓練時間。所以深度學習框架都會支持GPU，不過目前MXNet只支持NVIDA GPU，還不支持AMD GPU和Intel GPU。如果想要安裝MXNet GPU版本則需要先安裝Cuda和Cudnn，具體安裝方法在這里我就不詳細介紹了
windows系統請打開cmd輸入nvcc --version可以看到如下信息
通過上圖可以看出Cuda的版本是9.0的，所以在安裝MXNet GPU版本請用pip install mxnet-cu90進行安裝
如果是Ubuntu系統通過nvidia-smi命令查看Cuda的版本，然后再通過pip命令安裝即可
注意：安裝的MXNet的版本與cuda的版本不相符合，會導致報cuda* lib not found的錯誤
可以通過mxnet的test_utils包進行查看，代碼如下
import mxnet as mx #查看GPU的個數 mx.test_utils.list_gpus() #輸出 #range(0, 0)
通過結果可以發現，我的電腦上只有一個GPU，除此之外，還可以通過mxnet在創建NDArray時，調用不同的GPU，如果這個GPU不存在就會拋異常的特性來查看GPU的數量
for i in range(10):
try:
#通過ctx參數來選擇GPU
mx.nd.zeros((1,),ctx=mx.gpu(i))
except:
print("GPU num:%d"%i)
break
#輸出結果
GPU num:1
通過ctx參數可以指定數組創建在哪個GPU上，默認是GPU0，沒有指定ctx參數，默認是使用CPU
#使用GPU創建NDArray mx.nd.ones((3,4),ctx=mx.gpu()) """ [[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]] <NDArray 3x4 @gpu(0)> """
使用MXNet也很容易的再多個GPU之間進行通信，將某個數據拷貝到另一個GPU上，只需要執行以下代碼即可，其中x表示的是NDArray
注意：電腦沒有1個以上GPU執行以下代碼會報錯
x.copyto(gpu(1))
在之前的文章中有介紹過，如何使用MXNet的gluon模塊來創建一個神經網絡，這里我們將詳細介紹怎么樣來訓練網絡，將會介紹如何利用mxnet.init來初始化權重參數，利用datasets和tansforms來加載和轉換數據，通過matplotlib來可視化數據，通過time來統計計算時間
#導入相關包 from mxnet import nd,gluon,autograd,init from mxnet.gluon import nn from mxnet.gluon.data.vision import datasets,transforms from IPython import display import matplotlib.pyplot as plt import time
通過gluon.data.vision.datasets來自動的下載數據集，本次主要是構建一個分類網絡，來實現FasionMNIST數據集的分類，該數據集主要包含了一些服裝的類別，相對于MNIST數據集來說，分類難度稍微要大一些，接下來我們先來下載數據集。訓練集一共包含了60000張圖片，每張圖片的大小為28*28，一共有十種類別
#下載FashionMNIST數據集 fashionMNIST_trian=datasets.FashionMNIST(train=True) #獲取圖標和對應的標簽 images,labels=fashionMNIST_trian[:] #獲取數據的大小 #一共有60000張圖片,圖片大小是28*28 print(images.shape,labels.shape) #(60000, 28, 28, 1) (60000,) #輸出類別標簽,類別標簽是由0-9組成的類別,分別對應不同的服裝類型 print(labels[0]) #2
從訓練集中挑選出25張圖片來進行可視化顯示，便于更好的了解數據
def plot_show():
#設置每個類標的標簽
text_labels=["t-shirt","trouser","pullover","dress","coat",
"sandal","shirt","sneaker","bag","ankle boot"]
#從訓練集中選25個圖像可視化
part_images,part_labels=images[:25],labels[:25]
display.set_matplotlib_formats("svg")
_,figs=plt.subplots(5,5,figsize=(15,15))
for row in range(5):
for col in range(5):
f=figs[row][col]
#將3D圖片數據轉為2D便于可視化
f.imshow(part_images[row*5+col].reshape((28,28))
.asnumpy())
ax=f.axes
#設置標題
ax.set_title(text_labels[int(part_labels[row*5+col])])
#設置字體大小
ax.title.set_fontsize(14)
#隱藏坐標軸
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
在之前的文章中有介紹過使用gluon來構建模型，這里我們將詳細介紹如何利用gluo來訓練、加載、預訓練模型。
在前面可視化數據的時候介紹了通過gluon.vision.datasets來加載數據，在使用gluon構建模型的時候需要使用到這些數據，模型訓練的時候對于數據的格式有一定的要求(channel,height,width)并且要求數據是浮點類型。所以，我們還需要對之前的數據做一些轉換。利用transforms可以很方便的實現數據的轉換
#transforms鏈式轉換數據 transformer=transforms.Compose([ transforms.ToTensor(), transforms.Normalize(0.13,0.31)]) #轉換數據 fashion_data=fashion_train_data.transform_first(transformer)
通過ToTensor方法可以將圖片數據轉為(channel,height,width)的float類型的數據，通過Normalize方法可以設置數據的均值和標準差，這里將圖片的均值設置為0.13，標準差設置為0.31，最后再通過Compose將這些數據轉換過程組合成一個鏈式的處理。
由于內存的限制，在訓練模型的時候通常都是指定一個batch的數據進行迭代訓練，所以我們還需要將整個數據轉成一個batch迭代器，每次從這個迭代器中取一個batch數據進行訓練，gluon提供了一個DataLoader可以實現，而且通過num_workers參數來設置多個線程進行并行處理，但是在windows上測試的時候請將這個參數設置為0，避免線程錯誤問題
#設置batch的大小 batch_size=256 #在windows系統上,請將num_workers設置為0,否則會導致線程錯誤 train_data=gluon.data.DataLoader(fashion_data ,batch_size=batch_size,shuffle=True,num_workers=0) #每次從tran_data中取出一個batch大小的數據 for data,label in train_data: print(data.shape,label.shape)#(256, 1, 28, 28) (256,) break
使用gluon來構建一個LeNet的網絡結構，然后利用MXNet提供的GPU加速來訓練模型。MXNet可以很方便就能夠支持多個GPU同時加速訓練，在使用GPU加速訓練的時候，需要特別注意需要將參數和數據都放在GPU上，否則會出現錯誤。
訓練完成之后，保存模型文件的時候，MXNet提供了兩種不同的方式，在保存模型文件的時候，可以選擇只保存參數或同時保存參數和模型結構，通常參數是保存在.params文件中，模型結構是保存在.json文件中。如果只保存了參數，在加載模型的時候，則需要事先定義好網絡結構給網絡的參數賦值。如果有.json文件，則不需要定義網絡的結構，直接通過.josn文件加載即可。
#加載驗證數據
fashion_val_data=gluon.data.vision.FashionMNIST(train=False)
val_data=gluon.data.DataLoader(fashion_val_data.transform_first(transformer),
batch_size=batch_size,num_workers=0)
#定義使用的GPU,使用GPU加速訓練,如果有多個GPU,可以定義多個
gpu_devices=[mx.gpu(0)]
#定義網絡結構
LeNet=nn.Sequential()
#構建一個LeNet的網絡結構
LeNet.add(
nn.Conv2D(channels=6,kernel_size=5,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Conv2D(channels=16,kernel_size=3,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Flatten(),
nn.Dense(120,activation="relu"),
nn.Dense(84,activation="relu"),
nn.Dense(10)
)
#初始化神經網絡的權重參數,使用GPU來加速訓練
LeNet.collect_params().initialize(force_reinit=True,ctx=gpu_devices)
#定義softmax損失函數
softmax_cross_entropy=gluon.loss.SoftmaxCrossEntropyLoss()
#設置優化算法,使用隨機梯度下降sgd算法,學習率設置為0.1
trainer=gluon.Trainer(LeNet.collect_params(),"sgd",{"learning_rate":0.1})
#計算準確率
def acc(output,label):
return (output.argmax(axis=1)==label.astype("float32")).mean().asscalar()
#設置迭代的輪數
epochs=10
#訓練模型
for epoch in range(epochs):
train_loss,train_acc,val_acc=0,0,0
epoch_start_time=time.time()
for data,label in train_data:
#使用GPU來加載數據加速訓練
data_list=gluon.utils.split_and_load(data,gpu_devices)
label_list=gluon.utils.split_and_load(label,gpu_devices)
#前向傳播
with autograd.record():
#獲取多個GPU上的預測結果
pred_Y=[LeNet(x) for x in data_list]
#計算多個GPU上預測值的損失
losses=[softmax_cross_entropy(pred_y,Y) for pred_y,Y in zip(pred_Y,label_list)]
#反向傳播更新參數
for l in losses:
l.backward()
trainer.step(batch_size)
#計算訓練集上的總損失
train_loss +=sum([l.sum().asscalar() for l in losses])
#計算訓練集上的準確率
train_acc +=sum([acc(output_y,y) for output_y,y in zip(pred_Y,label_list)])
for data,label in val_data:
data_list=gluon.utils.split_and_load(data,ctx_list=gpu_devices)
label_list=gluon.utils.split_and_load(label,ctx_list=gpu_devices)
#計算驗證集上的準確率
val_acc +=sum(acc(LeNet(val_X),val_Y) for val_X,val_Y in zip(data_list,label_list))
print("epoch %d,loss:%.3f,train acc:%.3f,test acc:%.3f,in %.1f sec"%
(epoch+1,train_loss/len(labels),train_acc/len(train_data),val_acc/len(val_data),time.time()-epoch_start_time))
#保存模型參數
LeNet.save_parameters("LeNet.params")
想要同時將模型參數和模型結構保存為文件，其實也很簡單，只需要修改上面幾行代碼即可，將nn.Sequential修改為nn.HybridSequential，然后再添加調用hybridize()，將最后保存模型文件的代碼由save_parameters方法改為export，具體代碼如下
import mxnet as mx
from mxnet.gluon import nn
from mxnet import gluon,nd,autograd,init
from mxnet.gluon.data.vision import datasets,transforms
from IPython import display
import matplotlib.pyplot as plt
import time
import numpy as np
#下載fashionMNIST數據集
fashion_train_data=datasets.FashionMNIST(train=True)
#獲取圖片數據和對應的標簽
images,labels=fashion_train_data[:]
#transforms鏈式轉換數據
transformer=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(0.13,0.31)])
#轉換數據
fashion_data=fashion_train_data.transform_first(transformer)
#設置batch的大小
batch_size=256
#在windows系統上,請將num_workers設置為0,否則會導致線程錯誤
train_data=gluon.data.DataLoader(fashion_data,batch_size=batch_size,shuffle=True,num_workers=0)
#加載驗證數據
fashion_val_data=gluon.data.vision.FashionMNIST(train=False)
val_data=gluon.data.DataLoader(fashion_val_data.transform_first(transformer),
batch_size=batch_size,num_workers=0)
#定義使用的GPU,使用GPU加速訓練,如果有多個GPU,可以定義多個
gpu_devices=[mx.gpu(0)]
#定義網絡結構
LeNet=nn.HybridSequential()
#構建一個LeNet的網絡結構
LeNet.add(
nn.Conv2D(channels=6,kernel_size=5,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Conv2D(channels=16,kernel_size=3,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Flatten(),
nn.Dense(120,activation="relu"),
nn.Dense(84,activation="relu"),
nn.Dense(10)
)
LeNet.hybridize()
#初始化神經網絡的權重參數,使用GPU來加速訓練
LeNet.collect_params().initialize(force_reinit=True,ctx=gpu_devices)
#定義softmax損失函數
softmax_cross_entropy=gluon.loss.SoftmaxCrossEntropyLoss()
#設置優化算法,使用隨機梯度下降sgd算法,學習率設置為0.1
trainer=gluon.Trainer(LeNet.collect_params(),"sgd",{"learning_rate":0.1})
#計算準確率
def acc(output,label):
return (output.argmax(axis=1)==label.astype("float32")).mean().asscalar()
#設置迭代的輪數
epochs=10
#訓練模型
for epoch in range(epochs):
train_loss,train_acc,val_acc=0,0,0
epoch_start_time=time.time()
for data,label in train_data:
#使用GPU來加載數據加速訓練
data_list=gluon.utils.split_and_load(data,gpu_devices)
label_list=gluon.utils.split_and_load(label,gpu_devices)
#前向傳播
with autograd.record():
#獲取多個GPU上的預測結果
pred_Y=[LeNet(x) for x in data_list]
#計算多個GPU上預測值的損失
losses=[softmax_cross_entropy(pred_y,Y) for pred_y,Y in zip(pred_Y,label_list)]
#反向傳播更新參數
for l in losses:
l.backward()
trainer.step(batch_size)
#計算訓練集上的總損失
train_loss +=sum([l.sum().asscalar() for l in losses])
#計算訓練集上的準確率
train_acc +=sum([acc(output_y,y) for output_y,y in zip(pred_Y,label_list)])
for data,label in val_data:
data_list=gluon.utils.split_and_load(data,ctx_list=gpu_devices)
label_list=gluon.utils.split_and_load(label,ctx_list=gpu_devices)
#計算驗證集上的準確率
val_acc +=sum(acc(LeNet(val_X),val_Y) for val_X,val_Y in zip(data_list,label_list))
print("epoch %d,loss:%.3f,train acc:%.3f,test acc:%.3f,in %.1f sec"%
(epoch+1,train_loss/len(labels),train_acc/len(train_data),val_acc/len(val_data),time.time()-epoch_start_time))
#保存模型參數
LeNet.export("lenet",epoch=1)
#加載模型文件
LeNet=gluon.nn.SymbolBlock.imports("lenet-symbol.json",["data"],"lenet-0001.params")
在上面介紹了如何來訓練模型，并且保存模型文件，我們可以利用已經保存好的模型文件來做很多事情，如直接加載好訓練好的模型文件來預測數據、利用模型文件來進行微調等。
from mxnet.gluon import nn
from mxnet.gluon.data.vision import datasets,transforms
from IPython import display
import matplotlib.pyplot as plt
#構建模型
LeNet=nn.Sequential()
#注意模型的結果必須與訓練時的模型結構一模一樣
LeNet.add(
nn.Conv2D(channels=6,kernel_size=5,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Conv2D(channels=16,kernel_size=3,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Flatten(),
nn.Dense(units=120,activation="relu"),
nn.Dense(84,activation="relu"),
nn.Dense(10)
)
#加載模型
LeNet.load_parameters("LeNet.params")
#構建一個數據轉換器
transformer=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(0.13,0.31)
])
#獲取數據
mnist_valid=datasets.FashionMNIST(train=False)
X,Y=mnist_valid[:10]
preds=[]
for x in X:
x=transformer(x).expand_dims(axis=0)
#獲取預測結果
pred=LeNet(x).argmax(axis=1)
preds.append(pred.astype("int32").asscalar())
_,figs=plt.subplots(1,10,figsize=(15,15))
text_labels=['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
display.set_matplotlib_formats("svg")
for f,x,y,pred_y in zip(figs,X,Y,preds):
f.imshow(x.reshape((28,28)).asnumpy())
ax=f.axes
#顯示圖片的真實標簽和預測標簽
ax.set_title(text_labels[y]+"\n"+text_labels[pred_y])
#設置字體
ax.title.set_fontsize(14)
#隱藏坐標軸
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
Gluon model zoo提供了非常多的預訓練模型(AlexNet、DenseNet、Inception、ResNet、MobileNet等)，都是基于ImageNet數據訓練的，我們可以很方便的去加載這些模型，然后在我們自己的數據上進行微調，以獲取一個適合自己數據的模型。
gluon model zoo:
https://mxnet.incubator.apache.org/api/python/gluon/model_zoo.html
在前面幾篇文章中詳細介紹了MXNet的一些特點以及入門基礎知識，本篇文章主要介紹如何使用MXNet來訓練模型、加載模型進行預測、預訓練模型以及MXNet中GPU使用的相關知識。
在介紹訓練模型之前，先介紹MXNet如何使用GPU，因為后面訓練模型需要利用GPU來加速訓練。
在訓練神經網絡的時候，為了獲取一個效果比較好的模型通常都需要上萬級，甚至上億級的數據量，所以這需要強大的計算力，通過使用GPU能極大的提升計算機的運算速度，減少訓練時間。所以深度學習框架都會支持GPU，不過目前MXNet只支持NVIDA GPU，還不支持AMD GPU和Intel GPU。如果想要安裝MXNet GPU版本則需要先安裝Cuda和Cudnn，具體安裝方法在這里我就不詳細介紹了
windows系統請打開cmd輸入nvcc --version可以看到如下信息
通過上圖可以看出Cuda的版本是9.0的，所以在安裝MXNet GPU版本請用pip install mxnet-cu90進行安裝
如果是Ubuntu系統通過nvidia-smi命令查看Cuda的版本，然后再通過pip命令安裝即可
注意：安裝的MXNet的版本與cuda的版本不相符合，會導致報cuda* lib not found的錯誤
可以通過mxnet的test_utils包進行查看，代碼如下
import mxnet as mx #查看GPU的個數 mx.test_utils.list_gpus() #輸出 #range(0, 0)
通過結果可以發現，我的電腦上只有一個GPU，除此之外，還可以通過mxnet在創建NDArray時，調用不同的GPU，如果這個GPU不存在就會拋異常的特性來查看GPU的數量
for i in range(10):
try:
#通過ctx參數來選擇GPU
mx.nd.zeros((1,),ctx=mx.gpu(i))
except:
print("GPU num:%d"%i)
break
#輸出結果
GPU num:1
通過ctx參數可以指定數組創建在哪個GPU上，默認是GPU0，沒有指定ctx參數，默認是使用CPU
#使用GPU創建NDArray mx.nd.ones((3,4),ctx=mx.gpu()) """ [[1. 1. 1. 1.] [1. 1. 1. 1.] [1. 1. 1. 1.]] <NDArray 3x4 @gpu(0)> """
使用MXNet也很容易的再多個GPU之間進行通信，將某個數據拷貝到另一個GPU上，只需要執行以下代碼即可，其中x表示的是NDArray
注意：電腦沒有1個以上GPU執行以下代碼會報錯
x.copyto(gpu(1))
在之前的文章中有介紹過，如何使用MXNet的gluon模塊來創建一個神經網絡，這里我們將詳細介紹怎么樣來訓練網絡，將會介紹如何利用mxnet.init來初始化權重參數，利用datasets和tansforms來加載和轉換數據，通過matplotlib來可視化數據，通過time來統計計算時間
#導入相關包 from mxnet import nd,gluon,autograd,init from mxnet.gluon import nn from mxnet.gluon.data.vision import datasets,transforms from IPython import display import matplotlib.pyplot as plt import time
通過gluon.data.vision.datasets來自動的下載數據集，本次主要是構建一個分類網絡，來實現FasionMNIST數據集的分類，該數據集主要包含了一些服裝的類別，相對于MNIST數據集來說，分類難度稍微要大一些，接下來我們先來下載數據集。訓練集一共包含了60000張圖片，每張圖片的大小為28*28，一共有十種類別
#下載FashionMNIST數據集 fashionMNIST_trian=datasets.FashionMNIST(train=True) #獲取圖標和對應的標簽 images,labels=fashionMNIST_trian[:] #獲取數據的大小 #一共有60000張圖片,圖片大小是28*28 print(images.shape,labels.shape) #(60000, 28, 28, 1) (60000,) #輸出類別標簽,類別標簽是由0-9組成的類別,分別對應不同的服裝類型 print(labels[0]) #2
從訓練集中挑選出25張圖片來進行可視化顯示，便于更好的了解數據
def plot_show():
#設置每個類標的標簽
text_labels=["t-shirt","trouser","pullover","dress","coat",
"sandal","shirt","sneaker","bag","ankle boot"]
#從訓練集中選25個圖像可視化
part_images,part_labels=images[:25],labels[:25]
display.set_matplotlib_formats("svg")
_,figs=plt.subplots(5,5,figsize=(15,15))
for row in range(5):
for col in range(5):
f=figs[row][col]
#將3D圖片數據轉為2D便于可視化
f.imshow(part_images[row*5+col].reshape((28,28))
.asnumpy())
ax=f.axes
#設置標題
ax.set_title(text_labels[int(part_labels[row*5+col])])
#設置字體大小
ax.title.set_fontsize(14)
#隱藏坐標軸
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
在之前的文章中有介紹過使用gluon來構建模型，這里我們將詳細介紹如何利用gluo來訓練、加載、預訓練模型。
在前面可視化數據的時候介紹了通過gluon.vision.datasets來加載數據，在使用gluon構建模型的時候需要使用到這些數據，模型訓練的時候對于數據的格式有一定的要求(channel,height,width)并且要求數據是浮點類型。所以，我們還需要對之前的數據做一些轉換。利用transforms可以很方便的實現數據的轉換
#transforms鏈式轉換數據 transformer=transforms.Compose([ transforms.ToTensor(), transforms.Normalize(0.13,0.31)]) #轉換數據 fashion_data=fashion_train_data.transform_first(transformer)
通過ToTensor方法可以將圖片數據轉為(channel,height,width)的float類型的數據，通過Normalize方法可以設置數據的均值和標準差，這里將圖片的均值設置為0.13，標準差設置為0.31，最后再通過Compose將這些數據轉換過程組合成一個鏈式的處理。
由于內存的限制，在訓練模型的時候通常都是指定一個batch的數據進行迭代訓練，所以我們還需要將整個數據轉成一個batch迭代器，每次從這個迭代器中取一個batch數據進行訓練，gluon提供了一個DataLoader可以實現，而且通過num_workers參數來設置多個線程進行并行處理，但是在windows上測試的時候請將這個參數設置為0，避免線程錯誤問題
#設置batch的大小 batch_size=256 #在windows系統上,請將num_workers設置為0,否則會導致線程錯誤 train_data=gluon.data.DataLoader(fashion_data ,batch_size=batch_size,shuffle=True,num_workers=0) #每次從tran_data中取出一個batch大小的數據 for data,label in train_data: print(data.shape,label.shape)#(256, 1, 28, 28) (256,) break
使用gluon來構建一個LeNet的網絡結構，然后利用MXNet提供的GPU加速來訓練模型。MXNet可以很方便就能夠支持多個GPU同時加速訓練，在使用GPU加速訓練的時候，需要特別注意需要將參數和數據都放在GPU上，否則會出現錯誤。
訓練完成之后，保存模型文件的時候，MXNet提供了兩種不同的方式，在保存模型文件的時候，可以選擇只保存參數或同時保存參數和模型結構，通常參數是保存在.params文件中，模型結構是保存在.json文件中。如果只保存了參數，在加載模型的時候，則需要事先定義好網絡結構給網絡的參數賦值。如果有.json文件，則不需要定義網絡的結構，直接通過.josn文件加載即可。
#加載驗證數據
fashion_val_data=gluon.data.vision.FashionMNIST(train=False)
val_data=gluon.data.DataLoader(fashion_val_data.transform_first(transformer),
batch_size=batch_size,num_workers=0)
#定義使用的GPU,使用GPU加速訓練,如果有多個GPU,可以定義多個
gpu_devices=[mx.gpu(0)]
#定義網絡結構
LeNet=nn.Sequential()
#構建一個LeNet的網絡結構
LeNet.add(
nn.Conv2D(channels=6,kernel_size=5,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Conv2D(channels=16,kernel_size=3,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Flatten(),
nn.Dense(120,activation="relu"),
nn.Dense(84,activation="relu"),
nn.Dense(10)
)
#初始化神經網絡的權重參數,使用GPU來加速訓練
LeNet.collect_params().initialize(force_reinit=True,ctx=gpu_devices)
#定義softmax損失函數
softmax_cross_entropy=gluon.loss.SoftmaxCrossEntropyLoss()
#設置優化算法,使用隨機梯度下降sgd算法,學習率設置為0.1
trainer=gluon.Trainer(LeNet.collect_params(),"sgd",{"learning_rate":0.1})
#計算準確率
def acc(output,label):
return (output.argmax(axis=1)==label.astype("float32")).mean().asscalar()
#設置迭代的輪數
epochs=10
#訓練模型
for epoch in range(epochs):
train_loss,train_acc,val_acc=0,0,0
epoch_start_time=time.time()
for data,label in train_data:
#使用GPU來加載數據加速訓練
data_list=gluon.utils.split_and_load(data,gpu_devices)
label_list=gluon.utils.split_and_load(label,gpu_devices)
#前向傳播
with autograd.record():
#獲取多個GPU上的預測結果
pred_Y=[LeNet(x) for x in data_list]
#計算多個GPU上預測值的損失
losses=[softmax_cross_entropy(pred_y,Y) for pred_y,Y in zip(pred_Y,label_list)]
#反向傳播更新參數
for l in losses:
l.backward()
trainer.step(batch_size)
#計算訓練集上的總損失
train_loss +=sum([l.sum().asscalar() for l in losses])
#計算訓練集上的準確率
train_acc +=sum([acc(output_y,y) for output_y,y in zip(pred_Y,label_list)])
for data,label in val_data:
data_list=gluon.utils.split_and_load(data,ctx_list=gpu_devices)
label_list=gluon.utils.split_and_load(label,ctx_list=gpu_devices)
#計算驗證集上的準確率
val_acc +=sum(acc(LeNet(val_X),val_Y) for val_X,val_Y in zip(data_list,label_list))
print("epoch %d,loss:%.3f,train acc:%.3f,test acc:%.3f,in %.1f sec"%
(epoch+1,train_loss/len(labels),train_acc/len(train_data),val_acc/len(val_data),time.time()-epoch_start_time))
#保存模型參數
LeNet.save_parameters("LeNet.params")
想要同時將模型參數和模型結構保存為文件，其實也很簡單，只需要修改上面幾行代碼即可，將nn.Sequential修改為nn.HybridSequential，然后再添加調用hybridize()，將最后保存模型文件的代碼由save_parameters方法改為export，具體代碼如下
import mxnet as mx
from mxnet.gluon import nn
from mxnet import gluon,nd,autograd,init
from mxnet.gluon.data.vision import datasets,transforms
from IPython import display
import matplotlib.pyplot as plt
import time
import numpy as np
#下載fashionMNIST數據集
fashion_train_data=datasets.FashionMNIST(train=True)
#獲取圖片數據和對應的標簽
images,labels=fashion_train_data[:]
#transforms鏈式轉換數據
transformer=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(0.13,0.31)])
#轉換數據
fashion_data=fashion_train_data.transform_first(transformer)
#設置batch的大小
batch_size=256
#在windows系統上,請將num_workers設置為0,否則會導致線程錯誤
train_data=gluon.data.DataLoader(fashion_data,batch_size=batch_size,shuffle=True,num_workers=0)
#加載驗證數據
fashion_val_data=gluon.data.vision.FashionMNIST(train=False)
val_data=gluon.data.DataLoader(fashion_val_data.transform_first(transformer),
batch_size=batch_size,num_workers=0)
#定義使用的GPU,使用GPU加速訓練,如果有多個GPU,可以定義多個
gpu_devices=[mx.gpu(0)]
#定義網絡結構
LeNet=nn.HybridSequential()
#構建一個LeNet的網絡結構
LeNet.add(
nn.Conv2D(channels=6,kernel_size=5,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Conv2D(channels=16,kernel_size=3,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Flatten(),
nn.Dense(120,activation="relu"),
nn.Dense(84,activation="relu"),
nn.Dense(10)
)
LeNet.hybridize()
#初始化神經網絡的權重參數,使用GPU來加速訓練
LeNet.collect_params().initialize(force_reinit=True,ctx=gpu_devices)
#定義softmax損失函數
softmax_cross_entropy=gluon.loss.SoftmaxCrossEntropyLoss()
#設置優化算法,使用隨機梯度下降sgd算法,學習率設置為0.1
trainer=gluon.Trainer(LeNet.collect_params(),"sgd",{"learning_rate":0.1})
#計算準確率
def acc(output,label):
return (output.argmax(axis=1)==label.astype("float32")).mean().asscalar()
#設置迭代的輪數
epochs=10
#訓練模型
for epoch in range(epochs):
train_loss,train_acc,val_acc=0,0,0
epoch_start_time=time.time()
for data,label in train_data:
#使用GPU來加載數據加速訓練
data_list=gluon.utils.split_and_load(data,gpu_devices)
label_list=gluon.utils.split_and_load(label,gpu_devices)
#前向傳播
with autograd.record():
#獲取多個GPU上的預測結果
pred_Y=[LeNet(x) for x in data_list]
#計算多個GPU上預測值的損失
losses=[softmax_cross_entropy(pred_y,Y) for pred_y,Y in zip(pred_Y,label_list)]
#反向傳播更新參數
for l in losses:
l.backward()
trainer.step(batch_size)
#計算訓練集上的總損失
train_loss +=sum([l.sum().asscalar() for l in losses])
#計算訓練集上的準確率
train_acc +=sum([acc(output_y,y) for output_y,y in zip(pred_Y,label_list)])
for data,label in val_data:
data_list=gluon.utils.split_and_load(data,ctx_list=gpu_devices)
label_list=gluon.utils.split_and_load(label,ctx_list=gpu_devices)
#計算驗證集上的準確率
val_acc +=sum(acc(LeNet(val_X),val_Y) for val_X,val_Y in zip(data_list,label_list))
print("epoch %d,loss:%.3f,train acc:%.3f,test acc:%.3f,in %.1f sec"%
(epoch+1,train_loss/len(labels),train_acc/len(train_data),val_acc/len(val_data),time.time()-epoch_start_time))
#保存模型參數
LeNet.export("lenet",epoch=1)
#加載模型文件
LeNet=gluon.nn.SymbolBlock.imports("lenet-symbol.json",["data"],"lenet-0001.params")
在上面介紹了如何來訓練模型，并且保存模型文件，我們可以利用已經保存好的模型文件來做很多事情，如直接加載好訓練好的模型文件來預測數據、利用模型文件來進行微調等。
from mxnet.gluon import nn
from mxnet.gluon.data.vision import datasets,transforms
from IPython import display
import matplotlib.pyplot as plt
#構建模型
LeNet=nn.Sequential()
#注意模型的結果必須與訓練時的模型結構一模一樣
LeNet.add(
nn.Conv2D(channels=6,kernel_size=5,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Conv2D(channels=16,kernel_size=3,activation="relu"),
nn.MaxPool2D(pool_size=2,strides=2),
nn.Flatten(),
nn.Dense(units=120,activation="relu"),
nn.Dense(84,activation="relu"),
nn.Dense(10)
)
#加載模型
LeNet.load_parameters("LeNet.params")
#構建一個數據轉換器
transformer=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(0.13,0.31)
])
#獲取數據
mnist_valid=datasets.FashionMNIST(train=False)
X,Y=mnist_valid[:10]
preds=[]
for x in X:
x=transformer(x).expand_dims(axis=0)
#獲取預測結果
pred=LeNet(x).argmax(axis=1)
preds.append(pred.astype("int32").asscalar())
_,figs=plt.subplots(1,10,figsize=(15,15))
text_labels=['t-shirt', 'trouser', 'pullover', 'dress', 'coat',
'sandal', 'shirt', 'sneaker', 'bag', 'ankle boot']
display.set_matplotlib_formats("svg")
for f,x,y,pred_y in zip(figs,X,Y,preds):
f.imshow(x.reshape((28,28)).asnumpy())
ax=f.axes
#顯示圖片的真實標簽和預測標簽
ax.set_title(text_labels[y]+"\n"+text_labels[pred_y])
#設置字體
ax.title.set_fontsize(14)
#隱藏坐標軸
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.show()
Gluon model zoo提供了非常多的預訓練模型(AlexNet、DenseNet、Inception、ResNet、MobileNet等)，都是基于ImageNet數據訓練的，我們可以很方便的去加載這些模型，然后在我們自己的數據上進行微調，以獲取一個適合自己數據的模型。
gluon model zoo:
https://mxnet.incubator.apache.org/api/python/gluon/model_zoo.html