分类学习（加入半监督学习）
#随机种子固定，随机结果也固定
def seed_everything(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
#################################################################
seed_everything(0)
###############################################
#seed_everything(0)这一行调用了上述函数并传入了种子值0，
# 这意味着所有的随机操作都将基于这个种子值来进行初始化，从而确保了实验的可重复性。
固定随机种子：
首先，通过seed_everything(seed)函数设置所有随机数生成器的种子，确保实验结果的可重复性。这对于调试和复现实验结果非常重要。
---------------------------------------------------------------------------------------------------------------------------------
train_transform = transforms.Compose( #进行模型变换
[
transforms.ToPILImage(), #就是把224，224，3模型 -> 3,224,22
transforms.RandomResizedCrop(224), #对图片放大裁剪,裁切出来224*224
transforms.RandomRotation(50), #在50度以内进行旋转
transforms.ToTensor()#变为张量
]
)
val_transform = transforms.Compose( #进行模型变换
[
transforms.ToPILImage(), #就是把224，224，3模型 -> 3,224,22 验证集的话就不用进行transforms模型变换
# transforms.RandomResizedCrop(224), #对图片放大裁剪,裁切出来224*224
# transforms.RandomRotation(50), #在50度以内进行旋转
transforms.ToTensor()#变为张量
]
)
图像变换：
定义了两种不同的图像变换方法train_transform和val_transform。训练集使用了包括随机裁剪、旋转等在内的数据增强技术，以增加模型的泛化能力；而验证集只进行了基本的转换操作，如调整大小和转为张量。
---------------------------------------------------------------------------------------------------------------------------------
class food_Dataset(Dataset):
def __init__(self,path,mode="train"):
self.mode=mode
if mode == "semi":
self.X=self.read_file(path)
else:
self.X,self.Y=self.read_file(path) #给一个路径，读出来X,Y
self.Y = torch.LongTensor(self.Y) #将标签转化成长整型
if mode=="train":
self.transform = train_transform
else:
self.transform = val_transform
def read_file(self,path):
#读semi文件（没有标签的）
if self.mode=="semi":
file_list = os.listdir(path) # 列出文件下所有文件名字
xi = np.zeros((len(file_list), HW, HW, 3), dtype=np.uint8)
for j, img_name in enumerate(file_list): # enumerate既可以读到下表，也可以读到下表里的东西
img_path = os.path.join(path, img_name)
img = Image.open(img_path) # 可以把图片读进来
img = img.resize((HW, HW))
xi[j, ...] = img
print("读到了%d个训练数据" % len(xi))
return xi
else:
for i in tqdm(range(11)):
file_dir = path + "/%02d" % i
file_list = os.listdir(file_dir) # 列出文件下所有文件名字
xi = np.zeros((len(file_list), HW, HW, 3), dtype=np.uint8)
yi = np.zeros(len(file_list), dtype=np.uint8)
for j, img_name in enumerate(file_list): # enumerate既可以读到下表，也可以读到下表里的东西
img_path = os.path.join(file_dir, img_name)
img = Image.open(img_path) # 可以把图片读进来
img = img.resize((HW, HW))
xi[j, ...] = img
yi[j] = i
if i == 0:
X = xi
Y = yi
else:
X = np.concatenate((X, xi), axis=0)
Y = np.concatenate((Y, yi), axis=0)
print("读到了%d个训练数据" % len(Y))
return X, Y
def __getitem__(self, item): #这个函数的作用就是retuen X[item],Y[item]的值
if self.mode=="semi":
return self.transform(self.X[item]),self.X[item]#返回transform后的X和原始的X
else:
return self.transform(self.X[item]),self.Y[item] #加上transform是为了对图片进行函数增广
def __len__(self):
return len(self.X)
自定义数据集类：
food_Dataset: 自定义的数据集类，用于从指定路径读取图片及其标签（或无标签），并应用相应的变换。它支持三种模式：训练（train）、验证（val）和半监督学习（semi）。该类实现了__getitem__和__len__方法，使得它可以被PyTorch的数据加载器（DataLoader）使用。
---------------------------------------------------------------------------------------------------------------------------------
class semiDataset(Dataset):
def __init__(self,no_label_loder,model,device,thres=0.99):
x,y=self.get_label(no_label_loder,model,device,thres)
if x==[]:
self.flag=False
else:
self.flag=True
self.X=np.array(x) #转化成矩阵
self.Y=torch.LongTensor(y)
self.transform=train_transform #定义损失函数
def get_label(self,no_label_loder,model,device,thres):
model=model.to(device)
pred_prob=[]#用一个列表存概率值
labels=[]#用一个列表存对应的标签
x=[]#把无标签的x存进去
y=[]#把半监督学习后x对应的y存进去
soft =nn.Softmax
with torch.no_grad(): #半监督学习，对模型梯度不产生作用，因此加上with torch.no_grad()
for bat_x, _ in no_label_loder: #no_label_loder返回两个值，不需要后面的，所以用_表示
bat_x=bat_x.to(device)
pred=model(bat_x)#预测值
pred_soft=soft(pred)#转化为了概率
pred_max,pred_value=pred_soft.max(1)#既可以返回最大概率值，又可以返回最大概率值下标 、1表示横着读
pred_prob.extend(pred_max.cpu().numpy().tolist())#extend可以合并两个列表，append不行 对应概率的数组
labels.extend(pred_value.cpu().numpy().tolist()) #对应的标签的数组
for index,prob in enumerate(pred_prob):
if prob>thres:
x.append(no_label_loder.dataset[index][1])#取到原始数据
y.append(labels[index])
return x,y
def __getitem__(self, item):
return self.transform(self.X[item]),self.Y[item]
def __len__(self):
return len(self.X)
自定义数据集类：
semiDataset: 另一个自定义数据集类，专门用于从未标记的数据中筛选出高置信度的样本及其预测标签，以便将其加入到训练集中。这个过程是通过调用模型对未标记数据进行预测来实现的。
---------------------------------------------------------------------------------------------------------------------------------
def get_semi_loader(no_label_loder,model,device,thres):
semiset=semiDataset(no_label_loder,model,device,thres)
if semiset.flag==False:
return None
else:
semi_loader=DataLoader(semiset,batch_size=16,shuffle=False)
return semi_loader半监督学习数据加载器：
get_semi_loader函数根据给定的无标签数据加载器、模型、设备和阈值来创建一个新的数据加载器，其中包含由模型预测并认为是可靠的样本。这允许模型从未标记的数据中学习，从而在有限的标记数据情况下提高性能。
---------------------------------------------------------------------------------------------------------------------------------
#模型框架
class myModel(nn.Module):
def __init__(self,num_class):
super(myModel, self).__init__()
#3*224*224 -> 512*7*7 -> 拉直 -> 全连接
self.conv1=nn.Conv2d(3,64,3,1,1) # -> 64*224*224 (卷积）
self.bn1=nn.BatchNorm2d(64) #针对具有64个通道的二维数据的批量归一化层，目的是在训练过程中对该层输入数据进行归一化处理，以加快训练速度和提高模型性能。
self.relu1=nn.ReLU() #激活函数
self.pool1=nn.MaxPool2d(2) # 64*112*112 (池化)
self.layer1=nn.Sequential(
nn.Conv2d(64, 128, 3, 1, 1), # -> 128*112*112 (卷积）
nn.BatchNorm2d(128),
nn.ReLU(),
nn.MaxPool2d(2) # 128*56*56
)
self.layer2 = nn.Sequential(
nn.Conv2d(128, 256, 3, 1, 1), # -> 256*56*56 (卷积）
nn.BatchNorm2d(256),
nn.ReLU(),
nn.MaxPool2d(2) # 256*28*28
)
self.layer3 = nn.Sequential(
nn.Conv2d(256, 512, 3, 1, 1), # -> 512*28*28 (卷积）
nn.BatchNorm2d(512),
nn.ReLU(),
nn.MaxPool2d(2) # 512*14*14
)
self.pool2=nn.MaxPool2d(2) #512*7*7
self.fc1=nn.Linear(25088,1000) #拉直
self.relu2=nn.ReLU()
self.fc2=nn.Linear(1000,num_class)#1000->分类的类别
def forward(self,x):
x=self.conv1(x)
x=self.bn1(x)
x=self.relu1(x)
x=self.pool1(x)
x=self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.pool2(x)
x=x.view(x.size()[0],-1) #拉直
x=self.fc1(x)
x=self.relu2(x)
x=self.fc2(x)
return xCNN模型架构：
myModel是一个简单的卷积神经网络（CNN），设计用于分类任务。它包含了多个卷积层、批量归一化层、ReLU激活函数和最大池化层，最后通过全连接层输出分类结果。
---------------------------------------------------------------------------------------------------------------------------------
def train_val(model,train_loader,val_loader,no_label_loader,device,epochs,optimizer,loss,thres,save_path):
model = model.to(device)
semi_loader=None
plt_train_loss = [] #记录所有轮次的loss
plt_val_loss = []
plt_train_acc = []
plt_val_acc = []
max_acc=0.0
for epoch in range(epochs): #冲锋的号角
train_loss = 0.0
val_loss = 0.0
semi_loss = 0.0
train_acc = 0.0
val_acc = 0.0
semi_acc = 0.0
start_time = time.time()
model.train() #模型调为训练模式
for batch_x, batch_y in train_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
train_bat_loss = loss(pred, target)
train_bat_loss.backward()
optimizer.step() #更新模型的作用,更新参数 之后要梯度清零，否则会积累梯度
optimizer.zero_grad()
train_loss += train_bat_loss.cpu().item()
train_acc += np.sum(np.argmax(pred.detach().cpu().numpy(),axis=1)==target.cpu().numpy())
#pred.detach().cpu().numpy()取张量数据，np.argmax()，axis=1 的意思是取一行最大的坐标，
#也就是取概率最大的坐标，与标签相对比，相等就是Ture，反之False
plt_train_loss.append(train_loss / train_loader.__len__())
plt_train_acc.append(train_acc/train_loader.dataset.__len__()) #记录准确率
if semi_loader!=None:
for batch_x, batch_y in semi_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
semi_bat_loss = loss(pred, target)
semi_bat_loss.backward()
optimizer.step() #更新模型的作用,更新参数 之后要梯度清零，否则会积累梯度
optimizer.zero_grad()
semi_loss += train_bat_loss.cpu().item()
semi_acc += np.sum(np.argmax(pred.detach().cpu().numpy(),axis=1)==target.cpu().numpy())
#pred.detach().cpu().numpy()取张量数据，np.argmax()，axis=1 的意思是取一行最大的坐标，
#也就是取概率最大的坐标，与标签相对比，相等就是Ture，反之False
print("半监督数据集的训练准确率为",semi_acc/semi_loader.dataset.__len__())
model.eval()
with torch.no_grad():
for batch_x, batch_y in val_loader:
x, target = batch_x.to(device), batch_y.to(device)
pred = model(x)
val_bat_loss = loss(pred, target)
val_loss += val_bat_loss.cpu().item()
val_acc += np.sum(np.argmax(pred.detach().cpu().numpy(), axis=1) == target.cpu().numpy())
plt_val_loss.append(val_loss/ val_loader.dataset.__len__())
plt_val_acc.append(val_acc / val_loader.dataset.__len__()) # 记录准确率
if plt_val_acc[-1]>0.7:
semiloader=get_semi_loader(no_label_loader,model,device,thres) #如果正确率达到0.7，就可以训练
if val_acc > max_acc:
torch.save(model, save_path)
max_acc = val_loss
print('[%03d/%03d] %2.2f sec(s) Trainloss: %.6f |Valloss: %.6f Trainacc: %.6f | Valacc: %.6f'% \
(epoch, epochs, time.time() - start_time, plt_train_loss[-1], plt_val_loss[-1],plt_train_acc[-1],plt_val_acc[-1])
)
plt.plot(plt_train_loss)
plt.plot(plt_val_loss)
plt.title("loss")
plt.legend(["train", "val"])
plt.show()
plt.plot(plt_val_acc)
plt.plot(plt_val_acc)
plt.title("acc")
plt.legend(["train", "val"])
plt.show()
训练与验证流程 (train_val 函数)
-
初始化：将模型移动到GPU（如果可用），准备记录损失和准确率的列表。
-
循环遍历epochs：对于每个epoch：
- 执行训练阶段：计算训练损失和准确率。
- 如果存在半监督数据，则对其进行处理。
- 执行验证阶段：计算验证损失和准确率，检查是否需要保存最佳模型。
- 根据验证准确率达到阈值，更新半监督数据加载器。
- 输出当前epoch的信息，包括时间消耗、损失和准确率。
-
绘图：使用matplotlib绘制训练和验证的损失与准确率变化曲线，帮助直观了解模型的学习过程。
---------------------------------------------------------------------------------------------------------------------------------
train_path=r"D:\python_data\classify\food_classification\food-11_sample\training\labeled"
val_path=r"D:\python_data\classify\food_classification\food-11_sample\validation"
no_label_path=r"D:\python_data\classify\food_classification\food-11_sample\training\unlabeled\00"
train_set = food_Dataset(train_path,"train")
val_set = food_Dataset(val_path,"val")
no_label_set = food_Dataset(no_label_path ,"semi")
train_loader = DataLoader(train_set,batch_size=16,shuffle=True) #数据加载器
val_loader = DataLoader(val_set,batch_size=16,shuffle=True)
no_label_loader = DataLoader(no_label_set,batch_size=16,shuffle=False)#False是因为没有标签的照片不能打乱
#batch_size=4：此参数指定了每个批次（batch）中包含的数据样本数量
#为4。这意味着每次迭代过程中，DataLoader都会从train_set中取出4
#个样本组成一个批次返回给用户。选择合适的batch_size对模型训练的
#速度和性能都有影响。
#shuffle=True：在每个epoch开始前，如果设置为True，则DataLoader会将数据集中的数据顺序打乱。
# model = myModel(11)
from torchvision.models import resnet18
model=resnet18(pretrained=True) #pretrained=True 就是不仅用大佬的架构，还用大佬的参数 False 只用架构，不用参数
in_fetures=model.fc.in_features #提取模型分类的输出头
model.fc= nn.Linear(in_fetures,11)
lr=0.001 #学习率
loss = nn.CrossEntropyLoss() #直接调用交叉熵损失
optimizer = torch.optim.AdamW(model.parameters(),lr=lr,weight_decay=1e-4) #优化器AdamW
#model.parameters(): 这个方法会返回一个生成器，包含了模型中所有可学习参数（即网络层的权重和偏置等）
# 。通过传递这个生成器给优化器，告诉优化器需要更新哪些参数。
#weight_decay=1e-4: 权重衰减系数，用于指定L2正则化的强度。L2正则化是一种防止过拟合的技术，通过对损
# 失函数添加一个与权重大小成比例的惩罚项来实现。1e-4意味着对于每个权重w，都会在损失函数中加上权重衰减有
# 助于控制模型复杂度，避免模型过度拟合训练数据。
device="cuda" if torch.cuda.is_available() else "cpu" #如果满足就是cude 否则就是CPU
save_path = "model_save/best_model.pth" #保存最好的模型
epochs=4
thres =0.1
train_val(model,train_loader,val_loader,no_label_loader,device,epochs,optimizer,loss,thres,save_path)