4.5. 读取和存储

    我们可以直接使用函数和load函数分别存储和读取NDArray。下面的例子创建了NDArray变量x，并将其存在文件名同为x的文件里。

    1. from mxnet import nd
    2. from mxnet.gluon import nn
    3.  
    4. x = nd.ones(3)
    5. nd.save('x', x)

    然后我们将数据从存储的文件读回内存。

    1. In [2]:
    1. x2 = nd.load('x')
    2. x2
    1. Out[2]:
    1. [
    2.  [1. 1. 1.]
    3.  <NDArray 3 @cpu(0)>]
    1. In [3]:
    1. y = nd.zeros(4)
    2. nd.save('xy', [x, y])
    3. x2, y2 = nd.load('xy')
    4. (x2, y2)
    1.  [1. 1. 1.]
    2.  <NDArray 3 @cpu(0)>,
    3.  [0. 0. 0. 0.]
    4.  <NDArray 4 @cpu(0)>)

    我们甚至可以存储并读取一个从字符串映射到NDArray的字典。

    1. In [4]:
    1. mydict = {'x': x, 'y': y}
    2. nd.save('mydict', mydict)
    3. mydict2 = nd.load('mydict')
    4. mydict2
    1. Out[4]:
    1. {'x':
    2.  [1. 1. 1.]
    3.  <NDArray 3 @cpu(0)>, 'y':
    4.  [0. 0. 0. 0.]
    5.  <NDArray 4 @cpu(0)>}

    除NDArray以外，我们还可以读写Gluon模型的参数。Gluon的Block类提供了save_parameters函数和load_parameters函数来读写模型参数。为了演示方便，我们先创建一个多层感知机，并将其初始化。回忆“模型参数的延后初始化”一节，由于延后初始化，我们需要先运行一次前向计算才能实际初始化模型参数。

    1. In [5]:
    1. class MLP(nn.Block):
    2.     def __init__(self, **kwargs):
    3.         super(MLP, self).__init__(**kwargs)
    4.         self.hidden = nn.Dense(256, activation='relu')
    5.         self.output = nn.Dense(10)
    6.     def forward(self, x):
    7.         return self.output(self.hidden(x))
    8.  
    9. net = MLP()
    10. net.initialize()
    11. X = nd.random.uniform(shape=(2, 20))
    12. Y = net(X)
    1. filename = 'mlp.params'
    2. net.save_parameters(filename)

    接下来，我们再实例化一次定义好的多层感知机。与随机初始化模型参数不同，我们在这里直接读取保存在文件里的参数。

    1. In [7]:
    1. net2 = MLP()
    2. net2.load_parameters(filename)

    因为这两个实例都有同样的模型参数，那么对同一个输入的计算结果将会是一样的。我们来验证一下。

    1. In [8]:
    1. Y2 = net2(X)
    2. Y2 == Y
    1. Out[8]:
    1. [[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
    2.  [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]
    3. <NDArray 2x10 @cpu(0)>
    • 通过save函数和load函数可以很方便地读写NDArray。
    • 通过load_parameters函数和save_parameters函数可以很方便地读写Gluon模型的参数。