第八周 tensorflow实现猫狗识别

已于 2023-03-24 10:05:04 修改
阅读量532 收藏 5
点赞数
分类专栏： 365天深度学习 tensorflow系列 文章标签： tensorflow 深度学习 人工智能
于 2023-03-24 09:56:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44753643/article/details/129738617
版权

一、本周学习内容:

1、自己搭建VGG16网络

在这里插入图片描述
vgg16网络代码

def vgg_net(num_layer,filter):
    blk = Sequential()
    for _ in range(num_layer):
        blk.add(Conv2D(filters=filter,kernel_size=3,padding='same',activation='relu'))
    blk.add(MaxPool2D(pool_size=(2,2),strides=2))
    return blk

conv_arch = [(2,64),(2,128),(3,256),(3,512),(3,512)]
model = Sequential()
for num_layer,filter in conv_arch:
    model.add(vgg_net(num_layer,filter))
model.add(Sequential([
    Flatten(),
    Dense(4096,activation='relu'),
    Dropout(0.5),
    Dense(4096,activation='relu'),
    Dropout(0.5),
    Dense(len(class_num),activation='softmax')  # 输出类别数自行更改
]))

x = tf.random.uniform((1,224,224,3))
y = model(x)
print(model.summary())

2、了解model.train_on_batch（）

y_pred = model.train_on_batch(
x,
y=None,
sample_weight=None,
class_weight=None,
reset_metrics=True,
return_dict=False,
)
x：模型输入，单输入就是一个 numpy 数组， 多输入就是 numpy 数组的列表
y：标签，单输出模型就是一个 numpy 数组， 多输出模型就是 numpy 数组列表
sample_weight：mini-batch 中每个样本对应的权重，形状为 (batch_size)
class_weight：类别权重，作用于损失函数，为各个类别的损失添加权重，主要用于类别不平衡的情况， 形状为 (num_classes)
reset_metrics：默认True，返回的metrics只针对这个mini-batch, 如果False，metrics 会跨批次累积
return_dict：默认 False, y_pred 为一个列表，如果 True 则 y_pred 是一个字典
可看这篇文章描述train_on_batch

3、了解tqdm，并使用tqdm实现可视化进度条

tqdm是 Python 进度条库，可以在 Python长循环中添加一个进度提示信息。用户只需要封装任意的迭代器，是一个快速、扩展性强的进度条工具库。
这篇文章介绍tqdm的使用

二、前言

我们的数据图片共有3400张,两个类别,类别即为文件夹名。
类别包括:[‘Dark’, ‘Green’, ‘Light’, ‘Medium’]
在我们使用tensorflow.keras.preprocessing.image_dataset_from_directory()函数读取后会弹出下列提示
Found 3400 files belonging to 2 classes.
Using 680 files for validation.
[‘cat’, ‘dog’]

三、电脑环境

电脑系统：Windows 10
语言环境：Python 3.8.8
编译器：Pycharm 2021.1.3
深度学习环境：TensorFlow 2.8.0,keras 2.8.0
显卡及显存：RTX 3070 8G

四、前期准备

1、导入相关依赖项

from keras.models import Sequential
from keras.layers import *
from tensorflow import keras
from keras.callbacks import ModelCheckpoint
import tensorflow as tf
import matplotlib.pyplot as plt

2、设置GPU(我下载的tensorflow-gpu 默认使用GPU)

只使用GPU

if gpus:
    gpu0 = gpus[0]                                        #如果有多个GPU，仅使用第0个GPU
    tf.config.experimental.set_memory_growth(gpu0, True)  #设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpu0],"GPU")

使用cpu和gpu
os.environ[“CUDA_VISIBLE_DEVICES”] = “-1”

3、加载数据集和展示

(1)、数据集加载

# 数据集加载
traindatadir = "./dataset"
train = keras.preprocessing.image_dataset_from_directory(directory=traindatadir,
                                                           validation_split=0.2,
                                                           subset='training',
                                                           seed=469,
                                                           label_mode='categorical',
                                                           image_size=(224,224),
                                                           batch_size=32)
val = keras.preprocessing.image_dataset_from_directory(directory=traindatadir,
                                                           validation_split=0.2,
                                                           subset='validation',
                                                           seed=469,
                                                           label_mode='categorical',
                                                           image_size=(224,224),
                                                           batch_size=32)


class_names = train.class_names
print(class_names)

(2)、数据展示

图片展示

# 图片展示
plt.figure(figsize=(15, 10))  # 图形的宽为15高为10
for images, labels in train_ds.take(1):
    for i in range(32):
        ax = plt.subplot(5, 8, i + 1)
        plt.imshow(images[i])
        plt.title(class_names[labels[i]])
        plt.axis("off")

plt.show()  #使用pycharm的需要加入这行代码才能将图像显示出来
# train.take(i) 取出第i组图片数据和标签,即将所有图片打包后一个batch为32,

在这里插入图片描述

五、数据预处理

将数据归一化并加载入内存中

AUTOTUNE = tf.data.AUTOTUNE

def preprocess_image(image,label):
    return (image/255.0,label)

# 归一化处理
train_ds = train_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)
val_ds   = val_ds.map(preprocess_image, num_parallel_calls=AUTOTUNE)

train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds   = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

六、搭建CNN网络

# 网络模型
def vgg_net(num_layer,filter):
    blk = Sequential()
    for _ in range(num_layer):
        blk.add(Conv2D(filters=filter,kernel_size=3,padding='same',activation='relu'))
    blk.add(MaxPool2D(pool_size=(2,2),strides=2))
    return blk

conv_arch = [(2,64),(2,128),(3,256),(3,512),(3,512)]
# model = Sequential([Conv2D(filters=64,kernel_size=3,padding='same',activation='relu',input_shape=(224,224,1))])
model = Sequential()
for num_layer,filter in conv_arch:
    model.add(vgg_net(num_layer,filter))
# print(model.summary())
model.add(Sequential([
    Flatten(),
    Dense(4096,activation='relu'),
    Dropout(0.5),
    Dense(4096,activation='relu'),
    Dropout(0.5),
    Dense(len(class_names),activation='softmax')
]))

x = tf.random.uniform((1,224,224,3))
y = model(x)
print('y',y)
print(model.summary())
model.compile(optimizer="adam",
              loss     ='sparse_categorical_crossentropy',
              metrics  =['accuracy'])
from tqdm import tqdm
import tensorflow.keras.backend as K

epochs = 10
lr = 1e-4

# 记录训练数据，方便后面的分析
history_train_loss = []
history_train_accuracy = []
history_val_loss = []
history_val_accuracy = []

for epoch in range(epochs):
    train_total = len(train_ds)
    val_total = len(val_ds)

    """
    total：预期的迭代数目
    ncols：控制进度条宽度
    mininterval：进度更新最小间隔，以秒为单位（默认值：0.1）
    """
    with tqdm(total=train_total, desc=f'Epoch {epoch + 1}/{epochs}', mininterval=1, ncols=100) as pbar:

        lr = lr * 0.92
        K.set_value(model.optimizer.lr, lr)

        for image, label in train_ds:
            """
            训练模型，简单理解train_on_batch就是：它是比model.fit()更高级的一个用法

            想详细了解 train_on_batch 的同学，
            可以看看我的这篇文章：https://www.yuque.com/mingtian-fkmxf/hv4lcq/ztt4gy
            """
            history = model.train_on_batch(image, label)

            train_loss = history[0]
            train_accuracy = history[1]

            pbar.set_postfix({"loss": "%.4f" % train_loss,
                              "accuracy": "%.4f" % train_accuracy,
                              "lr": K.get_value(model.optimizer.lr)})
            pbar.update(1)
        history_train_loss.append(train_loss)
        history_train_accuracy.append(train_accuracy)

    print('开始验证！')

    with tqdm(total=val_total, desc=f'Epoch {epoch + 1}/{epochs}', mininterval=0.3, ncols=100) as pbar:

        for image, label in val_ds:
            history = model.test_on_batch(image, label)

            val_loss = history[0]
            val_accuracy = history[1]

            pbar.set_postfix({"loss": "%.4f" % val_loss,
                              "accuracy": "%.4f" % val_accuracy})
            pbar.update(1)
        history_val_loss.append(val_loss)
        history_val_accuracy.append(val_accuracy)

    print('结束验证！')
    print("验证loss为：%.4f" % val_loss)
    print("验证准确率为：%.4f" % val_accuracy)

Epoch 1/10: 100%|██████████| 85/85 [00:56<00:00,  1.50it/s, loss=0.6747, accuracy=0.5938, lr=9.2e-5]
Epoch 1/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 1/10: 100%|█████████████████████| 22/22 [00:05<00:00,  4.03it/s, loss=0.6325, accuracy=1.0000]
Epoch 2/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.6325
验证准确率为：1.0000
Epoch 2/10: 100%|█████████| 85/85 [00:57<00:00,  1.48it/s, loss=0.5680, accuracy=0.6562, lr=8.46e-5]
Epoch 2/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 2/10: 100%|█████████████████████| 22/22 [00:06<00:00,  3.66it/s, loss=0.4805, accuracy=0.8750]
Epoch 3/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.4805
验证准确率为：0.8750
Epoch 3/10: 100%|█████████| 85/85 [01:07<00:00,  1.26it/s, loss=0.5843, accuracy=0.7188, lr=7.79e-5]
开始验证！
Epoch 3/10: 100%|█████████████████████| 22/22 [00:04<00:00,  5.15it/s, loss=0.5533, accuracy=0.7500]
Epoch 4/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.5533
验证准确率为：0.7500
Epoch 4/10: 100%|█████████| 85/85 [01:06<00:00,  1.28it/s, loss=0.0835, accuracy=0.9688, lr=7.16e-5]
Epoch 4/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 4/10: 100%|█████████████████████| 22/22 [00:05<00:00,  4.24it/s, loss=0.0185, accuracy=1.0000]
Epoch 5/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.0185
验证准确率为：1.0000
Epoch 5/10: 100%|█████████| 85/85 [01:09<00:00,  1.22it/s, loss=0.0667, accuracy=0.9688, lr=6.59e-5]
Epoch 5/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 5/10: 100%|█████████████████████| 22/22 [00:05<00:00,  3.74it/s, loss=0.0099, accuracy=1.0000]
Epoch 6/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.0099
验证准确率为：1.0000
Epoch 6/10: 100%|█████████| 85/85 [01:14<00:00,  1.14it/s, loss=0.0395, accuracy=0.9688, lr=6.06e-5]
Epoch 6/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 6/10: 100%|█████████████████████| 22/22 [00:05<00:00,  3.77it/s, loss=0.0012, accuracy=1.0000]
Epoch 7/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.0012
验证准确率为：1.0000
Epoch 7/10: 100%|█████████| 85/85 [01:14<00:00,  1.14it/s, loss=0.0461, accuracy=1.0000, lr=5.58e-5]
Epoch 7/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 7/10: 100%|█████████████████████| 22/22 [00:05<00:00,  3.80it/s, loss=0.0012, accuracy=1.0000]
结束验证！
验证loss为：0.0012
验证准确率为：1.0000
Epoch 8/10: 100%|█████████| 85/85 [01:16<00:00,  1.10it/s, loss=0.0364, accuracy=1.0000, lr=5.13e-5]
Epoch 8/10:   0%|                                                            | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 8/10: 100%|█████████████████████| 22/22 [00:05<00:00,  3.68it/s, loss=0.0031, accuracy=1.0000]
Epoch 9/10:   0%|                                                            | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.0031
验证准确率为：1.0000
Epoch 9/10: 100%|█████████| 85/85 [01:16<00:00,  1.11it/s, loss=0.0117, accuracy=1.0000, lr=4.72e-5]
开始验证！
Epoch 9/10: 100%|█████████████████████| 22/22 [00:06<00:00,  3.23it/s, loss=0.0005, accuracy=1.0000]
Epoch 10/10:   0%|                                                           | 0/85 [00:00<?, ?it/s]结束验证！
验证loss为：0.0005
验证准确率为：1.0000
Epoch 10/10: 100%|████████| 85/85 [01:16<00:00,  1.12it/s, loss=0.0004, accuracy=1.0000, lr=4.34e-5]
Epoch 10/10:   0%|                                                           | 0/22 [00:00<?, ?it/s]开始验证！
Epoch 10/10: 100%|████████████████████| 22/22 [00:05<00:00,  3.77it/s, loss=0.0008, accuracy=1.0000]
结束验证！
验证loss为：0.0008
验证准确率为：1.0000

七、绘制损失函数图像和准确度图像

绘制代码与前几周相同

# 画准确度图
epochs_range = range(epochs)

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, history_train_accuracy, label='Training Accuracy')
plt.plot(epochs_range, history_val_accuracy, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, history_train_loss, label='Training Loss')
plt.plot(epochs_range, history_val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

以上就是我本周的学习内容
在这里插入图片描述

降花绘
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
TensorFlow入门实战｜第8周：猫狗识别
“365天深度学习训练营”报名进行中～
09-11 774
这篇文章中我放弃了以往的model.fit()训练方法，改用model.train_on_batch方法。此外我也引入了进度条的显示方式，更加方便我们及时查看模型训练过程中的情况，可以及时打印各项指标。🏡。
tensorflow实现猫狗识别
10-10
采用tensorflow实现猫狗的识别。首先是进行模型的撰写，然后训练，最后测试。具体的训练图片在网上下载即可
tensorflow 猫狗识别
06-05
tensorflow 猫狗识别 TensorFlow 卷积神经网络之使用训练好的模型识别猫狗图
【猫狗识别系统】图像识别Python+TensorFlow+卷积神经网络算法+人工智能深度学习
最新发布
子午的博客
06-04 1262
本研究中，我们开发了一个基于深度学习的猫狗识别系统，使用了TensorFlow框架下的MobileNetV2轻量级卷积神经网络模型。MobileNetV2模型以其高效的结构和较低的计算成本而闻名，非常适合在移动和嵌入式设备上使用。通过对数千张标记好的猫狗图片进行训练，最终生成了一个准确率较高的模型文件（H5格式），可以有效地区分猫和狗的图像。此外，为了提高用户体验和系统的实用性，我们使用Django框架搭建了一个简洁的Web应用界面。该界面允许用户上传图片，并即时显示模型的识别结果。
基于tensorflow实现猫狗识别代码(CNN)
08-17
通过TensorFlow搭建卷积神经网络实现猫狗识别代码，训练和测试代码完整，下载之后可以直接运行测试打码，运行环境在Linux下，需要把代码中的路径修改为本机实际路径
TensorFlow2实战-系列教程3：猫狗识别1
机器学习与软件工程
01-26 1842
TensorFlow2实战-系列教程3：猫狗识别1
tensorflow--猫狗识别
weixin_52612318的博客
05-29 1452
作为tensorflow初学的大三学生，本次课程作业的使用猫狗数据集做一个二分类模型。 目录 一，数据集介绍 二，数据导入 三，数据集构建 四，模型搭建 五，模型训练 六，模型测试 一，猫狗数据集数目构成 train cats:1000 ,dogs:1000 test cats: 500,dogs:500 validation cats:500,dogs:500 二，数据导入 train_dir = 'Data/train' test_dir = 'Data/test' valid
猫狗大战——基于TensorFlow的猫狗识别（2）
qq_33828738的博客
05-04 3363
基于tensorflow的猫狗大战第一部分，数据的导入。
基于tensorflow猫狗识别————数据处理（1）
gagaki的博客
05-15 1463
文章目录**一、数据集下载**二、图片裁剪**三、打标签** 一、数据集下载 ggle官网上提供猫狗识别数据集的下载，但是要翻墙，这里提供网盘保存。 链接：https://pan.baidu.com/s/1-0eBeAyE5i4TMiNS8CQcVQ 提取码：31sc 训练数据包含猫和狗各12500张图片，测试数据包含12500张猫和狗的图片。 ** 二、图片裁剪 ** 在用AlexNet神经网络模型训练之前要将图片统一裁剪成227x227大小，用opencv来裁剪。 import cv2 import o
tensorflow识别猫与狗
07-01 2151
问题 现在有很多的图片，里面分别有猫与狗，识别这些图片，区分猫与狗 设计解决这个问题的思路 1、下载与放置训练图片 2、现在对应的依赖，tensorflow、numpy等等 3、解析文件名，识别dog还是cat 4、建模 5、对模型进行训练 6、用测试模型进行验证 7、输出结果 8、优化模型 to step4 [1]图片地址 https://www.kaggle.com/c/dogs-vs-cats/data现在数据，现在速度比较慢，可以使用网盘。 网盘地址(提取码:l.
tensorflow 猫狗识别大战_视频
03-28
利用python tensorflow 猫狗识别大战_视频,讲述识别猫和狗的方法
基于tensorflow实现猫狗识别代码(CNN).zip
12-10
通过TensorFlow搭建卷积神经网络实现猫狗识别代码，训练和测试代码完整，下载之后可以直接运行测试打码，运行环境在Linux下，需要把代码中的路径修改为本机实际路径
基于tensorflow的猫狗图片的识别分类_深度学习CNN网络alexnet模型
04-14
猫狗图片的识别分类，通过一个Alexnet网络模型，对猫狗图片数据集进行训练，并保存模型
Python通过TensorFlow卷积神经网络实现猫狗识别
12-31
这份数据集来源于Kaggle，数据集有12500只猫和12500只狗。在这里简单介绍下整体思路 处理数据 设计神经网络 进行训练测试 1. 数据处理 将图片数据处理为 tf 能够识别的数据格式，并将数据设计批次。 第一步get_files() 方法读取图片，然后根据图片名，添加猫狗 label，然后再将 image和label 放到 数组中，打乱顺序返回 将第一步处理好的图片 和label 数组 转化为 tensorflow 能够识别的格式，然后将图片裁剪和补充进行标准化处理，分批次返回。 新建数据处理文件 ，文件名 input_data.py import tensor
猫狗图像识别（卷积神经网络算法，TensorFlow安装）
Sheenky的博客
06-09 7044
一、tensorflow库安装（1）TensorFlow的历史版本与对应Python版本（2）Python版本查询win+R或者在搜索框搜索cmd打开Windows的终端，在终端输入python --version（3）找到上面的版本框进行对应的TensorFlow下载当时安装时并没有想到版本问题会影响TensorFlow后续的使用，就随便选了一个版本，当然你想选择一样的版本也行，后续做法跟我的做法会是一样的。这里我们从清华园下载TensorFlow的镜像文件,后面是版本号pip install -i ht
猫狗识别——tensorflow
weixin_42980278的博客
08-30 680
（一）数据 负责实现读取数据，生成批次（batch） import tensorflow as tf import numpy as np import os os模块包含操作系统相关的功能， 可以处理文件和目录这些我们日常手动需要做的操作。因为我们需要获取test目录下的文件，所以要导入os模块。 数据构成，在训练数据中，There are 12500 cat,Ther...
tensorflow猫狗识别
他山之石 可以攻玉
11-06 475
import os import warnings warnings.filterwarnings("ignore") import tensorflow as tf from tensorflow.keras.optimizers import Adam from tensorflow.keras.preprocessing.image import ImageDataGenerator base_dir = './data/cats_and_dogs' train_dir = os.path.jo.
TensorFlow实现猫狗识别代码
05-05
以下是使用TensorFlow实现猫狗识别的代码示例： ```python import tensorflow as tf from tensorflow.keras.preprocessing.image import ImageDataGenerator # 定义训练集和验证集的路径 train_dir = '/path/to/train' validation_dir = '/path/to/validation' # 进行数据增强 train_datagen = ImageDataGenerator( rescale=1./255, rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True, fill_mode='nearest' ) test_datagen = ImageDataGenerator(rescale=1./255) # 定义训练集和验证集的生成器 train_generator = train_datagen.flow_from_directory( train_dir, target_size=(150, 150), batch_size=20, class_mode='binary' ) validation_generator = test_datagen.flow_from_directory( validation_dir, target_size=(150, 150), batch_size=20, class_mode='binary' ) # 构建模型 model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(150, 150, 3)), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(64, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(128, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Conv2D(128, (3,3), activation='relu'), tf.keras.layers.MaxPooling2D(2,2), tf.keras.layers.Flatten(), tf.keras.layers.Dense(512, activation='relu'), tf.keras.layers.Dense(1, activation='sigmoid') ]) # 编译模型 model.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.RMSprop(lr=1e-4), metrics=['accuracy']) # 训练模型 history = model.fit( train_generator, steps_per_epoch=100, epochs=100, validation_data=validation_generator, validation_steps=50, verbose=2 ) ``` 在上述代码中，我们使用了TensorFlow的`ImageDataGenerator`来进行数据增强，从而提高模型的泛化能力。然后，我们定义了训练集和验证集的生成器，并使用这些生成器训练我们的模型。模型的结构为4个卷积层和2个全连接层，使用了ReLU作为激活函数，并在输出层使用了sigmoid函数作为二元分类器的激活函数。最后，我们使用了RMSprop优化器和二元交叉熵作为损失函数进行模型的编译和训练。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

降花绘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值