神经网络完整学习过程：从数据到智能的演变之旅
目录
- 一、整体流程概览
- 二、阶段一：数据准备
- 三、阶段二：网络前向传播
- 四、阶段三：损失计算与评估
- 五、阶段四：反向传播与梯度计算
- 六、阶段五：参数优化更新
- 七、阶段六：迭代训练过程
- 八、阶段七：模型验证与测试
- 九、阶段八：超参数调优
- 十、完整案例演示
- 十一、总结
一、整体流程概览
1.1 神经网络学习的完整流程图
数据准备 → 前向传播 → 损失计算 → 反向传播 → 参数更新 → 重复迭代
↓ ↓ ↓ ↓ ↓ ↓
预处理 网络计算 误差评估 梯度计算 优化器 收敛检查1.2 学习过程的核心循环
python
# 伪代码：神经网络训练的核心循环
for epoch in range(num_epochs): # 遍历整个数据集多次
for batch in data_loader: # 分批处理数据
# 前向传播
predictions = model(batch.inputs)
# 计算损失
loss = loss_function(predictions, batch.labels)
# 反向传播
optimizer.zero_grad() # 清空上一轮梯度
loss.backward() # 计算梯度
# 参数更新
optimizer.step() # 更新权重参数
# 监控与记录
log_metrics(loss, predictions, batch.labels)
# 验证集评估
validation_accuracy = evaluate(model, validation_data)
# 早停检查
if early_stopping(validation_accuracy):
break二、阶段一：数据准备
2.1 数据收集与清洗
步骤：
- 数据收集：获取原始数据集
- 数据清洗：处理缺失值、异常值
- 数据标注：监督学习需要标签数据
示例：图像分类数据准备
python
# 数据加载与预处理
import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
# 数据转换管道
transform = transforms.Compose([
transforms.Resize((32, 32)), # 调整大小
transforms.ToTensor(), # 转为张量
transforms.Normalize( # 标准化
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5]
)
])
# 加载数据集
train_dataset = CIFAR10(root='./data', train=True,
download=True, transform=transform)
test_dataset = CIFAR10(root='./data', train=False,
download=True, transform=transform)2.2 数据划分
| 数据集 | 比例 | 用途 |
|---|---|---|
| 训练集 | 60-80% | 模型训练，参数学习 |
| 验证集 | 10-20% | 超参数调优，防止过拟合 |
| 测试集 | 10-20% | 最终性能评估 |
2.3 数据增强（防止过拟合）
python
# 数据增强策略
data_augmentation = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5), # 随机水平翻转
transforms.RandomRotation(10), # 随机旋转
transforms.ColorJitter( # 颜色抖动
brightness=0.2, contrast=0.2,
saturation=0.2, hue=0.1
),
transforms.RandomResizedCrop(224, scale=(0.8, 1.0))
])三、阶段二：网络前向传播
3.1 网络架构定义
python
import torch.nn as nn
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
# 输入层 → 隐藏层1
self.fc1 = nn.Linear(784, 256) # 784个输入特征，256个神经元
self.relu1 = nn.ReLU()
self.dropout1 = nn.Dropout(0.3)
# 隐藏层1 → 隐藏层2
self.fc2 = nn.Linear(256, 128)
self.relu2 = nn.ReLU()
self.dropout2 = nn.Dropout(0.3)
# 隐藏层2 → 输出层
self.fc3 = nn.Linear(128, 10) # 10个类别
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
# 展平输入 (batch_size, 1, 28, 28) → (batch_size, 784)
x = x.view(x.size(0), -1)
# 前向传播过程
x = self.fc1(x)
x = self.relu1(x)
x = self.dropout1(x)
x = self.fc2(x)
x = self.relu2(x)
x = self.dropout2(x)
x = self.fc3(x)
output = self.softmax(x)
return output3.2 前向传播的数学过程
对于第l层：
- 线性变换：z⁽ˡ⁾ = W⁽ˡ⁾·a⁽ˡ⁻¹⁾ + b⁽ˡ⁾
- 激活函数：a⁽ˡ⁾ = f(z⁽ˡ⁾)
多层网络的前向传播：
输入x → 第一层处理 → 激活 → 第二层处理 → 激活 → ... → 输出层 → 预测ŷ四、阶段三：损失计算与评估
4.1 常见损失函数
| 任务类型 | 损失函数 | 公式 | 特点 |
|---|---|---|---|
| 二分类 | 二元交叉熵 | L = -[y·log(ŷ)+(1-y)·log(1-ŷ)] | 输出概率在0-1之间 |
| 多分类 | 交叉熵 | L = -Σ yᵢ·log(ŷᵢ) | 配合Softmax使用 |
| 回归 | 均方误差 | L = (y - ŷ)² / n | 预测连续值 |
| 目标检测 | Smooth L1 | 条件分段函数 | 对异常值鲁棒 |
4.2 损失计算示例
python
# 分类任务损失计算
import torch.nn.functional as F
def compute_loss(predictions, labels):
"""
predictions: (batch_size, num_classes) - 模型预测概率
labels: (batch_size,) - 真实标签
"""
# 交叉熵损失
loss = F.cross_entropy(predictions, labels)
# 可选：添加L2正则化（权重衰减）
l2_lambda = 0.001
l2_norm = sum(p.pow(2.0).sum() for p in model.parameters())
total_loss = loss + l2_lambda * l2_norm
return total_loss4.3 性能评估指标
python
def evaluate_performance(predictions, labels):
"""
计算多种评估指标
"""
# 准确率
_, predicted_classes = torch.max(predictions, 1)
accuracy = (predicted_classes == labels).float().mean()
# 精确率、召回率、F1分数（二分类）
if predictions.shape[1] == 2:
precision = precision_score(labels.cpu(), predicted_classes.cpu())
recall = recall_score(labels.cpu(), predicted_classes.cpu())
f1 = f1_score(labels.cpu(), predicted_classes.cpu())
return {
'accuracy': accuracy.item(),
'precision': precision if 'precision' in locals() else None,
'recall': recall if 'recall' in locals() else None,
'f1': f1 if 'f1' in locals() else None
}五、阶段四：反向传播与梯度计算
5.1 反向传播的数学原理
链式法则应用 ：
∂L/∂W⁽ˡ⁾ = ∂L/∂a⁽ᴸ⁾ · ∂a⁽ᴸ⁾/∂z⁽ᴸ⁾ · ∂z⁽ᴸ⁾/∂a⁽ᴸ⁻¹⁾ · ... · ∂z⁽ˡ⁾/∂W⁽ˡ⁾
5.2 自动微分实现
python
# PyTorch中的反向传播
def backward_propagation_example():
# 前向传播
x = torch.randn(10, 784, requires_grad=True)
y_pred = model(x)
loss = loss_function(y_pred, y_true)
# 反向传播（自动计算所有梯度）
loss.backward() # 关键步骤！
# 查看梯度
print(f"第一层权重梯度形状: {model.fc1.weight.grad.shape}")
print(f"第一层偏置梯度形状: {model.fc1.bias.grad.shape}")
# 梯度统计
grad_norms = []
for name, param in model.named_parameters():
if param.grad is not None:
norm = param.grad.norm().item()
grad_norms.append((name, norm))
return grad_norms5.3 梯度消失/爆炸的监控
python
def monitor_gradients(model, threshold_min=1e-7, threshold_max=1e3):
"""
监控梯度是否消失或爆炸
"""
vanishing_layers = []
exploding_layers = []
for name, param in model.named_parameters():
if param.grad is not None:
grad_norm = param.grad.norm().item()
if grad_norm < threshold_min:
vanishing_layers.append((name, grad_norm))
print(f"警告：{name}梯度可能消失，范数: {grad_norm:.2e}")
elif grad_norm > threshold_max:
exploding_layers.append((name, grad_norm))
print(f"警告：{name}梯度可能爆炸，范数: {grad_norm:.2e}")
return vanishing_layers, exploding_layers六、阶段五：参数优化更新
6.1 优化器选择
| 优化器 | 公式 | 适用场景 | 优点 |
|---|---|---|---|
| SGD | w = w - η·∇L | 简单任务 | 简单，理论成熟 |
| SGD+Momentum | v = βv + η∇L, w = w - v | 大部分场景 | 减少震荡，加速收敛 |
| Adam | 自适应学习率 | 深度学习默认 | 自适应，调参简单 |
| RMSprop | 自适应梯度缩放 | RNN/LSTM | 处理非平稳目标 |
6.2 优化器实现
python
# 不同优化器的使用
import torch.optim as optim
# 1. 随机梯度下降
optimizer_sgd = optim.SGD(model.parameters(),
lr=0.01,
momentum=0.9,
weight_decay=1e-4) # L2正则化
# 2. Adam优化器（最常用）
optimizer_adam = optim.Adam(model.parameters(),
lr=0.001,
betas=(0.9, 0.999),
eps=1e-8,
weight_decay=1e-4)
# 3. 学习率调度器
scheduler = optim.lr_scheduler.StepLR(optimizer_adam,
step_size=10,
gamma=0.1) # 每10轮学习率×0.16.3 参数更新过程
python
def training_step(model, batch, optimizer, loss_fn):
"""
单次训练步骤
"""
# 1. 清空梯度（重要！）
optimizer.zero_grad()
# 2. 前向传播
inputs, labels = batch
predictions = model(inputs)
# 3. 计算损失
loss = loss_fn(predictions, labels)
# 4. 反向传播
loss.backward()
# 5. 梯度裁剪（防止梯度爆炸）
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
# 6. 参数更新
optimizer.step()
# 7. 学习率调整
scheduler.step()
return loss.item()七、阶段六：迭代训练过程
7.1 训练循环结构
python
def train_model(model, train_loader, val_loader, epochs=50):
"""
完整的训练循环
"""
# 初始化
train_losses = []
val_accuracies = []
best_val_acc = 0.0
patience_counter = 0
patience_limit = 10 # 早停耐心值
for epoch in range(epochs):
# ---------- 训练阶段 ----------
model.train() # 设置为训练模式
epoch_loss = 0.0
batch_count = 0
for batch_idx, (inputs, labels) in enumerate(train_loader):
# 单批次训练
loss = training_step(model, (inputs, labels), optimizer, loss_fn)
epoch_loss += loss
batch_count += 1
# 每100个batch输出一次进度
if batch_idx % 100 == 0:
print(f'Epoch: {epoch+1}/{epochs} | '
f'Batch: {batch_idx}/{len(train_loader)} | '
f'Loss: {loss:.4f}')
# 计算平均训练损失
avg_train_loss = epoch_loss / batch_count
train_losses.append(avg_train_loss)
# ---------- 验证阶段 ----------
model.eval() # 设置为评估模式
val_accuracy = evaluate_model(model, val_loader)
val_accuracies.append(val_accuracy)
print(f'Epoch {epoch+1}完成: '
f'训练损失 = {avg_train_loss:.4f}, '
f'验证准确率 = {val_accuracy:.2%}')
# ---------- 早停检查 ----------
if val_accuracy > best_val_acc:
best_val_acc = val_accuracy
patience_counter = 0
# 保存最佳模型
torch.save(model.state_dict(), 'best_model.pth')
print(f'保存最佳模型，准确率: {val_accuracy:.2%}')
else:
patience_counter += 1
if patience_counter >= patience_limit:
print(f'早停触发，连续{patience_limit}轮验证准确率未提升')
break
return train_losses, val_accuracies7.2 训练过程可视化
python
import matplotlib.pyplot as plt
def plot_training_history(train_losses, val_accuracies):
"""
绘制训练历史
"""
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
# 损失曲线
ax1.plot(train_losses, label='训练损失', color='blue')
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss')
ax1.set_title('训练损失变化曲线')
ax1.legend()
ax1.grid(True, alpha=0.3)
# 准确率曲线
ax2.plot(val_accuracies, label='验证准确率', color='green')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Accuracy')
ax2.set_title('验证准确率变化曲线')
ax2.legend()
ax2.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()八、阶段七：模型验证与测试
8.1 模型评估模式
python
def evaluate_model(model, data_loader):
"""
评估模型性能
"""
model.eval() # 重要：切换到评估模式
correct = 0
total = 0
# 不计算梯度，加快速度
with torch.no_grad():
for inputs, labels in data_loader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = correct / total
return accuracy
def test_model_final(model, test_loader):
"""
最终测试
"""
# 加载最佳模型
model.load_state_dict(torch.load('best_model.pth'))
# 评估
test_accuracy = evaluate_model(model, test_loader)
# 详细测试结果
print("=" * 50)
print("最终测试结果")
print("=" * 50)
print(f"测试集准确率: {test_accuracy:.2%}")
# 混淆矩阵
from sklearn.metrics import confusion_matrix, classification_report
all_preds = []
all_labels = []
with torch.no_grad():
for inputs, labels in test_loader:
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
all_preds.extend(preds.cpu().numpy())
all_labels.extend(labels.cpu().numpy())
# 打印分类报告
print("\n分类报告:")
print(classification_report(all_labels, all_preds))
return test_accuracy8.2 过拟合检测
python
def detect_overfitting(train_losses, val_losses, train_accs, val_accs):
"""
检测过拟合
"""
# 计算过拟合指标
final_train_loss = train_losses[-1]
final_val_loss = val_losses[-1]
final_train_acc = train_accs[-1]
final_val_acc = val_accs[-1]
# 损失差距
loss_gap = final_val_loss - final_train_loss
# 准确率差距
acc_gap = final_train_acc - final_val_acc
print(f"训练损失: {final_train_loss:.4f}")
print(f"验证损失: {final_val_loss:.4f}")
print(f"损失差距: {loss_gap:.4f}")
print(f"训练准确率: {final_train_acc:.2%}")
print(f"验证准确率: {final_val_acc:.2%}")
print(f"准确率差距: {acc_gap:.2%}")
# 判断是否过拟合
if acc_gap > 0.05: # 准确率差距超过5%
print("⚠️ 警告：可能出现过拟合！")
print("建议：增加数据增强、添加Dropout、增加正则化")
elif acc_gap < 0.01:
print("✅ 模型泛化能力良好")
else:
print("⚠️ 模型有一定过拟合倾向")
return loss_gap, acc_gap九、阶段八：超参数调优
9.1 重要超参数
python
# 超参数配置
hyperparameters = {
# 学习相关
'learning_rate': 0.001, # 最重要超参数
'batch_size': 32, # 32, 64, 128, 256
'num_epochs': 100,
# 网络结构
'hidden_size': 128, # 隐藏层神经元数
'num_layers': 3, # 网络深度
'dropout_rate': 0.3, # 丢弃率
# 优化器
'optimizer': 'adam', # 'sgd', 'adam', 'rmsprop'
'weight_decay': 1e-4, # L2正则化强度
# 学习率调度
'scheduler_type': 'step', # 'step', 'cosine', 'plateau'
'step_size': 10,
'gamma': 0.1,
}9.2 超参数搜索策略
python
# 网格搜索示例
def grid_search_hyperparameters():
"""
网格搜索超参数
"""
learning_rates = [0.1, 0.01, 0.001, 0.0001]
batch_sizes = [16, 32, 64, 128]
hidden_sizes = [64, 128, 256, 512]
results = []
for lr in learning_rates:
for batch_size in batch_sizes:
for hidden_size in hidden_sizes:
print(f"测试: lr={lr}, batch={batch_size}, hidden={hidden_size}")
# 重新初始化模型
model = NeuralNetwork(hidden_size=hidden_size)
# 训练模型
train_losses, val_accs = train_model_with_params(
model, lr, batch_size
)
# 记录结果
best_val_acc = max(val_accs)
results.append({
'lr': lr,
'batch_size': batch_size,
'hidden_size': hidden_size,
'best_val_acc': best_val_acc
})
# 找出最佳组合
best_result = max(results, key=lambda x: x['best_val_acc'])
return best_result, results
# 随机搜索（更高效）
def random_search_hyperparameters(num_trials=20):
import random
results = []
for trial in range(num_trials):
# 随机选择超参数
lr = 10 ** random.uniform(-4, -1) # 10^-4 到 10^-1
batch_size = random.choice([16, 32, 64, 128, 256])
dropout = random.uniform(0.1, 0.5)
# 训练和评估...
return results十、完整案例演示
10.1 MNIST手写数字识别完整流程
python
"""
MNIST手写数字识别完整示例
"""
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
# 1. 数据准备
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, transform=transform)
# 划分验证集
train_size = int(0.8 * len(train_dataset))
val_size = len(train_dataset) - train_size
train_dataset, val_dataset = torch.utils.data.random_split(train_dataset, [train_size, val_size])
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
# 2. 定义模型
class MNISTClassifier(nn.Module):
def __init__(self):
super(MNISTClassifier, self).__init__()
self.fc1 = nn.Linear(28*28, 256)
self.relu1 = nn.ReLU()
self.dropout1 = nn.Dropout(0.25)
self.fc2 = nn.Linear(256, 128)
self.relu2 = nn.ReLU()
self.dropout2 = nn.Dropout(0.25)
self.fc3 = nn.Linear(128, 10)
def forward(self, x):
x = x.view(x.size(0), -1) # 展平
x = self.fc1(x)
x = self.relu1(x)
x = self.dropout1(x)
x = self.fc2(x)
x = self.relu2(x)
x = self.dropout2(x)
x = self.fc3(x)
return x
# 3. 初始化
model = MNISTClassifier()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.5)
# 4. 训练循环
num_epochs = 20
train_losses = []
val_accuracies = []
for epoch in range(num_epochs):
# 训练阶段
model.train()
running_loss = 0.0
for batch_idx, (inputs, labels) in enumerate(train_loader):
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
avg_train_loss = running_loss / len(train_loader)
train_losses.append(avg_train_loss)
# 验证阶段
model.eval()
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in val_loader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
val_accuracy = correct / total
val_accuracies.append(val_accuracy)
# 学习率调整
scheduler.step()
print(f'Epoch [{epoch+1}/{num_epochs}], '
f'Loss: {avg_train_loss:.4f}, '
f'Val Acc: {val_accuracy:.2%}, '
f'LR: {scheduler.get_last_lr()[0]:.6f}')
# 5. 最终测试
model.eval()
test_correct = 0
test_total = 0
with torch.no_grad():
for inputs, labels in test_loader:
outputs = model(inputs)
_, predicted = torch.max(outputs.data, 1)
test_total += labels.size(0)
test_correct += (predicted == labels).sum().item()
print(f'测试集准确率: {test_correct/test_total:.2%}')
# 6. 保存模型
torch.save({
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'train_losses': train_losses,
'val_accuracies': val_accuracies,
}, 'mnist_model_complete.pth')10.2 训练过程分析
python
def analyze_training_process(train_losses, val_accuracies):
"""
分析训练过程
"""
print("=" * 60)
print("训练过程分析报告")
print("=" * 60)
# 1. 收敛性分析
print("\n1. 收敛性分析:")
final_loss = train_losses[-1]
loss_reduction = (train_losses[0] - final_loss) / train_losses[0] * 100
print(f" 初始损失: {train_losses[0]:.4f}")
print(f" 最终损失: {final_loss:.4f}")
print(f" 损失下降: {loss_reduction:.1f}%")
# 2. 稳定性分析
print("\n2. 稳定性分析:")
loss_fluctuation = max(train_losses) - min(train_losses)
print(f" 损失波动范围: {loss_fluctuation:.4f}")
# 3. 泛化能力分析
print("\n3. 泛化能力分析:")
final_train_acc = val_accuracies[-1]
print(f" 最终验证准确率: {final_train_acc:.2%}")
# 4. 学习曲线分析
print("\n4. 学习曲线分析:")
if train_losses[-5] > train_losses[-1]:
print(" ✅ 损失仍在下降，可继续训练")
else:
print(" ⚠️ 损失趋于平稳，接近收敛")
# 5. 建议
print("\n5. 改进建议:")
if loss_reduction < 50:
print(" • 增加网络深度或宽度")
print(" • 调整学习率")
elif final_train_acc < 0.9:
print(" • 增加训练数据")
print(" • 添加数据增强")
print(" • 尝试不同的网络架构")
else:
print(" • 模型性能良好，可考虑部署")
analyze_training_process(train_losses, val_accuracies)十一、总结
11.1 神经网络学习的完整流程回顾
| 阶段 | 核心任务 | 关键技术 | 输出结果 |
|---|---|---|---|
| 数据准备 | 数据收集、清洗、划分 | 数据增强、标准化 | 训练/验证/测试集 |
| 网络设计 | 架构设计、初始化 | 网络层、激活函数 | 神经网络模型 |
| 前向传播 | 计算预测值 | 矩阵乘法、激活函数 | 预测输出ŷ |
| 损失计算 | 评估预测误差 | 损失函数、评估指标 | 损失值L |
| 反向传播 | 计算梯度 | 链式法则、自动微分 | 梯度∂L/∂W |
| 参数更新 | 优化权重 | 优化器、学习率调度 | 更新后的W,b |
| 迭代训练 | 重复优化 | 批量训练、早停 | 训练历史 |
| 验证测试 | 评估泛化能力 | 评估指标、混淆矩阵 | 最终性能 |
11.2 关键成功因素
- 数据质量 > 模型复杂度：高质量数据比复杂模型更重要
- 适当的过拟合：训练准确率应略高于验证准确率，但差距不宜过大
- 监控与调试：持续监控损失曲线和评估指标
- 耐心与迭代：深度学习需要多次实验和调优
11.3 常见问题与解决方案
| 问题 | 症状 | 解决方案 |
|---|---|---|
| 梯度消失 | 浅层参数不更新 | 使用ReLU、ResNet、BatchNorm |
| 过拟合 | 训练好但验证差 | Dropout、数据增强、正则化 |
| 欠拟合 | 训练和验证都差 | 增加模型复杂度、增加训练时间 |
| 训练震荡 | 损失波动大 | 减小学习率、增加批量大小 |
| 收敛慢 | 损失下降缓慢 | 增大学习率、检查数据质量 |
11.4 哲学思考
神经网络的学习过程本质上是一个信息压缩与模式发现的过程：
- 压缩：将大量数据压缩为少量参数（权重）
- 泛化：从有限样本学习普遍规律
- 适应：通过迭代不断调整和改进
这个过程与人类学习惊人相似：
- 前向传播 = 尝试与预测
- 损失计算 = 结果评估
- 反向传播 = 反思与调整
- 参数更新 = 经验积累
11.5 实践建议
- 从小开始：先用小数据集、简单模型验证流程
- 逐步复杂：成功后再增加数据和模型复杂度
- 记录一切：详细记录每次实验的超参数和结果
- 可视化：图表比数字更直观
- 耐心：深度学习需要时间和反复实验
神经网络的学习是一个系统工程，理解每个环节的作用和相互关系，才能真正掌握深度学习的精髓。这个过程虽然复杂，但每一步都有其明确的目的和意义，共同构成了现代人工智能的基础。