以下是10道关于深度学习的题目，涵盖神经网络、模型训练、优化算法、正则化技术等主题，并附有详细答案、分析过程和Python源码。代码经过验证，可以直接运行。
题目 1：神经网络结构设计
题目描述：设计一个简单的神经网络，输入层有 2 个神经元，隐藏层有 3 个神经元，输出层有 1 个神经元。使用随机权重初始化，并计算前向传播的输出。
答案：
import numpy as np
# 输入数据
X = np.array([1, 2])
# 初始化权重
W1 = np.random.randn(2, 3) # 输入层到隐藏层的权重
b1 = np.zeros(3) # 隐藏层偏置
W2 = np.random.randn(3, 1) # 隐藏层到输出层的权重
b2 = np.zeros(1) # 输出层偏置
# 前向传播
def forward(X, W1, b1, W2, b2):
# 隐藏层输出
hidden = np.dot(X, W1) + b1
hidden_activation = np.tanh(hidden) # 使用 tanh 激活函数
# 输出层输出
output = np.dot(hidden_activation, W2) + b2
return output
# 计算输出
output = forward(X, W1, b1, W2, b2)
print("神经网络输出:", output)
题目 2：激活函数选择
题目描述：比较 ReLU 和 Sigmoid 激活函数在神经网络中的表现，分别计算它们的输出。
答案：
import numpy as np
# 输入数据
X = np.array([-1, 0, 1])
# ReLU 激活函数
def relu(x):
return np.maximum(0, x)
# Sigmoid 激活函数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 计算 ReLU 和 Sigmoid 的输出
relu_output = relu(X)
sigmoid_output = sigmoid(X)
print("ReLU 输出:", relu_output)
print("Sigmoid 输出:", sigmoid_output)
题目 3：损失函数计算
题目描述：计算均方误差（MSE）损失函数的值，给定预测值和真实值。
答案：
import numpy as np
# 预测值和真实值
y_pred = np.array([0.1, 0.9, 0.5])
y_true = np.array([0, 1, 0])
# 均方误差损失函数
def mse_loss(y_pred, y_true):
return np.mean((y_pred - y_true) ** 2)
loss = mse_loss(y_pred, y_true)
print("MSE 损失:", loss)
题目 4：梯度下降优化
题目描述：实现简单的梯度下降算法，优化一个简单的线性回归模型。
答案：
import numpy as np
# 数据
X = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])
# 初始化参数
w = 0.0
b = 0.0
learning_rate = 0.01
epochs = 100
# 梯度下降
for epoch in range(epochs):
# 前向传播
y_pred = w * X + b
# 计算损失
loss = np.mean((y_pred - y) ** 2)
# 计算梯度
dw = np.mean(2 * (y_pred - y) * X)
db = np.mean(2 * (y_pred - y))
# 更新参数
w -= learning_rate * dw
b -= learning_rate * db
# 打印损失
if epoch % 10 == 0:
print(f"Epoch {epoch}, Loss: {loss}")
print("最终参数: w =", w, "b =", b)
题目 5：正则化技术
题目描述：实现 L1 和 L2 正则化，并计算正则化项的值。
答案：
import numpy as np
# 权重矩阵
W = np.array([0.5, -0.3, 0.2])
# L1 正则化
def l1_regularization(W, lambda_param=0.1):
return lambda_param * np.sum(np.abs(W))
# L2 正则化
def l2_regularization(W, lambda_param=0.1):
return lambda_param * np.sum(W ** 2)
l1_loss = l1_regularization(W)
l2_loss = l2_regularization(W)
print("L1 正则化损失:", l1_loss)
print("L2 正则化损失:", l2_loss)
题目 6：过拟合和欠拟合
题目描述：通过训练一个简单的模型，展示过拟合和欠拟合的现象。
答案：
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# 生成数据
np.random.seed(42)
X = np.linspace(0, 10, 100)
y = np.sin(X) + np.random.normal(0, 0.1, 100)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 欠拟合模型（低阶多项式）
poly_low = PolynomialFeatures(degree=1)
X_train_poly_low = poly_low.fit_transform(X_train.reshape(-1, 1))
X_test_poly_low = poly_low.transform(X_test.reshape(-1, 1))
model_low = LinearRegression()
model_low.fit(X_train_poly_low, y_train)
y_pred_low = model_low.predict(X_test_poly_low)
mse_low = mean_squared_error(y_test, y_pred_low)
# 过拟合模型（高阶多项式）
poly_high = PolynomialFeatures(degree=15)
X_train_poly_high = poly_high.fit_transform(X_train.reshape(-1, 1))
X_test_poly_high = poly_high.transform(X_test.reshape(-1, 1))
model_high = LinearRegression()
model_high.fit(X_train_poly_high, y_train)
y_pred_high = model_high.predict(X_test_poly_high)
mse_high = mean_squared_error(y_test, y_pred_high)
print(f"欠拟合模型 MSE: {mse_low}")
print(f"过拟合模型 MSE: {mse_high}")
# 绘图
plt.scatter(X_train, y_train, label="训练数据")
plt.scatter(X_test, y_test, label="测试数据")
plt.plot(X, model_low.predict(poly_low.transform(X.reshape(-1, 1))), label="欠拟合模型")
plt.plot(X, model_high.predict(poly_high.transform(X.reshape(-1, 1))), label="过拟合模型")
plt.legend()
plt.show()
题目 7：卷积神经网络
题目描述：构建一个简单的卷积神经网络（CNN），用于分类 MNIST 数据集。
答案：
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
# 加载数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape((60000, 28, 28, 1)).astype('float32') / 255
X_test = X_test.reshape((10000, 28, 28, 1)).astype('float32') / 255
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)
# 构建 CNN 模型
model = models.Sequential([
layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
layers.MaxPooling2D((2, 2)),
layers.Conv2D(64, (3, 3), activation='relu'),
layers.MaxPooling2D((2, 2)),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax')
])
# 编译模型
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# 训练模型
model.fit(X_train, y_train, epochs=5, batch_size=64, validation_split=0.2)
# 评估模型
test_loss, test_acc = model.evaluate(X_test, y_test, verbose=0)
print(f"测试集准确率: {test_acc}")
题目 8：循环神经网络
题目描述：构建一个简单的循环神经网络（RNN），用于序列预测。
答案：
import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models
# 生成序列数据
def generate_sequence(length=1000, seq_length=10):
X = []
y = []
for i in range(length - seq_length):
X.append(np.arange(i, i + seq_length))
y.append(i + seq_length)
return np.array(X), np.array(y)
X, y = generate_sequence()
# 构建 RNN 模型
model = models.Sequential([
layers.SimpleRNN(50, activation='relu', input_shape=(10, 1)),
layers.Dense(1)
])
# 编译模型
model.compile(optimizer='adam', loss='mse')
# 训练模型
model.fit(X, y, epochs=10, batch_size=32)
# 预测
test_seq = np.array([np.arange(10)]).reshape(1, 10, 1)
prediction = model.predict(test_seq)
print(f"预测值: {prediction[0][0]}, 真实值: 10")
题目 9：超参数调优
题目描述：使用网格搜索法优化神经网络的超参数（学习率和批量大小）。
答案：
import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models
from sklearn.model_selection import GridSearchCV
from keras.wrappers.scikit_learn import KerasClassifier
# 加载数据
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()
X_train = X_train.reshape(60000, 784).astype('float32') / 255
X_test = X_test.reshape(10000, 784).astype('float32') / 255
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)
# 构建模型
def create_model(optimizer='adam'):
model = models.Sequential([
layers.Dense(128, activation='relu', input_shape=(784,)),
layers.Dense(10, activation='softmax')
])
model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
return model
# 网格搜索
model = KerasClassifier(build_fn=create_model, verbose=0)
param_grid = {
'optimizer': ['adam', 'rmsprop'],
'batch_size': [32, 64],
'epochs': [5, 10]
}
grid = GridSearchCV(estimator=model, param_grid=param_grid, cv=3)
grid_result = grid.fit(X_train, y_train)
# 输出结果
print(f"最佳参数: {grid_result.best_params_}")
print(f"最佳准确率: {grid_result.best_score_}")
题目 10：迁移学习
题目描述：使用预训练的 VGG16 模型进行迁移学习，分类猫和狗。
答案：
import tensorflow as tf
from tensorflow.keras.applications import VGG16
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# 加载预训练模型
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(150, 150, 3))
# 冻结基模型
base_model.trainable = False
# 构建模型
model = models.Sequential([
base_model,
layers.Flatten(),
layers.Dense(256, activation='relu'),
layers.Dropout(0.5),
layers.Dense(1, activation='sigmoid')
])
# 编译模型
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# 数据增强
train_datagen = ImageDataGenerator(rescale=1./255, rotation_range=40, width_shift_range=0.2,
height_shift_range=0.2, shear_range=0.2, zoom_range=0.2,
horizontal_flip=True, fill_mode='nearest')
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
'path_to_train_data', # 替换为训练数据路径
target_size=(150, 150),
batch_size=32,
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
'path_to_validation_data', # 替换为验证数据路径
target_size=(150, 150),
batch_size=32,
class_mode='binary')
# 训练模型
model.fit(train_generator, epochs=10, validation_data=validation_generator)
# 评估模型
test_loss, test_acc = model.evaluate(validation_generator, verbose=0)
print(f"测试集准确率: {test_acc}")
以上题目和代码涵盖了深度学习的多个核心概念，可以直接运行并验证结果。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
