devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

通过Django实现图像识别_基于django图像识别技术

作者：IT小白 | 2024-07-25 15:43:29

赞

踩

基于django图像识别技术

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

该项目需要用到的标准库有： 

opencv

numpy

pickle

os

tensorflow

torch

torchvision

PIL

一、训练模型

训练图片需要自行去准备，数据集可以用cifar-10或者cifar-100，不过需要先解压数据集再进行训练，如何解压数据集呢？看如下代码：

  1. import cv2
  2. import numpy as np
  3. import pickle
  4. import os
  5.  
  6.  
  7. # 解压缩，返回解压后的字典
  8. def unpickle(file):
  9. 	fo = open(file, 'rb')
  10. 	dict = pickle.load(fo, encoding='latin1')
  11. 	fo.close()
  12. 	return dict
  13.  
  14. # path=os.getcwd()
  15. # print(path)
  16. def cifar10_to_images():
  17.     tar_dir = '..//datasets//cifar-10-batches-py//'  # 原始数据库目录
  18.     train_root_dir = '..//cirfar10//train//'  # 图片保存目录
  19.     test_root_dir = '..//cirfar10//test//'
  20.     if not os.path.exists(train_root_dir):
  21.         os.makedirs(train_root_dir)
  22.     if not os.path.exists(test_root_dir):
  23.         os.makedirs(test_root_dir)
  24.     # 生成训练集图片，如果需要png格式，只需要改图片后缀名即可。
  25.     label_names = ["airplane", "automobile", "bird", "cat", "dear", "dog", "frog", "horse", "ship", "truck"]
  26.     for j in range(1, 6):
  27.         dataName = tar_dir + "data_batch_" + str(j)
  28.         Xtr = unpickle(dataName)
  29.         print(dataName + " is loading...")
  30.  
  31.         for i in range(0, 10000):
  32.             img = np.reshape(Xtr['data'][i], (3, 32, 32))  # Xtr['data']为图片二进制数据
  33.             img = img.transpose(1, 2, 0)  # 读取image
  34.             picName = train_root_dir + str(Xtr['labels'][i]) + '_' + label_names[Xtr['labels'][i]] + '_' + str(
  35.                 i + (j - 1) * 10000) + '.jpg'  # label+class+index
  36.             cv2.imwrite(picName, img)
  37.         print(dataName + " loaded.")
  38.  
  39.     print("test_batch is loading...")
  40.  
  41.     # 生成测试集图片
  42.     testXtr = unpickle(tar_dir + "test_batch")
  43.     for i in range(0, 10000):
  44.         img = np.reshape(testXtr['data'][i], (3, 32, 32))
  45.         img = img.transpose(1, 2, 0)
  46.         picName = test_root_dir + str(testXtr['labels'][i]) + '_' + label_names[testXtr['labels'][i]] + '_' + str(
  47.             i) + '.jpg'
  48.         cv2.imwrite(picName, img)
  49.     print("test_batch loaded.")

解压数据集之后就可以开始训练模型了，我使用的是gpu来训练，如果要进行训练的话，需要下载tensorflow+cudnn+cuda，如何下载这些本文章不详细介绍

核心代码：

alex_net.py

  1. import tensorflow as tf
  2. def AlexNet(num_classes):
  3. 	return tf.keras.models.Sequential([
  4. 	    # 这里，我们使用一个 11*11 的更大窗口来捕捉对象。
  5. 	    # 同时，步幅为 4，以减少输出的高度和宽度。
  6. 	    # 另外，输出通道的数目远大于 LeNet
  7. 	    tf.keras.layers.Conv2D(filters=96, kernel_size=11, strides=4,input_shape=(224,224,3), activation='relu'),
  8. 	    tf.keras.layers.MaxPool2D(pool_size=3, strides=2),
  9. 	    # 减小卷积窗口，使用填充为 2 来使得输入与输出的高和宽一致，且增大输出通道数
  10. 	    tf.keras.layers.Conv2D(filters=256, kernel_size=5, padding='same', activation='relu'),
  11. 	    tf.keras.layers.MaxPool2D(pool_size=3, strides=2),
  12. 		 # 使用三个连续的卷积层和较小的卷积窗口。
  13. 		 # 除了最后的卷积层，输出通道的数量进一步增加。
  14. 		 # 在前两个卷积层之后，汇聚层不用于减少输入的高度和宽度
  15. 		 tf.keras.layers.Conv2D(filters=384, kernel_size=3, padding='same', activation='relu'),
  16. 		 tf.keras.layers.Conv2D(filters=384, kernel_size=3, padding='same', activation='relu'),
  17. 		 tf.keras.layers.Conv2D(filters=256, kernel_size=3, padding='same', activation='relu'),
  18. 		 tf.keras.layers.MaxPool2D(pool_size=3, strides=2),
  19. 		 tf.keras.layers.Flatten(),
  20. 		 # 这里，全连接层的输出数量是 LeNet 中的好几倍。使用 dropout 层来减轻过拟合
  21. 		 tf.keras.layers.Dense(4096, activation='relu'),
  22. 		 tf.keras.layers.Dropout(0.5),
  23. 		 tf.keras.layers.Dense(4096, activation='relu'),
  24. 		 tf.keras.layers.Dropout(0.5),
  25. 		 # 最后是输出层。由于这里使用 Fashion-MNIST，所以用类别数为 10，而非论文中的 1000
  26. 		 tf.keras.layers.Dense(num_classes, activation='softmax')
  27. 	])

alex_net_train_animals.py

  1. from keras.preprocessing.image import ImageDataGenerator
  2. train_datagen = ImageDataGenerator( rescale=1./255, rotation_range=40, width_shift_range=0.2,
  3.                                     height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True,)
  4. #train_datagen = ImageDataGenerator(rescale=1./255)
  5. validation_datagen = ImageDataGenerator(rescale=1./255)#注意，不能增强验证数据
  6. test_datagen = ImageDataGenerator(rescale=1./255)#注意，不能增强测试数据
  7. # train_generator = train_datagen.flow_from_directory(r'..\datasets\cats_and_dogs_and_horse_small\train', #目标目录
  8. train_generator = train_datagen.flow_from_directory(r'E:\animals\train', #目标目录
  9.                                                     target_size=(224, 224), #将所有图像的大小调整为 224×224
  10.                                                     # batch_size=20,
  11.                                                     batch_size=100,
  12.                                                     class_mode='categorical') #因为使用了 binary_crossentropy 损失，所以需要用二进制标签
  13. validation_generator = validation_datagen.flow_from_directory(
  14.     # r'..\datasets\cats_and_dogs_and_horse_small\validation',
  15.     r'E:\animals\validation',
  16.     target_size=(224, 224),
  17.     # batch_size=20,
  18.     batch_size=100,
  19.     class_mode='categorical')
  20. test_generator = test_datagen.flow_from_directory(
  21.     # r'..\datasets\cats_and_dogs_and_horse_small\test',
  22.     r'E:\animals\test',
  23.     target_size=(224, 224),
  24.     # batch_size=20,
  25.     batch_size=100,
  26.     class_mode='categorical')
  27. for data_batch, labels_batch in train_generator:
  28.     print('批处理数据形状:', data_batch.shape)
  29.     print('批处理标签形状:', labels_batch.shape)
  30.     break
  31. import tensorflow as tf
  32. from keras.callbacks import ModelCheckpoint
  33. filepath = 'model1.h5'
  34. # 有一次提升, 则覆盖一次.
  35. checkpoint = ModelCheckpoint(filepath, monitor='val_acc', verbose=1,
  36. save_best_only=True, mode='max', period=1)
  37. callbacks_list = [checkpoint]
  38. from alex_net import AlexNet
  39. model = AlexNet(100)
  40. # model = AlexNet(3)
  41. model.compile(loss='categorical_crossentropy',
  42.          optimizer= tf.keras.optimizers.Adam(lr = 0.0001),
  43.          metrics=['acc'])
  44. history = model.fit(
  45.      train_generator,
  46.      steps_per_epoch=500,
  47.      # steps_per_epoch=300,
  48.      epochs=100,
  49.      validation_data=validation_generator,
  50.      # validation_steps=150,
  51.      validation_steps=100,
  52.      callbacks=callbacks_list)
  53. #加载模型权重
  54. model.load_weights(filepath)
  55. scores = model.evaluate(test_generator)
  56. print("{0}: {1:.2f}%".format(model.metrics_names[1], scores[1] * 100))
  57. acc = history.history['acc']
  58. val_acc = history.history['val_acc']
  59. loss = history.history['loss']
  60. val_loss = history.history['val_loss']
  61. from com.util import plotting
  62. plotting(acc,loss,val_acc,val_loss,mark_every=2)
  63. # #生成器输出,每个批量包含 20 个样本，一个样本生成了 224x224 的 RGB 图像
  64. #本例中，每个批次包含 20 个样本，所以读取完所有 6000 个训练样本需要 300 个批次，3000 个验证和测试样本分别需要 150 个批次

二、使用模型并预测

核心代码：

lenet模型算法

  1. '''1.构建神经网络'''
  2. class LeNet(nn.Module):
  3.     def __init__(self):
  4.         super(LeNet,self).__init__()
  5.         # 卷积层1：输入图像深度=3，输出图像深度=16，卷积核大小=5*5，卷积步长=1;16表示输出维度，也表示卷积核个数
  6.         self.conv1 = nn.Conv2d(in_channels=3,out_channels=16,kernel_size=5,stride=1)
  7.         # 池化层1：采用最大池化，区域集大小=2*2.池化步长=2
  8.         self.pool1 = nn.MaxPool2d(kernel_size=2,stride=2)
  9.         # 卷积层2
  10.         self.conv2 = nn.Conv2d(in_channels=16,out_channels=32,kernel_size=5,stride=1)
  11.         # 池化层2
  12.         self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
  13.         # 全连接层1：输入大小=32*5*5，输出大小=120
  14.         self.fc1 = nn.Linear(32*5*5,120)
  15.         # 全连接层2
  16.         self.fc2 = nn.Linear(120,84)
  17.         # 全连接层3
  18.         self.fc3 = nn.Linear(84,10)
  19.  
  20.     def forward(self,x):
  21.         x = F.relu(self.conv1(x))  # input(3, 32, 32) output(16, 28, 28)
  22.         x = self.pool1(x)  # output(16, 14, 14)
  23.         x = F.relu(self.conv2(x))  # output(32, 10, 10)
  24.         x = self.pool2(x)  # output(32, 5, 5)
  25.         x = x.view(-1, 32 * 5 * 5)  # output(32*5*5)
  26.         x = F.relu(self.fc1(x))  # output(120)
  27.         x = F.relu(self.fc2(x))  # output(84)
  28.         x = self.fc3(x)  # output(10)
  29.         return x
  1. import torch
  2. import torchvision.transforms as transforms
  3. from PIL import Image
  4. from zzz.main import LeNet
  5.  
  6. transform = transforms.Compose([transforms.Resize((32, 32)),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
  7.  
  8. classes = ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')
  9.  
  10. net = LeNet()
  11. net.load_state_dict(torch.load('Lenet.pth'))
  12.  
  13. im = Image.open('D:/ship.jpg')
  14. im = transform(im)  # [C, H, W]
  15. # 输入pytorch网络中要求的格式是[batch，channel，height，width]，所以这里增加一个维度
  16. im = torch.unsqueeze(im, dim=0)  # [N, C, H, W]
  17.  
  18. with torch.no_grad():
  19.     outputs = net(im)
  20.     predict = torch.max(outputs, dim=1)[1].data.numpy() # 索引即classed中的类别
  21. print(classes[int(predict)])
  22.  
  23. # 直接打印张量的预测结果
  24. with torch.no_grad():
  25.     outputs = net(im)
  26.     predict = torch.softmax(outputs,dim=1) # [batch，channel，height，width],这里因为对batch不需要处理
  27. print(predict)

三、通过django实现图像识别

前端部分

1.首先导入bootstrap前端框架，bootstrap可以从官网上下载

2.需要导入Django的静态资源引用标签{% load static %}，然后在所有的引用路径前需要添加static标记，即采用类似href="{% static 'css/bootstrap.css' %}"这种引用方式。通过这种方式就可以正确地引用静态配置文件

  1. {% load static %}
  2. <html lang="zh-cn">
  3.  
  4. <head>
  5.     <meta charset="utf-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1">
  8.     <title>图像识别{% block title %}{% endblock %} </title>
  9.     <link href="{% static 'css/bootstrap.css' %}" rel="stylesheet">
  10.     <link href="{% static 'css/style.css' %}" rel="stylesheet">
  11.     <script src="{% static 'js/jquery.min.js' %}"></script>
  12.     <script src="{% static 'js/bootstrap.min.js' %}"></script>
  13. </head>
  14. <body>
  15. <!-- 主体内容 -->
  16.     <div class="model-details">
  17.         <img class="img-responsive" style="max-width:700px;" src="{% static 'img/dog.jpg' %}">
  18.         <!-- 按钮触发模态框 -->
  19.         <h3>使用产品</h3>
  20.         <button class="btn btn-primary btn-lg" data-toggle="modal" data-target="#myModal">
  21.             在线图像识别
  22.         </button>
  23.         <!-- 模态框（Modal） -->
  24.         <div class="modal fade" id="myModal" tabindex="-1" role="dialog" aria-labelledby="myModalLabel"
  25.             aria-hidden="true">
  26.             <div class="modal-dialog">
  27.                 <div class="modal-content">
  28.                     <div class="modal-header">
  29.                         <button type="button" class="close" data-dismiss="modal" aria-hidden="true">
  30.                             &times;
  31.                         </button>
  32.                         <h4 class="modal-title" id="myModalLabel">
  33.                             在线图像识别
  34.                         </h4>
  35.                     </div>
  36.                     <div class="modal-body">
  37.                         <img id="photoIn" src="{% static 'img/sample.jpg' %}" class="img-responsive"
  38.                             style="max-width:250px">
  39.                         <h4>请上传图片</h4>
  40.                         <input type="file" id="photo" name="photo" />
  41.                     </div>
  42.                     <div class="modal-footer">
  43.                         <button type="button" class="btn btn-default" data-dismiss="modal">关闭
  44.                         </button>
  45.                         <button type="button" id="compute" class="btn btn-primary">
  46.                             开始检测
  47.                         </button>
  48.                         <textarea id="output" disabled class="form-control" rows="5"
  49.                             style="text-align: left;font: 40px 宋体;border: 0">
  50.                         </textarea>
  51.                     </div>
  52.                 </div><!-- /.modal-content -->
  53.             </div><!-- /.modal -->
  54.         </div>
  55.         <script>
  56.             $(function () {
  57.                 $('#photo').on('change', function () {
  58.                     var r = new FileReader();
  59.                     f = document.getElementById('photo').files[0];
  60.                     r.readAsDataURL(f);
  61.                     r.onload = function (e) {
  62.                         document.getElementById('photoIn').src = this.result;
  63.                     };
  64.                 });
  65.             });
  66.         </script>   
  67.     </div>
  68. </div>
  69. <!-- 图像发送至后台服务器进行识别 -->
  70. <script>
  71.     $('#compute').click(function () {
  72.         formdata = new FormData();
  73.         var file = $("#photo")[0].files[0];
  74.         formdata.append("image", file);
  75.         $.ajax({
  76.             url: '/productapp/imgdetect/', // 调用Django服务器计算函数
  77.             type: 'POST', // 请求类型
  78.             data: formdata,
  79.             dataType: 'json', // 期望获得的响应类型为json
  80.             processData: false,
  81.             contentType: false,
  82.             success: ShowResult // 在请求成功之后调用该回调函数输出结果
  83.         })
  84.     })
  85. </script>
  86.  
  87. <!-- 返回结果显示 -->
  88. <script>
  89.     function ShowResult(data) {
  90.         output.value = data['output'];
  91.     }
  92. </script>
  93. <script>
  94.     document.getElementById("output").style.width="150px";
  95.     document.getElementById("output").style.height="70px";
  96. </script>
  97. <body/>
  98. {% endblock %}

后端部分

  1. from django.shortcuts import render
  2.  
  3.  
  4. # Create your views here.
  5.  
  6.  
  7. def system(request):
  8. 	return render(request, 'imgsystem.html')
  9.  
  10.  
  11. import numpy as np  # 矩阵运算
  12. import urllib  # url解析
  13. import json  # json字符串使用
  14. import cv2  # opencv包
  15. import os  # 执行操作系统命令
  16. from django.views.decorators.csrf import csrf_exempt  # 跨站点验证
  17. from django.http import JsonResponse  # json字符串响应
  18. from PIL import Image
  19. import keras.models
  20. import numpy as np
  21. import tensorflow as tf
  22. from keras.preprocessing import image
  23. from django.urls import path
  24. from django.views.static import serve
  25. from demo1 import settings
  26. from django.conf import settings
  27. from django.http import HttpResponse
  28.  
  29.  
  30. def read_image(stream=None):
  31. 	if stream is not None:
  32. 		data_temp = stream.read()
  33. 	img = np.asarray(bytearray(data_temp), dtype="uint8")
  34. 	img = cv2.imdecode(img, cv2.IMREAD_COLOR)
  35. 	return img
  36.  
  37.  
  38. @csrf_exempt  # 用于规避跨站点请求攻击
  39. def imgdetect(request):
  40. 	result = {"code": None}
  41. 	if request.method == "POST":  # 规定客户端使用POST上传图片
  42. 		filelist = request.FILES.get("image", None)  # 读取图像
  43. 		img = read_image(stream=request.FILES["image"])
  44. 		if not filelist:
  45. 			return HttpResponse('file not found')
  46. 		
  47. 		# 被我保存到本地啦，保存到哪里随意啦
  48. 		save_path = 'E:\\test\\demo1\\product1\\add_img\\%s' % (filelist.name)
  49. 		with open(save_path, 'wb+') as f:
  50. 			for chunk in filelist.chunks():
  51. 				f.write(chunk)
  52. 		model = keras.models.load_model("E:/test/demo1/productapp/model.h5")
  53. 		classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
  54. 		# img=Image.fromarray(cv2.cvtColor(img,cv2.COLOR_BGR2RGB))
  55. 		# img=image.load_img('product1/add_img/cat.1.jpg',target_size=(224,224,))
  56. 		img = image.load_img(save_path, target_size=(224, 224,))
  57. 		img_data = image.img_to_array(img)
  58. 		img_data = np.expand_dims(img_data, axis=0)
  59. 		test_img = img_data / 255  # 此处还需要将0-255转化为0-1
  60. 		# test_img = np.expand_dims(test_img, 0)  # 将三维输入图像拓展成四维张量
  61. 		pred = model.predict(test_img)  # 预测
  62. 		# print('预测结果：', end='')
  63. 		code = classes[pred.argmax()]
  64. 		result.update({"output": code})
  65. 		return JsonResponse(result)

其他需要注意的内容

1.需要在setting文件中添加下列几行代码

2.需要在项目根目录下新建product1文件夹，目录结构如下：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/880974?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号