python实现图像分类,python图像识别技术

　　本文主要介绍Python如何教你如何对图像进行分类。今天的文章主要讲的是如何建立图像识别模型。本文通过示例代码向您详细介绍，对您的学习或工作有一定的参考价值。有需要的朋友可以参考一下。

　　日常生活中，总会有对图像进行分类的场景，比如垃圾分类，不同场景的图像分类。今天的文章主要是关于基于图像识别场景的建模。图像识别是通过Python深度学习训练模型，然后利用模型自动审核上传的电子表格，对比后反馈相应的结果。Python Torchvision主要用于构建模型。Torchvision服务于Pytorch深度学习框架，主要用于生成图片、视频数据集和训练模型。

模型构建

　　要直观的建立模型，需要使用Jupyter notebook来建立模型。

导入所需包

　　图像识别需要深度学习相关模块，所以需要导入相应的包。具体导入的包如下：

　　%reload_ext自动重装

　　%自动重新装入2

　　进口火炬

　　从torch.utils.data导入数据加载器

　　从torchvision.datasets导入图像文件夹

　　从torchvision导入转换为tfs

　　从torchvision导入模型

　　从火炬进口nn

　　将matplotlib.pyplot作为plt导入

　　%matplotlib内联

　　导入操作系统

　　OS . environ[ KMP _重复_LIB_OK]=TRUE

是否使用 GPU

　　模型的主要训练方式是基于GPU或者CPU的训练。没有GPU，训练模型需要一定的时间。训练持续时间取决于训练集的数据和硬件性能，训练结果的准确性取决于数据的数量和准确性。而且深度学习需要大量的材料才能判断出准确的结果，所以需要声明CPU是用来训练的：

　　#你用GPU吗？

　　use_gpu=False

数据增强

　　对采集到的数据在训练集中进行预处理并设置训练层数，然后将采集到的图片水平翻转后进行切割，切割后随机翻转，增强图片的随机对比度和颜色变化。

　　#数据增强

　　train_transform=tfs。撰写([

　　#训练集的数据预处理

　　tfs。调整大小([224，224])，

　　tfs。RandomHorizontalFlip()，

　　tfs。随机作物(128)，

　　tfs。ToTensor()，

　　tfs。规格化([0.5，0.5，0.5]，[0.5，0.5，0.5])

　　])

　　test_transform=tfs。撰写([

　　tfs。调整大小([224，224])，

　　# tfs。随机作物(128)，

　　tfs。ToTensor()，

　　tfs。规格化([0.5，0.5，0.5]，[0.5，0.5，0.5])

　　])

　　#每批数据集的数量

　　批处理大小=10

数据集和验证集准备

　　模型训练需要准备数据集和验证集，只有足够多的照片才能给出比较准确的答案。训练集和验证集的一些代码如下：

　　#建立训练集和验证集

　　#

　　train_set=ImageFolder(。/dataset1/train ，train_transform)

　　train _ data=data loader(train _ set，batch_size，shuffle=True，num_workers=0)

　　valid_set=ImageFolder(。/dataset1/valid ，test_transform)

　　valid _ data=data loader(valid _ set，2*batch_size，shuffle=False，num_workers=0)

　　train_set.class_to_idx

　　len(有效数据)

　　#数据集准备

　　尝试：

　　if iter(train_data)。下一个()[0]。形状[0]==batch_size和\

　　iter(valid_data)。下一个()[0]。shape[0]==2*batch_size:

　　打印(“数据集准备好了！”)

　　else:

　　打印(不成功

　　s, maybe the batch size is wrong)

　　except:

　　 print(not success, image transform is wrong!)

模型构建并准备模型

# 构建模型
　　def get_model():
　　 model = models.resnet50(pretrained=True)
　　 model.fc = nn.Linear(2048, 3)
　　 return model
　　try:
　　 model = get_model()
　　 with torch.no_grad():
　　 scorce = model(iter(train_data).next()[0])
　　 print(scorce.shape[0], scorce.shape[1])
　　 if scorce.shape[0] == batch_size and scorce.shape[1] == 3:
　　 print(Model is ready!)
　　 else:
　　 print(Model is failed!)
　　except:
　　 print(model is wrong)
　　if use_gpu:
　　 model = model.cuda()

构建模型优化器

# 构建loss函数和优化器
　　criterion = nn.CrossEntropyLoss()
　　optimizer = torch.optim.Adam(model.parameters(), lr = 1e-4)
　　# 训练的epoches数目
　　max_epoch = 20

模型训练和训练结果可视化

　　数据集和训练集准备好后进行模型训练和训练结果可视化，部分代码如下：

def train(model, train_data, valid_data, max_epoch, criterion, optimizer):
　　 freq_print = int(len(train_data) / 3)
　　 metric_log = dict()
　　 metric_log[train_loss] = list()
　　 metric_log[train_acc] = list()
　　 if valid_data is not None:
　　 metric_log[valid_loss] = list()
　　 metric_log[valid_acc] = list()
　　 for e in range(max_epoch):
　　 model.train()
　　 running_loss = 0
　　 running_acc = 0
　　 for i, data in enumerate(train_data, 1):
　　 img, label = data
　　 if use_gpu:
　　 img = img.cuda()
　　 label = label.cuda()
　　 # forward前向传播
　　 out = model(img)
　　 # 计算误差
　　 loss = criterion(out, label.long())
　　 # 反向传播，更新参数
　　 optimizer.zero_grad()
　　 loss.backward()
　　 optimizer.step()
　　 # 计算准确率
　　 _, pred = out.max(1)
　　 num_correct = (pred == label.long()).sum().item()
　　 acc = num_correct/img.shape[0]
　　 running_loss += loss.item()
　　 running_acc +=acc
　　 if i % freq_print == 0:
　　 print([{}]/[{}], train loss: {:.3f}, train acc: {:.3f} \
　　 .format(i, len(train_data), running_loss / i, running_acc / i))
　　 metric_log[train_loss].append(running_loss / len(train_data))
　　 metric_log[train_acc].append(running_acc / len(train_data))
　　 if valid_data is not None:
　　 model.eval()
　　 running_loss = 0
　　 running_acc = 0
　　 for data in valid_data:
　　 img, label = data
　　 if use_gpu:
　　 img = img.cuda()
　　 label = label.cuda()
　　 # forward前向传播
　　 out = model(img)
　　 # 计算误差
　　 loss = criterion(out, label.long())
　　 # 计算准确度
　　 _, pred = out.max(1)
　　 num_correct = (pred==label.long()).sum().item()
　　 acc = num_correct/img.shape[0]
　　 running_loss += loss.item()
　　 running_acc += acc
　　 metric_log[valid_loss].append(running_loss/len(valid_data))
　　 metric_log[valid_acc].append(running_acc/len(valid_data))
　　 print_str = epoch: {}, train loss: {:.3f}, train acc: {:.3f}, \
　　 valid loss: {:.3f}, valid accuracy: {:.3f}.format(
　　 e+1, metric_log[train_loss][-1], metric_log[train_acc][-1],
　　 metric_log[valid_loss][-1], metric_log[valid_acc][-1])
　　 else:
　　 print_str = epoch: {}, train loss: {:.3f}, train acc: {:.3f}.format(
　　 e+1,
　　 metric_log[train_loss][-1],
　　 metric_log[train_acc][-1])
　　 print(print_str)
　　 # 可视化
　　 nrows = 1
　　 ncols = 2
　　 figsize= (10, 5)
　　 _, figs = plt.subplots(nrows, ncols, figsize=figsize)
　　 if valid_data is not None:
　　 figs[0].plot(metric_log[train_loss], label=train loss)
　　 figs[0].plot(metric_log[valid_loss], label=valid loss)
　　 figs[0].axes.set_xlabel(loss)
　　 figs[0].legend(loc=best)
　　 figs[1].plot(metric_log[train_acc], label=train acc)
　　 figs[1].plot(metric_log[valid_acc], label=valid acc)
　　 figs[1].axes.set_xlabel(acc)
　　 figs[1].legend(loc=best)
　　 else:
　　 figs[0].plot(metric_log[train_loss], label=train loss)
　　 figs[0].axes.set_xlabel(loss)
　　 figs[0].legend(loc=best)
　　 figs[1].plot(metric_log[train_acc], label=train acc)
　　 figs[1].axes.set_xlabel(acc)
　　 figs[1].legend(loc=best)

调参进行模型训练

# 用作调参
　　train(model, train_data, valid_data, max_epoch, criterion, optimizer)

保存模型

# 保存模型
　　torch.save(model.state_dict(), ./model/save_model2.pth)

总结

　　今天的文章主要是讲图像识别模型如何构建。希望对大家有所帮助。

　　到此这篇关于Python 教你如何给图像分类的文章就介绍到这了,更多相关Python 图像分类内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。