loss = train_network(net, train)backward_network(net)

本文详细解析了深度学习网络的训练流程,包括train_network函数如何遍历min_batch进行训练,损失值的计算与累加,以及参数更新的时机。通过具体函数实现,展示了前向传播、后向传播及网络参数更新的过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

train_network(net, train)函数主体

float train_network(network *net, data d)
{
    assert(d.X.rows % net->batch == 0);//判断data d.X中保存的训练图像数据能否被min_batch整除
    int batch = net->batch;//将min_batch赋给batch,表示每次训练的数据
    int n = d.X.rows / batch;//d.X中的训练数据分几次训练
    int i;
    float sum = 0;//用来保存损失值
    for(i = 0; i < n; ++i){//遍历训练所有的min_batch
        get_next_batch(d, batch, i*batch, net->input, net->truth);//将每次训练的数据导入网络中去,每次训练min_batch数据
        /*
		void get_next_batch(data d, int n, int offset, float *X, float *y)
		{
		    int j;
		    for(j = 0; j < n; ++j){//遍历每张图像的数据和标签,将其导入网络中
		        int index = offset + j;//每批min_batch的偏移目录地址
		        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));//将d.X.vals[index]中的d.X.cols个float类型的数据复制到X+j*d.X.cols中去,即导入到net->input中;这里d.X.cols就是每一幅图像的数据量,即高*宽*通道,我的是设置的448x448x3=602112
		        if(y) memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));//同上,将与之对应的标签导入到net->truth中,这里我设置了一幅图上最大的检测框数量为90,每一个检测框包括5个标签数据,所以每幅图上的最大标签数据数量为90x5=450;
		    }
		}
		*/
        float err = train_network_datum(net);//核心训练函数
        sum += err;//将每次min_batch训练得出的损失累加
    }
    return (float)sum/(n*batch);//得到一个大的batch的平均损失值
}

float err = train_network_datum(net);函数主体

float train_network_datum(network *net)
{
    *net->seen += net->batch;//记录训练了多少图像
    net->train = 1;
    forward_network(net);//前向网络参考[博客](https://blog.youkuaiyun.com/m0_37799466/article/details/106192969)
    backward_network(net);//返回后向网络[博客](https://blog.youkuaiyun.com/m0_37799466/article/details/106195131)
    float error = *net->cost;//一次min_batch的损失值
    if(((*net->seen)/net->batch)%net->subdivisions == 0) update_network(net);//每训练一个大batch就更新一次参数,即net->batch*net->subdivisions,关注[博客](https://blog.youkuaiyun.com/m0_37799466/article/details/106285677)
    return error;
}
from data_process import get_data import torch from sklearn.model_selection import train_test_split from LeNet5 import LeNet5 X, y = get_data() # 获取数据【0.025,0.035】100*0.2 = 20 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y) # 数据拆分 print(X_train.shape) #(1075, 227, 227, 1) 0 1 2 3 --- (1075, 1, 227, 227) 0 3 1 2 X_train_tensor = torch.tensor(X_train, dtype=torch.float32).permute(0, 3, 1, 2) # 将数据转成模型要求的形式 print(X_train_tensor.shape) X_test_tensor = torch.tensor(X_test, dtype=torch.float32).permute(0, 3, 1, 2) y_train_tensor = torch.tensor(y_train, dtype=torch.int64) train_ds = torch.utils.data.TensorDataset(X_train_tensor, y_train_tensor) # 将数据转为tensordata类型 train_dl = torch.utils.data.DataLoader(train_ds, batch_size=128, shuffle=True) # 对数据进行分批及打乱操作 network = LeNet5() # 实例化得到一个leNet-5网络模型 loss_fn = torch.nn.CrossEntropyLoss() # 损失函数(交差熵) optimizer = torch.optim.SGD(network.parameters(), lr=0.01) # 优化器 # 模型训练 for epoch in range(1): for image, label in train_dl: y_pre = network(image) # 模型计算(前向传播) loss = loss_fn(y_pre, label) # 计算损失值 network.zero_grad() # 将网络中的所有梯度清零 loss.backward() # 计算梯度项(反向求导) optimizer.step() # 参数优化(模型训练) print('第{}轮训练,当前批次的训练损失值为:{}'.format(epoch, loss.item())) predicted = network(X_test_tensor) # 模型预测 result = predicted.data.numpy().argmax(axis=1) # 预测标签 acc_test = (result == y_test).mean() # 模型测试精度 print(acc_test) torch.save(network.state_dict(), 'leNet5-1.pt') # 保存模型参数
06-08
class NeuralNetwork: def init(self, input_dim, hidden_dim, output_dim): self.input_dim = input_dim self.hidden_dim = hidden_dim self.output_dim = output_dim self.weights1 = np.random.randn(input_dim, hidden_dim) self.bias1 = np.zeros((1, hidden_dim)) self.weights2 = np.random.randn(hidden_dim, output_dim) self.bias2 = np.zeros((1, output_dim)) def relu(self, x): return np.maximum(0, x) def relu_derivative(self, x): return np.where(x >= 0, 1, 0) def forward(self, x): self.z1 = np.dot(x, self.weights1) + self.bias1 self.a1 = self.relu(self.z1) self.z2 = np.dot(self.a1, self.weights2) + self.bias2 self.y_hat = self.z2 return self.y_hat def backward(self, x, y, learning_rate): error = self.y_hat - y delta2 = error delta1 = np.dot(delta2, self.weights2.T) * self.relu_derivative(self.a1) grad_weights2 = np.dot(self.a1.T, delta2) grad_bias2 = np.sum(delta2, axis=0, keepdims=True) grad_weights1 = np.dot(x.T, delta1) grad_bias1 = np.sum(delta1, axis=0) self.weights2 -= learning_rate * grad_weights2 self.bias2 -= learning_rate * grad_bias2 self.weights1 -= learning_rate * grad_weights1 def mse_loss(self, y, y_hat): return np.mean((y - y_hat)**2) def sgd_optimizer(self, x, y, learning_rate): y_hat = self.forward(x) loss = self.mse_loss(y, y_hat) self.backward(x, y, learning_rate) return loss def train(self, x, y, learning_rate, num_epochs): for i in range(num_epochs): y_hat = self.forward(x) loss = np.mean(np.square(y_hat - y)) loss_history.append(loss) self.backward(X, y, y_hat, learning_rate) if i % 100 == 0: print('Epoch', i, '- Loss:', loss) return loss_history input_dim=13 hidden_dim=25 output=1 nn=NeuralNetwork(input_dim, hidden_dim, output_dim) learning_rate=0.05 num_epochs=2000 loss_history=nn.train(x, y, learning_rate, num_epochs)分析代码
06-08
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值