""" 構(gòu)建神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)。
"""

import numpy as np

class SimpleNN:
 def __init__(self, architecture):
 self.architecture = architecture
 self.weights = []
 self.biases = []

 #初始化權(quán)重和偏差
 np.random.seed(99)
 for i in range(len(architecture) - 1):
 self.weights.append(np.random.uniform(
 low=-1, high=1,
 size=(architecture[i], architecture[i+1])
 ))
 self.biases.append(np.zeros((1, architecture[i+1])))

architecture = [2, 64, 64, 64, 1] # 兩個輸入，兩個隱藏層，一個輸出
model = SimpleNN(architecture)

print('weight dimensions:')
for w in model.weights:
 print(w.shape)

print('nbias dimensions:')
for b in model.biases:
 print(b.shape)

"""實現(xiàn)前向傳播
"""

import numpy as np

class SimpleNN:
 def __init__(self, architecture):
 self.architecture = architecture
 self.weights = []
 self.biases = []

 # 初始化權(quán)重和偏差
 np.random.seed(99)
 for i in range(len(architecture) - 1):
 self.weights.append(np.random.uniform(
 low=-1, high=1,
 size=(architecture[i], architecture[i+1])
 ))
 self.biases.append(np.zeros((1, architecture[i+1])))

 @staticmethod
 def relu(x):
 #實現(xiàn)relu激活函數(shù)
 return np.maximum(0, x)

 def forward(self, X):
 #遍歷所有層
 for W, b in zip(self.weights, self.biases):

 #應(yīng)用該層的權(quán)重和偏差
 X = np.dot(X, W) + b

 #為除最后一層之外的所有層進(jìn)行ReLU激活
 if W is not self.weights[-1]:
 X = self.relu(X)

 #返回結(jié)果
 return X

 def predict(self, X):
 y = self.forward(X)
 return y.flatten()

#定義模型
architecture = [2, 64, 64, 64, 1] # 兩個輸入，兩個隱藏層，一個輸出
model = SimpleNN(architecture)

# 生成預(yù)測
prediction = model.predict(np.array([0.1,0.2]))
print(prediction)

"""定義我們希望模型要學(xué)習(xí)的內(nèi)容
"""
import numpy as np
import matplotlib.pyplot as plt

# 定義一個具有兩個輸入的隨機(jī)函數(shù)
def random_function(x, y):
 return (np.sin(x) + x * np.cos(y) + y + 3**(x/3))

# 生成一個包含x和y值對的網(wǎng)格
x = np.linspace(-10, 10, 100)
y = np.linspace(-10, 10, 100)
X, Y = np.meshgrid(x, y)

#計算隨機(jī)函數(shù)的輸出
Z = random_function(X, Y)

#創(chuàng)建二維圖
plt.figure(figsize=(8, 6))
contour = plt.contourf(X, Y, Z, cmap='viridis')
plt.colorbar(contour, label='Function Value')
plt.title('2D Plot of Objective Function')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 定義一個具有兩個輸入的隨機(jī)函數(shù)
def random_function(x, y):
 return (np.sin(x) + x * np.cos(y) + y + 3**(x/3))

# 定義要生成的隨機(jī)樣本數(shù)
n_samples = 1000

#生成指定范圍內(nèi)的隨機(jī)X和Y值
x_min, x_max = -10, 10
y_min, y_max = -10, 10

# 生成X和Y生成隨機(jī)值
X_random = np.random.uniform(x_min, x_max, n_samples)
Y_random = np.random.uniform(y_min, y_max, n_samples)

# 在生成的X和Y值上計算隨機(jī)函數(shù)
Z_random = random_function(X_random, Y_random)

#創(chuàng)建數(shù)據(jù)集
dataset = pd.DataFrame({
 'X': X_random,
 'Y': Y_random,
 'Z': Z_random
})

#顯示數(shù)據(jù)集
print(dataset.head())

#創(chuàng)建采樣數(shù)據(jù)的二維散點圖
plt.figure(figsize=(8, 6))
scatter = plt.scatter(dataset['X'], dataset['Y'], c=dataset['Z'], cmap='viridis', s=10)
plt.colorbar(scatter, label='Function Value')
plt.title('Scatter Plot of Randomly Sampled Data')
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.show()

import numpy as np

class SimpleNN:
 def __init__(self, architecture):
 self.architecture = architecture
 self.weights = []
 self.biases = []

 #在此代碼塊中跟蹤這些值
 #以便我們可以觀察它們
 self.perceptron_inputs = None
 self.perceptron_outputs = None

 #初始化權(quán)重和偏差
 np.random.seed(99)
 for i in range(len(architecture) - 1):
 self.weights.append(np.random.uniform(
 low=-1, high=1,
 size=(architecture[i], architecture[i+1])
 ))
 self.biases.append(np.zeros((1, architecture[i+1])))

 @staticmethod
 def relu(x):
 return np.maximum(0, x)

 def forward(self, X):
 self.perceptron_inputs = [X]
 self.perceptron_outputs = []

 for W, b in zip(self.weights, self.biases):
 Z = np.dot(self.perceptron_inputs[-1], W) + b
 self.perceptron_outputs.append(Z)

 if W is self.weights[-1]: # Last layer (output)
 A = Z # 回歸線性輸出
 else:
 A = self.relu(Z)
 self.perceptron_inputs.append(A)

 return self.perceptron_inputs, self.perceptron_outputs

 def predict(self, X):
 perceptron_inputs, _ = self.forward(X)
 return perceptron_inputs[-1].flatten()

#定義模型
architecture = [2, 64, 64, 64, 1] # 兩個輸入，兩個隱藏層，一個輸出
model = SimpleNN(architecture)

#生成預(yù)測
prediction = model.predict(np.array([0.1,0.2]))

#查看臨界優(yōu)化值
for i, (inpt, outpt) in enumerate(zip(model.perceptron_inputs, model.perceptron_outputs[:-1])):
 print(f'layer {i}')
 print(f'input: {inpt.shape}')
 print(f'output: {outpt.shape}')
 print('')

print('Final Output:')
print(model.perceptron_outputs[-1].shape)

import numpy as np

class SimpleNN:
 def __init__(self, architecture):
 self.architecture = architecture
 self.weights = []
 self.biases = []

 #初始化權(quán)重和偏差
 np.random.seed(99)
 for i in range(len(architecture) - 1):
 self.weights.append(np.random.uniform(
 low=-1, high=1,
 size=(architecture[i], architecture[i+1])
 ))
 self.biases.append(np.zeros((1, architecture[i+1])))

 @staticmethod
 def relu(x):
 return np.maximum(0, x)

 @staticmethod
 def relu_as_weights(x):
 return (x > 0).astype(float)

 def forward(self, X):
 perceptron_inputs = [X]
 perceptron_outputs = []

 for W, b in zip(self.weights, self.biases):
 Z = np.dot(perceptron_inputs[-1], W) + b
 perceptron_outputs.append(Z)

 if W is self.weights[-1]: #最后一層（輸出）
 A = Z # 回歸線性輸出
 else:
 A = self.relu(Z)
 perceptron_inputs.append(A)

 return perceptron_inputs, perceptron_outputs

 def backward(self, perceptron_inputs, perceptron_outputs, target):
 weight_changes = []
 bias_changes = []

 m = len(target)
 dA = perceptron_inputs[-1] - target.reshape(-1, 1) # 輸出層梯度

 for i in reversed(range(len(self.weights))):
 dZ = dA if i == len(self.weights) - 1 else dA * self.relu_as_weights(perceptron_outputs[i])
 dW = np.dot(perceptron_inputs[i].T, dZ) / m
 db = np.sum(dZ, axis=0, keepdims=True) / m
 weight_changes.append(dW)
 bias_changes.append(db)

 if i > 0:
 dA = np.dot(dZ, self.weights[i].T)

 return list(reversed(weight_changes)), list(reversed(bias_changes))

 def predict(self, X):
 perceptron_inputs, _ = self.forward(X)
 return perceptron_inputs[-1].flatten()

#定義模型
architecture = [2, 64, 64, 64, 1] #兩個輸入，兩個隱藏層，一個輸出
model = SimpleNN(architecture)

#定義樣本輸入和目標(biāo)輸出
input = np.array([[0.1,0.2]])
desired_output = np.array([0.5])

#進(jìn)行正向和反向傳播來計算變化
perceptron_inputs, perceptron_outputs = model.forward(input)
weight_changes, bias_changes = model.backward(perceptron_inputs, perceptron_outputs, desired_output)

#用于打印的較小數(shù)字
np.set_printoptions(precisinotallow=2)

for i, (layer_weights, layer_biases, layer_weight_changes, layer_bias_changes)
in enumerate(zip(model.weights, model.biases, weight_changes, bias_changes)):
 print(f'layer {i}')
 print(f'weight matrix: {layer_weights.shape}')
 print(f'weight matrix changes: {layer_weight_changes.shape}')
 print(f'bias matrix: {layer_biases.shape}')
 print(f'bias matrix changes: {layer_bias_changes.shape}')
 print('')

print('The weight and weight change matrix of the second layer:')
print('weight matrix:')
print(model.weights[1])
print('change matrix:')
print(weight_changes[1])

# 計算輸出誤差
dA = perceptron_inputs[-1] - target.reshape(-1, 1)

#一個批處理大小的縮放因子。
#希望更改是所有批次的平均值，所以一旦聚合了所有更改，我們就除以m。

m = len(target)

for i in reversed(range(len(self.weights))):
 dZ = dA #現(xiàn)已簡化

 # 計算權(quán)重變化
 dW = np.dot(perceptron_inputs[i].T, dZ) / m
 #計算偏差的變化
 db = np.sum(dZ, axis=0, keepdims=True) / m

 # 跟蹤所需的變更
 weight_changes.append(dW)
 bias_changes.append(db)
 ...

dW = np.dot(perceptron_inputs[i].T, dZ) / m

dZ = dA if i == len(self.weights) - 1 else dA * self.relu_as_weights(perceptron_outputs[i])

def relu_as_weights(x):
 return (x > 0).astype(float)

import numpy as np

class SimpleNN:
 def __init__(self, architecture):
 self.architecture = architecture
 self.weights = []
 self.biases = []

 #初始化權(quán)重和偏差
 np.random.seed(99)
 for i in range(len(architecture) - 1):
 self.weights.append(np.random.uniform(
 low=-1, high=1,
 size=(architecture[i], architecture[i+1])
 ))
 self.biases.append(np.zeros((1, architecture[i+1])))

 @staticmethod
 def relu(x):
 return np.maximum(0, x)

 @staticmethod
 def relu_as_weights(x):
 return (x > 0).astype(float)

 def forward(self, X):
 perceptron_inputs = [X]
 perceptron_outputs = []

 for W, b in zip(self.weights, self.biases):
 Z = np.dot(perceptron_inputs[-1], W) + b
 perceptron_outputs.append(Z)

 if W is self.weights[-1]: # 最后一層（輸出）
 A = Z # 回歸線性輸出
 else:
 A = self.relu(Z)
 perceptron_inputs.append(A)

 return perceptron_inputs, perceptron_outputs

 def backward(self, perceptron_inputs, perceptron_outputs, y_true):
 weight_changes = []
 bias_changes = []

 m = len(y_true)
 dA = perceptron_inputs[-1] - y_true.reshape(-1, 1) # 回歸線性梯度

 for i in reversed(range(len(self.weights))):
 dZ = dA if i == len(self.weights) - 1 else dA * self.relu_as_weights(perceptron_outputs[i])
 dW = np.dot(perceptron_inputs[i].T, dZ) / m
 db = np.sum(dZ, axis=0, keepdims=True) / m
 weight_changes.append(dW)
 bias_changes.append(db)

 if i > 0:
 dA = np.dot(dZ, self.weights[i].T)

 return list(reversed(weight_changes)), list(reversed(bias_changes))

 def update_weights(self, weight_changes, bias_changes, lr):
 for i in range(len(self.weights)):
 self.weights[i] -= lr * weight_changes[i]
 self.biases[i] -= lr * bias_changes[i]

 def train(self, X, y, epochs, lr=0.01):
 for epoch in range(epochs):
 perceptron_inputs, perceptron_outputs = self.forward(X)
 weight_changes, bias_changes = self.backward(perceptron_inputs, perceptron_outputs, y)
 self.update_weights(weight_changes, bias_changes, lr)

 if epoch % 20 == 0 or epoch == epochs - 1:
 loss = np.mean((perceptron_inputs[-1].flatten() - y) ** 2) # MSE
 print(f"EPOCH {epoch}: Loss = {loss:.4f}")

 def predict(self, X):
 perceptron_inputs, _ = self.forward(X)
 return perceptron_inputs[-1].flatten()

# 數(shù)據(jù)扁平化處理
X_flat = X.flatten()
Y_flat = Y.flatten()
Z_flat = Z.flatten()

# 把X和Y入棧，作為輸入特性
inputs = np.column_stack((X_flat, Y_flat))
outputs = Z_flat

#規(guī)范化輸入和輸出
inputs_mean = np.mean(inputs, axis=0)
inputs_std = np.std(inputs, axis=0)
outputs_mean = np.mean(outputs)
outputs_std = np.std(outputs)

inputs = (inputs - inputs_mean) / inputs_std
outputs = (outputs - outputs_mean) / outputs_std

# 定義體系結(jié)構(gòu)：[input_dim, hidden1, ..., output_dim]
architecture = [2, 64, 64, 64, 1] #兩個輸入，兩個隱藏層，一個輸出
model = SimpleNN(architecture)

# 訓(xùn)練模型
model.train(inputs, outputs, epochs=2000, lr=0.001)

import matplotlib.pyplot as plt

# 將預(yù)測重新調(diào)整為網(wǎng)格格式，以進(jìn)行可視化
Z_pred = model.predict(inputs) * outputs_std + outputs_mean
Z_pred = Z_pred.reshape(X.shape)

#True函數(shù)圖和模型預(yù)測圖比較
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# 繪制True函數(shù)
axes[0].contourf(X, Y, Z, cmap='viridis')
axes[0].set_title("True Function")
axes[0].set_xlabel("X-axis")
axes[0].set_ylabel("Y-axis")
axes[0].colorbar = plt.colorbar(axes[0].contourf(X, Y, Z, cmap='viridis'), ax=axes[0], label="Function Value")

# 繪制預(yù)測函數(shù)
axes[1].contourf(X, Y, Z_pred, cmap='plasma')
axes[1].set_title("NN Predicted Function")
axes[1].set_xlabel("X-axis")
axes[1].set_ylabel("Y-axis")
axes[1].colorbar = plt.colorbar(axes[1].contourf(X, Y, Z_pred, cmap='plasma'), ax=axes[1], label="Function Value")

plt.tight_layout()
plt.show()

# 定義體系結(jié)構(gòu): [input_dim, hidden1, ..., output_dim]
architecture = [2, 64, 64, 64, 1] # 兩個輸入，兩個隱藏層，一個輸出
model = SimpleNN(architecture)

# 訓(xùn)練模型
model.train(inputs, outputs, epochs=2000, lr=0.001)

# 定義體系結(jié)構(gòu): [input_dim, hidden1, ..., output_dim]
architecture = [2, 64, 64, 64, 1] # Two inputs, two hidden layers, one output
model = SimpleNN(architecture)

# 訓(xùn)練模型
model.train(inputs, outputs, epochs=4000, lr=0.001)