points_sum = 100
# 在(0, 0)点附近生成一堆点然后以4为半径在周围生成一堆点构成2类随机数据。
c1_x, c1_y, c2_x, c2_y = [], [], [], []
for _ in range(points_sum):
c1_x.append(np.random.normal(0, 1))
c1_y.append(np.random.normal(0, 1))
r = np.random.normal(4, 1)
theta = np.random.normal(0, 2 * np.pi)
c2_x.append(r * np.cos(theta))
c2_y.append(r * np.sin(theta))
c_x = c1_x + c2_x
c_y = c1_y + c2_y
# 定义符号。
A = pd.Variable([c_x, c_y], name='A')
W1 = pd.Variable(np.random.random((4, 2)), name='W1') # 输入层到隐含层的权重矩阵。
W2 = pd.Variable(np.random.random((2, 4)), name='W2') # 隐含层到输出层的权重矩阵。
B1 = pd.Variable(np.random.random((4, 1)), name='B1') # 隐含层的偏置。
B2 = pd.Variable(np.random.random((2, 1)), name='B2') # 输出层的偏置。
K = pd.Constant([[-1] * points_sum + [1] * points_sum,
[1] * points_sum + [-1] * points_sum])
# 构建2x4x2网络，使用ReLu激活函数。
model = pd.maximum(W2 @ pd.maximum(W1 @ A + B1, 0) + B2, 0)
# 使用SVM loss。
loss = pd.reduce_mean(pd.maximum(pd.reduce_sum(K * model, axis=0) + 1, 0))
# 创建loss计算引擎，申明变量为W1，W2，B1和B2。
loss_engine = pd.Engine(loss, [W1, W2, B1, B2])
import paradox as pd
A = pd.Constant([[1, 2], [1, 3]], name='A')
x = pd.Variable([0, 0], name='x')
b = pd.Constant([3, 4], name='b')
y = pd.reduce_sum((A @ x - b)**2) / 2
print('value =\n{}\n'.format(y.get_value())) # 完善自动求值
print('x gradient =\n{}\n'.format(y.get_gradient(x))) # 完善自动求导
for _ in range(points_sum):
c1_x.append(r * np.cos(theta))
c1_y.append(r * np.sin(theta))
c2_x.append(-r * np.cos(theta))
c2_y.append(-r * np.sin(theta))
r += r_step
theta += theta_step
c_x = c1_x + c2_x
c_y = c1_y + c2_y
# 定义每个点的分类类别。
classification = pd.utils.generate_label_matrix([0] * points_sum +
[1] * points_sum)[0]
# 定义符号。
A = pd.Variable(np.array([c_x, c_y]).transpose(), name='A')
W1 = pd.Variable(np.random.random((2, 8)), name='W1') # 输入层到隐含层的权重矩阵。
W2 = pd.Variable(np.random.random((8, 8)), name='W2') # 第1层隐含层到输出层的权重矩阵。
W3 = pd.Variable(np.random.random((8, 2)), name='W3') # 第2层隐含层到输出层的权重矩阵。
B1 = pd.Variable(np.random.random((1, 8)), name='B1') # 第1层隐含层的偏置。
B2 = pd.Variable(np.random.random((1, 8)), name='B2') # 第2层隐含层的偏置。
B3 = pd.Variable(np.random.random((1, 2)), name='B3') # 输出层的偏置。
# 构建2x8x8x2网络，使用ReLu激活函数。
model = pd.nn.relu(pd.nn.relu(pd.nn.relu(A @ W1 + B1) @ W2 + B2) @ W3 + B3)
# 使用Softmax loss。
loss = pd.nn.softmax_loss(model, classification)
# 创建loss计算引擎，申明变量为W1，W2，B1和B2。
loss_engine = pd.Engine(loss, [W1, W2, W3, B1, B2, B3])
x_data = []
y_data = []
# 生成y = 2 * x + 1直线附近的随机点。
for _ in range(points_sum):
x = np.random.normal(0, 2)
y = 2 * x + 1 + np.random.normal(0, 2)
x_data.append(x)
y_data.append(y)
x_np = np.array(x_data)
y_np = np.array(y_data)
# 定义符号。
X = pd.Constant(x_np, name='x')
Y = pd.Constant(y_np, name='y')
w = pd.Variable(0, name='w')
b = pd.Variable(0, name='b')
# 使用最小二乘误差。
loss = pd.reduce_mean((w * X + b - Y) ** 2)
# 创建loss计算引擎，申明变量为w和b。
loss_engine = pd.Engine(loss, [w, b])
# 梯度下降optimizer。
optimizer = pd.GradientDescentOptimizer(0.00005)
# 迭代100次最小化loss。
for epoch in range(1000):
optimizer.minimize(loss_engine)
loss_value = loss_engine.value()
theta = 0
for _ in range(points_sum):
c1_x.append(r * np.cos(theta))
c1_y.append(r * np.sin(theta))
c2_x.append(-r * np.cos(theta))
c2_y.append(-r * np.sin(theta))
r += r_step
theta += theta_step
c_x = c1_x + c2_x
c_y = c1_y + c2_y
# 定义每个点的分类类别。
classification = [0] * points_sum + [1] * points_sum
# 定义符号。
A = pd.Variable([c_x, c_y], name='A')
W1 = pd.Variable(np.random.random((8, 2)), name='W1') # 输入层到隐含层的权重矩阵。
W2 = pd.Variable(np.random.random((8, 8)), name='W2') # 第1层隐含层到输出层的权重矩阵。
W3 = pd.Variable(np.random.random((2, 8)), name='W3') # 第2层隐含层到输出层的权重矩阵。
B1 = pd.Variable(np.random.random((8, 1)), name='B1') # 第1层隐含层的偏置。
B2 = pd.Variable(np.random.random((8, 1)), name='B2') # 第2层隐含层的偏置。
B3 = pd.Variable(np.random.random((2, 1)), name='B3') # 输出层的偏置。
# 构建2x8x8x2网络，使用ReLu激活函数。
model = pd.nn.relu(W3 @ pd.nn.relu(W2 @ pd.nn.relu(W1 @ A + B1) + B2) + B3)
# 使用Softmax loss。
loss = pd.nn.softmax_loss(model, classification)
# 创建loss计算引擎，申明变量为W1，W2，B1和B2。
c1_x = []
c1_y = []
c2_x = []
c2_y = []
# 分别在(0, 0)点附近和(8, 8)点附近生成2类随机数据。
for _ in range(points_sum):
c1_x.append(np.random.normal(0, 2))
c1_y.append(np.random.normal(0, 2))
c2_x.append(np.random.normal(8, 2))
c2_y.append(np.random.normal(8, 2))
# 定义符号。
c1 = pd.Constant([c1_x, c1_y], name='c1')
c2 = pd.Constant([c2_x, c2_y], name='c2')
W = pd.Variable([[1, 1], [1, 1]], name='w')
B = pd.Variable([[1], [1]], name='b')
# 定义SVM loss函数。
loss = pd.reduce_mean(
pd.maximum(0, [[1, -1]] @ (W @ c1 + B) + 1) +
pd.maximum(0, [[-1, 1]] @ (W @ c2 + B) + 1))
# 创建loss计算引擎，申明变量为W和B。
loss_engine = pd.Engine(loss, [W, B])
# 创建梯度下降optimizer。
optimizer = pd.GradientDescentOptimizer(0.01)
# 迭代至多1000次最小化loss。
for epoch in range(1000):
points_sum = 100
# 在(0, 0)点附近生成一堆点然后以4为半径在周围生成一堆点构成2类随机数据。
c1_x, c1_y, c2_x, c2_y = [], [], [], []
for c1 in range(points_sum):
c1_x.append(np.random.normal(0, 1))
c1_y.append(np.random.normal(0, 1))
r = np.random.normal(4, 1)
theta = np.random.normal(0, 2 * np.pi)
c2_x.append(r * np.cos(theta))
c2_y.append(r * np.sin(theta))
c_x = c1_x + c2_x
c_y = c1_y + c2_y
A = pd.Constant([c_x, c_y], name='A')
W1 = pd.Variable(np.random.random((4, 2)), name='W1')
W2 = pd.Variable(np.random.random((2, 4)), name='W2')
B1 = pd.Variable(np.random.random((4, 1)), name='B1')
B2 = pd.Variable(np.random.random((2, 1)), name='B2')
K = pd.Constant([[-1] * points_sum + [1] * points_sum, [1] * points_sum + [-1] * points_sum])
# 构建2x4x2网络，使用ReLu激活函数，SVM loss。
loss = pd.reduce_mean(pd.maximum(pd.reduce_sum(K * pd.maximum(W2 @ pd.maximum(W1 @ A + B1, 0) + B2, 0), axis=0) + 1, 0))
# 创建loss计算引擎，申明变量为W1，W2，B1和B2。
loss_engine = pd.Engine(loss, [W1, W2, B1, B2])
# 创建梯度下降optimizer。
optimizer = pd.GradientDescentOptimizer(0.0001)
