Machine learning 如何解决'；CUDA内存不足。试图分配xxx MiB'；在皮托克？

我试图在pytorch培训一名CNN，但我遇到了一些问题。 运行时错误：

运行时错误：CUDA内存不足。尝试分配512.00 MiB（GPU 0； 2.00 GiB总容量；584.97 MiB已分配；13.81 MiB空闲；PyTorch共保留590.00 MiB）

这是我的代码：

导入操作系统
将numpy作为np导入
进口cv2
进口火炬
导入torch.nn作为nn
导入torchvision.transforms作为变换
从torch.utils.data导入数据加载器，数据集
导入时间
将matplotlib.pyplot作为plt导入
%matplotlib内联
root_path='C:/Users/60960/Desktop/recet task/course_LeeML20/course_LeeML20-datasets/hw3/food-11'
培训路径=根路径+'/training'
测试路径=根路径+'/testing'
验证路径=根路径+'/validation'
def readfile（路径，有_标签）：
img_path=sorted（os.listdir（path））
x=np.zero（（len（img_路径），128128,3，dtype=np.uint8）
y=np.zero（（len（img_路径）），dtype=np.uint8）
对于i，枚举中的文件（img_路径）：
img=cv2.imread（路径+'/'+文件）
x[i，：，：]=cv2.resize（img，（128128））
如果有_标签：
y[i]=int（file.split（“”“）[0]）
如果有_标签：
返回x，y
其他：
返回x
def显示img（来自cv2的img）：
b、 g，r=cv2.分割（img_与cv2）
img=cv2.merge（[r，g，b]）
plt.imshow（img）
plt.show（）
x\u train，y\u train=readfile（训练路径，True）
x_val，y_val=readfile（验证路径，True）
x_test=readfile（测试路径，False）
train_transform=transforms.Compose([
transforms.ToPILImage（），
transforms.RandomHorizontalFlip（），
随机旋转（15），
transforms.ToTensor（）
])
test_transform=transforms.Compose([
transforms.ToPILImage（），
transforms.ToTensor（）
])
类ImgDataset（数据集）：
定义初始化（self，x，y=None，transform=None）：
self.x=x
self.y=y
如果y不是无：
self.y=t.LongTensor（y）
自我转换=转换
定义（自我）：
返回len（self.x）
def uu getitem uu（self，idx）：
X=self.X[idx]
如果self.transform不是None：
X=自转换（X）
如果self.y不是无：
Y=self.Y[idx]
返回X，Y
返回X
批量大小=128
列车组=ImgDataset（x列车、y列车、变换=列车变换）
val\u set=ImgDataset（x\u val，y\u val，transform=test\u transform）
序列加载器=数据加载器（序列集，批量大小=批量大小，随机播放=真）
val_loader=DataLoader（val_set，batch_size=batch_size，shuffle=False）
类分类器（nn.Module）：
定义初始化（自）：
超级（分类器，自）。\uuuu初始化
self.cnn=nn.Sequential(
nn.Conv2d（3,64,3,1,1），
nn.2D（64），
nn.ReLU（），
nn.MaxPool2d（2,2,0），
nn.Conv2d（64128,3,1,1），
nn.2D（128），
nn.ReLU（），
nn.MaxPool2d（2,2,0），
nn.Conv2d（128256,3,1,1），
nn.2D（256），
nn.ReLU（），
nn.MaxPool2d（2,2,0），
nn.Conv2d（256512,3,1,1），
nn.2D（512），
nn.ReLU（），
nn.MaxPool2d（2,2,0），
nn.Conv2d（512512,3,1,1），
nn.2D（512），
nn.ReLU（），
nn.MaxPool2d（2,2,0）
)
self.fc=nn(
nn.线性（512*4*41024），
nn.ReLU（），
nn.线性（1024512），
nn.ReLU（），
nn.线性（512,11）
)
def前进（自身，x）：
out=self.cnn（x）
out=out.view（out.size（）[0]，-1）
返回self.fc（输出）
模型=分类器（）.cuda（）
损耗=nn.CrossEntropyLoss（）
optim=t.optim.Adam（model.parameters（），lr=0.001）
纪元=30
对于范围内的历元（历元）：
epoch\u start\u time=time.time（）
列车acc=0.0
列车损耗=0.0
val_acc=0.0
val_损失=0.0
模型列车（）
对于i，枚举中的数据（列装载机）：
优化零度梯度（）
列车pred=model（数据[0].cuda（））
批次损失=损失（序列pred，数据[1].cuda（））
批次损失向后（）
optim.step（）
列车acc+=np.sum（np.argmax（列车cpu（）.data.numpy（），轴=1）==data[1].numpy（））
列车损失+=批次损失。项目（）
model.eval（）
带t.no_grad（）：
对于i，枚举中的数据（val_加载器）：
val_pred=model（数据[0].cuda（））
批次损失=损失（val\U pred，数据[1].cuda（））
val_acc+=np.sum（np.argmax（val_pred.cpu（）.data.numpy（），axis=1）=data[1].numpy（））
val_损失+=批次损失。项目（）
打印（“[%03d/%03d]%2.2f秒列车附件：%3.6f损失：%3.6f；Val附件：%3.6f损失：%3.6f%”（历元+1，历元，时间.时间（）-历元开始时间，列车附件/列车附件/列车附件集。uu列/列车附件集。u列/列车附件集。u列/列车附件集。u列/列车附件集。u列/附件集。u列/附件集。u列/附件集。u列/附件集。u列/附件集。u）
x_列x_val=np.连接（（x_列，x_val），轴=0）
y_列值=np。连接（（y_列，y_值），轴=0）
列值集=ImgDataset（x列值，x列值，列变换）
列值加载器=数据加载器（列值集，批量大小=批量大小，随机播放=真）
model_final=分类器（）.cuda（）
损失_fn=nn.交叉熵（）
optim=t.optim.Adam（model_final.parameters（），lr=0.001）
纪元=30
对于范围内的历元（历元）：
epoch\u start\u time=time.time（）
列车acc=0.0
列车损耗=0.0
模型_最终列车（）
对于i，枚举中的数据（列值装载机）：
优化零度梯度（）
列车pred=模型最终（数据[0].cuda（））
批次损失=损失（序列pred，数据[1].cuda（））
批次损失向后（）
optim.step（）
列车acc+=np.sum（np.argmax（列车cpu（）.data.numpy（），轴=1）==data[1].numpy（））
列车损失+=批次损失。项目（）
打印（“[%03d/%03d]%2.2f秒列车附件：%3.6f损耗：%3.6f%”（历元+1，历元，时间.time（）-历元开始时间，列车附件/列车价值集。uuuuuuuuuuuuuuuuuuuu（），列车损失/列车价值集。uuuuuuuuuuuuuuuuuuuuuuuuu len（））
测试集=ImgDataset（x测试，转换=测试转换）
test\u loader=DataLoader（test\u set，batch\u size=batch\u size，shuffle=False）
模型_最终评估（）
预测=[]
带t.no_grad（）：
为了我，爸爸