Paddlapaddle: Project1: hello Paddle

Tips: 通过此方法安装不成功，安装后无法导入Paddlepaddle，可通过此方法：

python -m pip install paddlepaddle==3.0.0b1 -i https://www.paddlepaddle.org.cn/packages/stable/cpu/

(2) Import Paddlepaddle

import paddle
print("Paddle" + paddle.__version__)

4. Prepare data

In this machine learning task, the mileage of passenges $distanceTravelled$ and the corresponding total cost of these passenges $totalFee$ are already known.

Typically, in machine learning tasks, $distanceTravelled$ input values like this are generally called $x$ (or features), and $totalFee$ output values likes this are generally called $y$ (or labels).

PaddlePaddle is the same as other Deep learning Framework, it use Tensor (张量) to represent data. Convert sample data into paddle's Tensor data.

x_data = paddle.to_tensor([[1.], [3.0], [5.0], [9.0], [10.0], [20.0]])
y_data = paddle.to_tensor([[12.], [16.0], [20.0], [28.0], [30.0], [50.0]])

5. Calculation of the model defiend by PaddlePaddle

Use machine learning methods through PaddlePaddle to learn the sum of the following formula from data $w$ and $b$. $$yPredict = w \times x + b$$

In this way, in the future, we can estimate the value $y$ giving $x$.

The linear transformation layer of Paddlepaddle will be used ($paddle.nn.linear$) to implement this calculation process. The variables correspond to the concept of Tensor in Paddle. ($x, y, w, b, yPredict$).

Tips: In the example here, based on experience, we already know that there is a linear relationship between $distanceTravelled$ and $totalFee$. But in most practical problems, the relationship betwen features (x) and labels (y) is usually nonlinear, so more types of complex neural netwoks are needed. (For example, the BMI index is not linearly related to your height, and a certain pixel value in a picture is not linearly related to whether the picture is a cat or a dog.)

linear = paddle.nn.Linear(in_features=1, out_features=1)

5. Get ready to run Paddle

The computer will randomly guess $w$ and $b$, see how well it guesses at the begining. The value $w$ is a random value, $b$ is zero, which is the initialization strategy of Paddle and is also commonly used intialization strategy in this field. 

w_before_opt = linear.weight.numpy().item()
b_before_opt = linear.bias.numpy().item()
print("w before optimize: {}".format(w_before_opt))
print("b before optimize: {}".format(b_before_opt))

6. Tell PaddlePaddle how to learn

Afte defining the neural network (although it is the simplest one), we need to tell PaddlePaddle how to learn so that we can get the parameters $w$ and $b$.

In machine/deep learning, the machine gets the paramenters by random guessing at the beginning. When using the parameter values obtained by random guessing to perform calculations (predictions), there must be a gap between the obtained values and the actual values. Next, the machine will adjust the sum according to this gap. With such gradual adjustments, the sum will beacome more and more correct, and the gap between predict values and actual values will become smaller and smaller, so that a useful sum can be finally obtained. 

The function that measures the gap is the loss function, and the method used to adjust the paremeters is the optimization algorithm.

In this example, the mean square error is used as the loss function and the optimization algorithm SGD (stocastic gradient descent) is used. The parameters learning_rate can be understood as the parameter that control the step size of each adjustment.

mse_loss = paddle.nn.MSELoss()
sgd_optimizer = paddle.optimizer.SGD(learning_rate=0.001, parameters = linear.parameters())

7. Run the optimization algorithm

Next, let PaddlePaddle run this optimization algorithm. This will be a process of gradually adjusting parameters as described earilier. You should be able to see that the loss value (which measures the difference between the sum y and y_predict) is certantly decreasing.

total_epoch = 5000
for i in range(total_epoch):
    y_predict = linear(x_data)
    loss = mse_loss(y_predict, y_data)
    loss.backward()
    sgd_optimizer.step()
    sgd_optimizer.clear_grad()
    
    if i%1000 == 0:
        print("epoch {} loss {}".format(i, loss.numpy()))
        
print("finished training， loss {}".format(loss.numpy()))

8. Parameters learned by machine learning method

w_after_opt = linear.weight.numpy().item()
b_after_opt = linear.bias.numpy().item()

print("w after optimize: {}".format(w_after_opt))
print("b after optimize: {}".format(b_after_opt))