Python 基礎語法學習

時間 2021-03-06

標籤 python 算法數組網絡 dom 函數學習 code orm 欄目 Python 简体版

原文原文鏈接

for i \
        in range(3):
    print(i)
    print("-"*10)

0
----------
1
----------
2
----------

a = 10
b = 10.1
c = "hello"
print(a, "\n", b, "\n", c)

10 
 10.1 
 hello

print("%.3f" % 3.2)

3.200

a = "hello,world"
a0 = a[:-2]
a1 = a[1:]
print(a0, "\n", a1)

hello,wor 
 ello,world

list1 = [12.1, 100, "hello"]
print(list1)
list1[2] = -10
list2 = list1
print(list2)

[12.1, 100, 'hello']
[12.1, 100, -10]

# Filename : test.py
# author by : www.runoob.com

# 引入 datetime 模塊
import datetime


def getYesterday():
    today = datetime.date.today()
    oneday = datetime.timedelta(days=1)
    yesterday = today-oneday
    return yesterday


# 輸出
print(getYesterday())

2020-04-08

a = 10
b = 10
print("a id", id(a))
print("b id", id(b))
print("a and b", a is b)
c = 400
d = 400
print("c id", id(c))
print("d id", id(d))
print("c and d", c is d)

a id 94470720303456
b id 94470720303456
a and b True
c id 139988167345392
d id 139988167345936
c and d False

a = 1
if a == 1:
    print("wow")
elif a == 2:
    print("wooow")
else:
    print("not")

wow

list1 = [1, 2, 3, 4]
a = 1
b = 7
print(a in list1, b in list1)

True False

def function1(string="hao are you"):
    print("you say:", string)
    return None


function1()

you say: hao are you

list1 = [1, 3, 4, 6, 7]
for i in list1:
    print(i)

class number1:
    number1_name = 0
    number1_num1 = 0

    def __init__(self, name, num1):
        self.number1_name = name
        self.number1_num1 = num1

    def printinfo(self):
        print("name:", self.number1_name, "number:", self.number1_num1)


a = number1("Jan", 101)
b = number1("May", 102)
a.printinfo()
b.printinfo()

name: Jan number: 101
name: May number: 102

a = input()
print(a)

da
da

Numpy庫學習

import numpy as np
np.array([[1, 2, 3], [4, 5, 6], [1, 2, 4]])

array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 4]])

import numpy as np
np.ones([2, 4])

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.]])

import numpy as np
a = np.ones([1, 2])
a[0, 1] = -1
print(a)

[[ 1. -1.]]

import numpy as np
a = np.array(((1, 2, 3), (2, 3, 4)))
print(a)
a[0, 1] = -1
print(a)

[[1 2 3]
 [2 3 4]]
[[ 1 -1  3]
 [ 2  3  4]]

import numpy as np
a = np.zeros([3, 3])
print(a)

[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

import numpy as np
a = np.empty([3, 5])
print(a)

[[ 6.91252072e-310  1.04179639e+038  0.00000000e+000  0.00000000e+000
  -3.45901879e-144]
 [ 0.00000000e+000  0.00000000e+000  1.20056986e+075  0.00000000e+000
   0.00000000e+000]
 [ 2.98193437e-035  0.00000000e+000  0.00000000e+000 -4.60251970e-178
   0.00000000e+000]]

import numpy as np
a = np.array([[1, 2, 3], [7, 1, 5], [8, 2, 7], [5, 1, 5]])
c = a.shape
a = a.ndim
b = np.zeros([2, 4, 2, 2])
d = b.size
b = b.ndim
print(a, c, b, d)

2 (4, 3) 4 32

ndim是維數 shape是行列數 size是數組中的個數python

import numpy as np
a = np.matrix([[1, 2], [7, 1]])
print(a, a.ndim, a.shape, a.size)

[[1 2]
 [7 1]] 2 (2, 2) 4

matrix是矩陣算法

import numpy as np
a = np.matrix([[1, 2], [7, 1]])
print(a.dtype)
b = np.array([[12, 7, 5], [9, 1, 2]], dtype=np.float64)
print(b.dtype)

int64
float64

dtype是顯示當前數組/矩陣的數據類型 dtype=np.int16/int32/float64是改數組數據類型數組

import numpy as np
a = np.matrix([[1, 2], [7, 1]], dtype=np.float64)
print(a.itemsize)

itemsize是給當前數組的每一個數據的大小網絡

import numpy as np
a = np.arange(1, 4001, 2, dtype=np.int16)
print(a)

[   1    3    5 ... 3995 3997 3999]

numpy.arange()dom

概述
Numpy 中 arange() 主要是用於生成數組，具體用法以下；
arange()
2.1 語法
numpy.arange(start, stop, step, dtype = None)
在給定間隔內返回均勻間隔的值。
值在半開區間 [開始，中止]內生成（換句話說，包括開始但不包括中止的區間）,返回的是 ndarray 。
2.2 參數：
start —— 開始位置，數字，可選項，默認起始值爲0
stop —— 中止位置，數字
step —— 步長，數字，可選項，默認步長爲1，若是指定了step，則還必須給出start。
dtype —— 輸出數組的類型。若是未給出dtype，則從其餘輸入參數推斷數據類型。

import numpy as np
a = np.matrix([[1, 2, 3]])
b = np.matrix([[7], [2], [4]])
c = np.array([[1, 2, 3]])
d = np.array([[7], [2], [4]])
e = np.dot(a, b)
f = a.dot(b)
print(a*b, '\n', c*d, '\n', e, '\n', f)

[[23]] 
 [[ 7 14 21]
 [ 2  4  6]
 [ 4  8 12]] 
 [[23]] 
 [[23]]

np.dot()或者a.dot()是求數組點積，及把數組相乘轉爲爲矩陣相乘函數

import numpy as np
a = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a.min(0), '\n', a.max(axis=1), '\n', b.min(), '\n', b.max())

[[1 2 3]] 
 [[3]
 [6]
 [9]] 
 1 
 9

numpy中的max() min()函數中有一個 axis形參爲 0 則輸出每一列的最值，爲 1 則輸出每行最值，不填則輸出整個列表或矩陣的最值學習

import numpy as np
a = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a.sum(0), '\n', a.sum(1), '\n', a.sum())

[[12 15 18]] 
 [[ 6]
 [15]
 [24]] 
 45

numpy中 sum()函數是求和ui

import numpy as np
a = np.matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(np.exp(a), '\n', np.square(a), '\n', np.sqrt(a))

[[2.71828183e+00 7.38905610e+00 2.00855369e+01]
 [5.45981500e+01 1.48413159e+02 4.03428793e+02]
 [1.09663316e+03 2.98095799e+03 8.10308393e+03]] 
 [[ 1  4  9]
 [16 25 36]
 [49 64 81]] 
 [[1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974]
 [2.64575131 2.82842712 3.        ]]

np.exp()爲指數運算，np.sqrt()爲平方根運算，np.suare()爲平方運算
***這幾個函數全在numpy類中不在定義對象中code

import numpy as np
np.random.seed(11)
print(np.random.rand(2, 2))
print(np.random.rand(2, 2))
print(np.random.randn(2, 2))
c = np.random.randint(1, 10, (3, 3), np.int16)
print(c, c.dtype)
print(np.random.binomial(10, 0.6, (3, 3)))
print(np.random.beta(2, 3, (3, 3)))
print(np.random.normal(5, 1, (3, 3)))

[[0.18026969 0.01947524]
 [0.46321853 0.72493393]]
[[0.4202036  0.4854271 ]
 [0.01278081 0.48737161]]
[[-0.53662936  0.31540267]
 [ 0.42105072 -1.06560298]]
[[9 2 7]
 [4 3 7]
 [4 3 2]] int16
[[8 5 5]
 [7 7 8]
 [8 5 6]]
[[0.48914705 0.31453808 0.61569653]
 [0.42094996 0.39159773 0.06277155]
 [0.34021367 0.72969676 0.20578207]]
[[6.08771086 5.53382172 5.39521201]
 [5.12286753 6.20910164 4.1569339 ]
 [4.85810642 5.38535414 3.42250569]]

numpy.random.seed(int x) 用於指定隨機數生成時所用算法開始的整數值，若是使用相同的seed( )值，則每次生成的隨即數都相同，若是不設置這個值，則系統根據時間來本身選擇這個值，此時每次生成的隨機數因時間差別而不一樣。有利於結果復現。orm

numpy.random.rand(d0,d1,…dn) 幾行幾列幾維
以給定的形狀建立一個數組，並在數組中加入在[0,1]之間知足均勻分佈的隨機樣本。

numpy.random.randn(d0,d1,…dn)
以給定的形狀建立一個數組，數組元素來符合標準正態分佈 N(0,1) <--平均值爲0方差爲1

numpy.random.randint(low,high=None,size=None,dtype)
生成值爲整數類型的隨機樣本數，size爲幾行幾列
生成在半開半閉區間[low,high)上離散均勻分佈的整數值;若high=None，則取值區間變爲[0,low)

numpy.random.binomial(n,p,size=None)
生成一個維數指定且知足二項分佈的隨機樣本
（下方僅供參考）
參數n：一次試驗的樣本數n，而且相互不干擾
參數p：事件發生的機率p，範圍[0,1]
參數size：限定了返回值的形式和實驗次數。當size是整數N時，表示實驗N次，返回每次實驗中事件發生的次數；size是（X，Y）時，表示實驗X*Y次，以X行Y列的形式輸出每次試驗中事件發生的次數。

numpy.random.beta(a, b, size=None)
生成一個指定維度且知足beta分佈的隨機樣本數
The Beta distribution is a special case of the Dirichlet distribution, and is related to the Gamma distribution. It has the probability distribution function
beta分佈就是機率出現的機率

numpy.random.normal(loc=0.0, scale=1.0, size=None)
生成一個指定維度且知足高斯正態分佈的隨機樣本數
loc 分佈的中值("centre")
scale 分佈的標準差(spread or "width")
size 輸出的維數(shape)

import numpy as np
a = np.arange(1, 10, 1, np.int16)
print(a)
print(a[0:5])
for i in a:
    print(i)

[1 2 3 4 5 6 7 8 9]
[1 2 3 4 5]
1
2
3
4
5
6
7
8
9

一維數組索引、切片、迭代如上

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a)
print("-"*10)
for i in a:
    for j in i:
        print(j)
print("-"*10)
for i in a.flat:
    print(i)

[[1 2 3]
 [4 5 6]
 [7 8 9]]
----------
1
2
3
4
5
6
7
8
9
----------
1
2
3
4
5
6
7
8
9

經過二層嵌套循環能夠完成遍歷數組，也可用 .flat對數組扁平化處理，一層循環遍歷數組

Matplotlib庫學習

import matplotlib.pyplot as plt
%matplotlib inline

matplotlib庫爲python繪圖庫，如要直接顯示繪製圖像要加 %matplotlib inline

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
np.random.seed(19)
a = np.random.normal(4, 5, 30)
b = np.random.randn(30)
c = np.random.binomial(10, 0.5, 30)
plt.title("Test")
plt.xlabel("X")
plt.ylabel("Y")
x, = plt.plot(a, "r-o")
y, = plt.plot(b, "b--x")
z, = plt.plot(c, "g-.*")
plt.legend([x, y, z], ["normal", "randn", "binomial"])
print(a)
print(b)
print(c)

[ 5.10501631  2.29767496  1.11125729  1.97984222  0.98355287  2.78073861
  9.17671869  6.90376706  5.26206868 -3.31272976 -3.74170661  5.32636364
  3.99551896 -1.07996201  4.55994803 -1.95976026 11.7777195  -0.66649961
  6.63267125  3.25017709  6.61392873 10.71077436 11.79260635 10.27997038
  8.54301652 -0.2045069   9.02792549 -1.1190209   4.90886956  1.91659527]
[ 1.97840875  1.91744468 -1.031007   -0.48331191 -0.64508015  0.06034816
  0.54793044  0.84514847 -1.20718132  0.37484034  0.94234783 -0.35126393
  0.45973503 -0.04851666  0.41548191 -0.70187614  0.18546447  0.46834978
  0.03952335  0.71614054 -0.4816884  -0.05249119 -0.27227855  0.30798526
 -1.76065359  1.15022395 -0.21773107 -1.22058738 -0.34361544  1.54876219]
[3 4 9 4 7 3 8 5 6 6 5 7 2 5 4 4 6 4 6 8 5 3 3 4 4 5 7 3 6 6]

matplotlib.plot(x,y,format_string,**kwargs)
說明：
x:x軸數據，列表或數組，可選
y:y軸數據，列表或數組
format_string:控制曲線的格式字符串，可選

**kwargs:第二組或更多，(x,y,format_string)

設置線性圖的顏色經常使用參數：
b藍色 g綠色 r紅色 m洋紅色 c藍綠色 y黃色 k黑色 w白色 ‘#008000’RGB某顏色
參數點形狀：
o圓型 *星型 + x
點線條形狀：
-實現 --虛線 -.點實現：點線

plt.title("Test")爲給標題
plt.xlabel("X")給x軸命名
plt.ylabel("Y")給y軸命名
plt.legend([x,y,z],["normal","randn","binomial"])給圖的點作說明

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

np.random.seed(15)
a = np.random.normal(4, 5, 30)
b = np.random.randn(30)
c = np.random.binomial(10, 0.5, 30)

fig = plt.figure()
ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 2)
ax3 = fig.add_subplot(2, 2, 3)

A, = ax1.plot(a, "r-o")
ax1.legend([A], ["a"])
B, = ax2.plot(b, "b--*")
ax2.legend([B], ["b"])
C, = ax3.plot(c, "g-.+")
ax3.legend([C], ["c"])

<matplotlib.legend.Legend at 0x7f44c444aa90>

建立子圖須要先調用 plt.figure() 函數，給每一個圖位置進行賦值用 fig.add_subplot(a,b,c) 函數
，其中 a,b 爲幾行幾列的子圖表 c爲當前圖在表中位置，最後用 plot函數將具體數據寫入圖中

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

np.random.seed(15)
a = np.random.randn(30)
np.random.seed(5)
b = np.random.randn(30)

plt.scatter(a,b,c="g",marker="o",label="(x,y)")
plt.legend(loc=0)
plt.title("Are you ready")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

plt.scatter()函數繪製散點圖，詳見代碼
loc=0/1/2/3/4 0爲自動選其他從第一象限逆時針

import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

np.random.seed(42)
a = np.random.randn(1000)
plt.hist(a, bins=20, color="g")
plt.title("No,I'm not")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()

plt.hint()函數繪製直方圖，bins 是條紋數

import matplotlib.pyplot as plt

labels = ["Dogs", "Cats", "Birds"]
sizes = [15, 50, 35]

plt.pie(sizes, explode=(0, 0, 0.1), labels=labels,autopct='%1.2f', startangle=90)
plt.axis('equal')
plt.show()

PyTorch 基礎學習

import torch
a = torch.FloatTensor(2, 3)
b = torch.FloatTensor([2.1, 3, 4, 5])
c = torch.IntTensor(2, 3)
d = torch.IntTensor([[1, 2, 3, 4], [2, 3, 4, 5]])
print(a)
print(b)
print(c)
print(d)

tensor([[0., 0., 0.],
        [0., 0., 0.]])
tensor([2.1000, 3.0000, 4.0000, 5.0000])
tensor([[          0,           0,           0],
        [          0, -1107135675,  1884978169]], dtype=torch.int32)
tensor([[1, 2, 3, 4],
        [2, 3, 4, 5]], dtype=torch.int32)

import torch
a = torch.rand(2, 3)
b = torch.randn(2, 3)
c = torch.arange(1, 22, 2)
d = torch.zeros(2, 3)
print(a)
print(b)
print(c)
print(d)

tensor([[0.2277, 0.6782, 0.7195],
        [0.7507, 0.2358, 0.0920]])
tensor([[ 0.7264, -0.5226,  0.5209],
        [ 0.4460, -0.3604,  0.6802]])
tensor([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19, 21])
tensor([[0., 0., 0.],
        [0., 0., 0.]])

推薦使用 arange 而不是 range
arrange 第三個參數是步長

import torch

a = torch.randn(2, 3)
print(a)
b = torch.abs(a)
print(b)
print(torch.add(a, b))
print(torch.add(a, 10))

tensor([[-2.0042,  1.5977, -0.0227],
        [-0.1025, -0.5865,  0.8083]])
tensor([[2.0042, 1.5977, 0.0227],
        [0.1025, 0.5865, 0.8083]])
tensor([[0.0000, 3.1955, 0.0000],
        [0.0000, 0.0000, 1.6166]])
tensor([[ 7.9958, 11.5977,  9.9773],
        [ 9.8975,  9.4135, 10.8083]])

import torch
a = torch.IntTensor([[-2, 1, 3], [2, 7, -10]])
b = torch.clamp(a, -1, 3)
print(a)
print(b)

tensor([[ -2,   1,   3],
        [  2,   7, -10]], dtype=torch.int32)
tensor([[-1,  1,  3],
        [ 2,  3, -1]], dtype=torch.int32)

torch.clamp(a,b,c) 用來對參數進行範圍裁剪第一個參數傳要裁剪對象，第二個參數是下限，第三個參數是上限

import torch
a = torch.randn(2, 3)
b = torch.randn(2, 3)
print(a)
print(b)

print(torch.mul(a, b))
print(torch.mul(a, 10))

print(torch.div(a, b))
print(torch.div(10, b))

c = torch.zeros(2, 3)
print(torch.div(10, c))

print(torch.pow(a, 0))
print(torch.pow(c, 0))

tensor([[-0.5769,  1.2399, -0.8562],
        [ 0.8909,  0.9248,  1.3515]])
tensor([[-0.3133, -0.2824,  0.4792],
        [-0.7237, -2.1322,  2.8614]])
tensor([[ 0.1807, -0.3501, -0.4103],
        [-0.6447, -1.9718,  3.8674]])
tensor([[-5.7688, 12.3990, -8.5620],
        [ 8.9094,  9.2479, 13.5155]])
tensor([[ 1.8413, -4.3910, -1.7867],
        [-1.2312, -0.4337,  0.4723]])
tensor([[-31.9180, -35.4140,  20.8683],
        [-13.8187,  -4.6901,   3.4947]])
tensor([[inf, inf, inf],
        [inf, inf, inf]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])

torch.mul 是乘法 torch.div 是除法 torch.pow 是冪運算（特別的：零的零次方也是1）

import torch
a = torch.FloatTensor([[1, 2, 3], [3, 2, 1]])
b = torch.FloatTensor([[4, 5], [2, 7], [3, 1]])
print(torch.mm(a, b))
print(torch.mm(b, a))

c = torch.randn(3)
print(torch.mv(a, c))

tensor([[17., 22.],
        [19., 30.]])
tensor([[19., 18., 17.],
        [23., 18., 13.],
        [ 6.,  8., 10.]])
tensor([0.6090, 1.7420])

torch.mm 是矩陣乘法 torch.mv 是矩陣和向量的乘法（注意：數據類型要相同才能運算）

一個簡單的神經網絡

torch中 .t()是輸出轉置矩陣
format 函數能夠接受不限個參數，位置能夠不按順序
如："{1} {0} {1}".format("hello", "world") 輸出結果爲「'world hello world」

import torch
import matplotlib.pyplot as plt
%matplotlib inline
batch_n = 100  # 輸入數據量
hidden_layer = 100  # 經隱藏層後的數據量
input_data = 1000  # 每一個數據中有1000個數據特徵
output_data = 10  # 輸出10個分類結果

x = torch.randn(batch_n, input_data)  # 100*1000
y = torch.randn(batch_n, output_data)  # 100*10
w1 = torch.randn(input_data, hidden_layer)  # 1000*100
w2 = torch.randn(hidden_layer, output_data)  # 100*10
# 輸入層到輸出層的權重初始化定義

epoch_n = 20  # 學習次數
learning_rate = 1e-7   # 學習速率

for epoch in range(epoch_n):
    h1 = x.mm(w1)  # 100*100
    h1 = h1.clamp(min=0)  # 過濾
    y_pred = h1.mm(w2)  # 100*10  # 前向傳播預測值

    loss = (y_pred - y).pow(2).sum()  # 偏差值 均方偏差函數
    print("Epoch:{}, Loss:{:.4f}".format(epoch, loss))
    plt.plot(epoch, loss/1000000, "g-.o")


    grad_y_pred = 2*(y_pred - y)
    grad_w2 = h1.t().mm(grad_y_pred)  # 鏈式求導梯度

    grad_h = grad_y_pred.clone()
    grad_h = grad_h.mm(w2.t())
    grad_h.clamp_(min=0)
    grad_w1 = x.t().mm(grad_h)  # 鏈式求導梯度

    w1 -= learning_rate*grad_w1  # 新權重
    w2 -= learning_rate*grad_w2  # 新權重

Epoch:0, Loss:46159204.0000
Epoch:1, Loss:35363124.0000
Epoch:2, Loss:30140088.0000
Epoch:3, Loss:27308764.0000
Epoch:4, Loss:25534646.0000
Epoch:5, Loss:24247540.0000
Epoch:6, Loss:23200030.0000
Epoch:7, Loss:22282628.0000
Epoch:8, Loss:21446886.0000
Epoch:9, Loss:20668928.0000
Epoch:10, Loss:19937316.0000
Epoch:11, Loss:19245446.0000
Epoch:12, Loss:18589512.0000
Epoch:13, Loss:17966258.0000
Epoch:14, Loss:17373192.0000
Epoch:15, Loss:16808334.0000
Epoch:16, Loss:16270253.0000
Epoch:17, Loss:15757100.0000
Epoch:18, Loss:15267285.0000
Epoch:19, Loss:14799396.0000

import torch
from torch.autograd import Variable
import matplotlib.pyplot as plt
%matplotlib inline

batch_n = 100  # 輸入數據量
hidden_layer = 100  # 經隱藏層後的數據量
input_data = 1000  # 每一個數據中有1000個數據特徵
output_data = 10  # 輸出10個分類結果

x = Variable(torch.randn(batch_n, input_data),requires_grad=False)  # 100*1000
y = Variable(torch.randn(batch_n, output_data),requires_grad=False)  # 100*10
w1 = Variable(torch.randn(input_data, hidden_layer),requires_grad=True)  # 1000*100
w2 = Variable(torch.randn(hidden_layer, output_data),requires_grad=True)  # 100*10
# 輸入層到輸出層的權重初始化定義
# Variable封裝 且w1 w2保留梯度值

epoch_n = 20  # 學習次數
learning_rate = 1e-7   # 學習速率

for epoch in range(epoch_n):
    y_pred = x.mm(w1).clamp(min=0).mm(w2)

    loss = (y_pred - y).pow(2).sum()  # 偏差值 均方偏差函數
    print("Epoch:{}, Loss:{:.4f}".format(epoch, loss.item()))
    plt.plot(epoch, loss.item(), "g-.o")

    loss.backward()

    w1.data -= learning_rate*w1.grad.data  # 新權重
    w2.data -= learning_rate*w2.grad.data  # 新權重
    
    w1.grad.data.zero_()
    w2.grad.data.zero_()

Epoch:0, Loss:45419716.0000
Epoch:1, Loss:36970548.0000
Epoch:2, Loss:32581012.0000
Epoch:3, Loss:29904798.0000
Epoch:4, Loss:27988124.0000
Epoch:5, Loss:26438394.0000
Epoch:6, Loss:25090844.0000
Epoch:7, Loss:23873752.0000
Epoch:8, Loss:22752522.0000
Epoch:9, Loss:21709780.0000
Epoch:10, Loss:20735070.0000
Epoch:11, Loss:19820292.0000
Epoch:12, Loss:18961622.0000
Epoch:13, Loss:18154286.0000
Epoch:14, Loss:17393844.0000
Epoch:15, Loss:16677597.0000
Epoch:16, Loss:16001947.0000
Epoch:17, Loss:15363768.0000
Epoch:18, Loss:14760480.0000
Epoch:19, Loss:14189733.0000