【TensorFlow系列教程第四章】TensorFlow模型构建 深入理解TensorFlow中神经网络的关键步骤：前向传播、损失函数与反向传播

import tensorflow as tf

# 定义输入和输出数据的placeholder
x = tf.placeholder(tf.float32, shape=(None, input_size), name='x')
y_true = tf.placeholder(tf.float32, shape=(None, output_size), name='y_true')

# 定义神经网络的参数
hidden_size = 100
W1 = tf.Variable(tf.random_normal([input_size, hidden_size]), name='W1')
b1 = tf.Variable(tf.zeros([hidden_size]), name='b1')
W2 = tf.Variable(tf.random_normal([hidden_size, output_size]), name='W2')
b2 = tf.Variable(tf.zeros([output_size]), name='b2')

# 定义神经网络的结构
hidden_layer = tf.nn.relu(tf.matmul(x, W1) + b1)
output_layer = tf.matmul(hidden_layer, W2) + b2

# 定义损失函数
loss = tf.reduce_mean(tf.square(output_layer - y_true))

# 定义优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
train_op = optimizer.minimize(loss)

# 初始化变量
init = tf.global_variables_initializer()

# 创建会话并运行模型
with tf.Session() as sess:
    sess.run(init)
    
    # 训练模型
    for i in range(num_epochs):
        _, current_loss = sess.run([train_op, loss], feed_dict={x: input_data, y_true: target_data})
        
        if i % 100 == 0:
            print(f'Epoch {i}, Loss: {current_loss}')
    
    # 使用模型进行预测
    predictions = sess.run(output_layer, feed_dict={x: test_data})

import tensorflow as tf
from tensorflow.keras.losses import MeanSquaredError

# 定义真实标签和模型预测值
y_true = tf.constant([1.0, 2.0, 3.0])
y_pred = tf.constant([2.0, 2.5, 3.5])

# 计算均方差损失
loss_fn = MeanSquaredError()
loss = loss_fn(y_true, y_pred)

print('Mean Squared Error:', loss.numpy())

import tensorflow as tf
from tensorflow.keras.losses import CategoricalCrossentropy

# 定义真实标签和模型预测值
y_true = tf.constant([[0, 1, 0], [1, 0, 0], [0, 0, 1]])
y_pred = tf.constant([[0.1, 0.6, 0.3], [0.8, 0.1, 0.1], [0.2, 0.2, 0.6]])

# 计算交叉熵损失
loss_fn = CategoricalCrossentropy()
loss = loss_fn(y_true, y_pred)

print('Cross Entropy Loss:', loss.numpy())

import tensorflow as tf
from tensorflow.keras.losses import Loss

class CustomLoss(Loss):
    def __init__(self, weight):
        super(CustomLoss, self).__init__()
        self.weight = weight

    def call(self, y_true, y_pred):
        return tf.reduce_mean(tf.square(y_true - y_pred)) * self.weight

# 定义真实标签和模型预测值
y_true = tf.constant([1.0, 2.0, 3.0])
y_pred = tf.constant([2.0, 2.5, 3.5])

# 计算自定义损失
loss_fn = CustomLoss(weight=0.5)
loss = loss_fn(y_true, y_pred)

print('Custom Loss:', loss.numpy())

import tensorflow as tf
import numpy as np

# 定义输入数据的维度
input_dim = 2
# 定义隐藏层的神经元数量
hidden_dim = 3
# 定义输出层的神经元数量
output_dim = 1
# 定义学习率
learning_rate = 0.01

# 定义输入数据
X = tf.placeholder(tf.float32, shape=[None, input_dim])
# 定义标签数据
y = tf.placeholder(tf.float32, shape=[None, output_dim])

# 定义隐藏层参数
W1 = tf.Variable(tf.random_normal([input_dim, hidden_dim]))
b1 = tf.Variable(tf.zeros([hidden_dim]))
# 定义输出层参数
W2 = tf.Variable(tf.random_normal([hidden_dim, output_dim]))
b2 = tf.Variable(tf.zeros([output_dim]))

# 定义隐藏层输出
hidden_output = tf.nn.sigmoid(tf.matmul(X, W1) + b1)
# 定义输出层输出
output = tf.matmul(hidden_output, W2) + b2

# 定义损失函数
loss = tf.reduce_mean(tf.square(output - y))
# 定义优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

# 生成随机训练数据
X_train = np.random.rand(100, input_dim)
y_train = np.random.rand(100, output_dim)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    # 进行训练
    for i in range(1000):
        _, current_loss = sess.run([optimizer, loss], feed_dict={X: X_train, y: y_train})
        if i % 100 == 0:
            print("Step {}: Loss={}".format(i, current_loss))