Upgrade guide¶

import paddle

# Sequential networking
mnist = paddle.nn.Sequential(
    paddle.nn.Flatten(),
    paddle.nn.Linear(784, 512),
    paddle.nn.ReLU(),
    paddle.nn.Dropout(0.2),
    paddle.nn.Linear(512, 10)
)

import paddle

# Layer class networking
class Mnist(paddle.nn.Layer):
    def __init__(self):
        super().__init__()

        self.flatten = paddle.nn.Flatten()
        self.linear_1 = paddle.nn.Linear(784, 512)
        self.linear_2 = paddle.nn.Linear(512, 10)
        self.relu = paddle.nn.ReLU()
        self.dropout = paddle.nn.Dropout(0.2)

    def forward(self, inputs):
        y = self.flatten(inputs)
        y = self.linear_1(y)
        y = self.relu(y)
        y = self.dropout(y)
        y = self.linear_2(y)

        return y

mnist = Mnist()

import paddle
from paddle.vision.transforms import ToTensor

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
lenet = paddle.vision.models.LeNet()

# Mnist inherits paddle.nn.Layer belonging to Net, model contains the training function
model = paddle.Model(lenet)

# set the optimizer, loss, metric for training model
model.prepare(
    paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()),
    paddle.nn.CrossEntropyLoss(),
    paddle.metric.Accuracy()
    )

# training
model.fit(train_dataset, epochs=2, batch_size=64, log_freq=200)

# evaluation
model.evaluate(test_dataset, log_freq=20, batch_size=64)

import paddle
from paddle.vision.transforms import ToTensor

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
lenet = paddle.vision.models.LeNet()
loss_fn = paddle.nn.CrossEntropyLoss()

# load the training set batch_size as 64
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)

def train():
    epochs = 2
    adam = paddle.optimizer.Adam(learning_rate=0.001, parameters=lenet.parameters())
    # Use Adam as an optimization function
    for epoch in range(epochs):
        for batch_id, data in enumerate(train_loader()):
            x_data = data[0]
            y_data = data[1]
            predicts = lenet(x_data)
            acc = paddle.metric.accuracy(predicts, y_data)
            loss = loss_fn(predicts, y_data)
            loss.backward()
            if batch_id % 100 == 0:
                print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))
            adam.step()
            adam.clear_grad()

# training
train()

import paddle
import paddle.nn as nn
import paddle.optimizer as opt
import paddle.distributed as dist

class LinearNet(nn.Layer):
    def __init__(self):
        super().__init__()
        self._linear1 = nn.Linear(10, 10)
        self._linear2 = nn.Linear(10, 1)

    def forward(self, x):
        return self._linear2(self._linear1(x))

def train(print_result=False):

    # 1. initialize the parallel training environment
    dist.init_parallel_env()

    # 2. create parallel training Layer and Optimizer
    layer = LinearNet()
    dp_layer = paddle.DataParallel(layer)

    loss_fn = nn.MSELoss()
    adam = opt.Adam(
        learning_rate=0.001, parameters=dp_layer.parameters())

    # 3. run the network
    inputs = paddle.randn([10, 10], 'float32')
    outputs = dp_layer(inputs)
    labels = paddle.randn([10, 1], 'float32')
    loss = loss_fn(outputs, labels)

    if print_result is True:
        print("loss:", loss.numpy())

    loss.backward()

    adam.step()
    adam.clear_grad()

# Usage 1: Only import the training function
# Applicable scenario: no parameters are required and all currently visible GPU devices are needed.
if __name__ == '__main__':
    dist.spawn(train)

# Usage 2：Import the training function and parameters
# Applicable scenario: some parameters are required and all currently visible GPU devices are needed.
if __name__ == '__main__':
    dist.spawn(train, args=(True,))

# Usage 3：Import the training function and parameters and specify the number of parallel processes
# Applicable scenario: some parameters are required and only part of the visible GPU devices are needed：
# The current machine has 8 GPU cards {0,1,2,3,4,5,6,7},  the first two cards {0,1} will be used.
# Or the current machine can make only 4 GPU cards visible by configuring the environment variable CUDA_VISIBLE_DEVICES=4,5,6,7
# GPU cards are visible, the first two visible cards will be used {4,5}
if __name__ == '__main__':
    dist.spawn(train, args=(True,), nprocs=2)

# Usage 4: Import the training function and parameters and specify the number of parallel processesand specify the card number currently in use
# Applicable scenario: some parameters are required and part of the visible GPU devices are needed, yet：
# You may not have the right to configure environment variables for the current machine due to permission issues, for example,the current machine has 8 GPU cards
# {0,1,2,3,4,5,6,7}, but you do not have the right to configure CUDA_VISIBLE_DEVICES, then you can
# Specify the parameter selected_gpus to select the card you wish to use, e.g. selected_gpus='4,5'.
# You can specify the use of card #4 and card #5
if __name__ == '__main__':
    dist.spawn(train, nprocs=2, selected_gpus='4,5')

# Usage 5: Specify the starting port for multi-card communication
# Applicable scenario: port establishment communication prompt requires retry or communication establishment failure
# By default, Paddle will find a free port on the current machine for multi-card communication, but
# When the machine environment is more complex, the port found by the program maybe unstable, so you can
# specify a stable free starting port for a better training experience
if __name__ == '__main__':
    dist.spawn(train, nprocs=2, started_port=12345)

model = paddle.Model(Mnist())
# Prediction format, saved models can be used for prediction deployment
model.save('mnist', training=False)
# You can  get the model needed for predictive deployment

import paddle
from paddle.jit import to_static
from paddle.static import InputSpec

class SimpleNet(paddle.nn.Layer):
    def __init__(self):
        super().__init__()
        self.linear = paddle.nn.Linear(10, 3)

    # The first change
    # Specify the shape of the input data via InputSpec, None means variable length
    # Convert dynamic graph to static graph Program by to_static decorator
    @to_static(input_spec=[InputSpec(shape=[None, 10], name='x'), InputSpec(shape=[3], name='y')])
    def forward(self, x, y):
        out = self.linear(x)
        out = out + y
        return out


net = SimpleNet()

# The second change
# Save static graph model that can be used for predictive deployment
paddle.jit.save(net, './simple_net')