TensorFlow中的VGG16 介绍以及 代码

最新推荐文章于 2025-06-29 08:13:08 发布
最新推荐文章于 2025-06-29 08:13:08 发布
阅读量3.2k 收藏 20
点赞数 4
CC 4.0 BY-SA版权
分类专栏： VGG
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40979622/article/details/88784331

VGG是由牛津大学的K. Simonyan和A. Zisserman在“用于大规模图像识别的超深度卷积网络”一文中提出的卷积神经网络模型。  。该模型在ImageNet中实现了92.7％的前5个测试精度  ，这是属于1000个类的超过1400万张图像的数据集。

 

VGG16 之前一直没找到代码，今天找到了。

关于原理，之前看过，这里就不写了。一以后有hi时间再写。

这段代码是测试代码，人家已经把模型训练好了。我们直接下载它的模型用就可以了。

关于训练，以及换数据集，我明天再试试。

我是在这里找到的。https://www.cs.toronto.edu/~frossard/post/vgg16/

代码：

import tensorflow as tf
import numpy as np
from scipy.misc import imread, imresize
from imagenet_classes import class_names


class vgg16:
    def __init__(self, imgs, weights=None, sess=None):
        self.imgs = imgs
        self.convlayers()
        self.fc_layers()
        self.probs = tf.nn.softmax(self.fc3l)
        if weights is not None and sess is not None:
            self.load_weights(weights, sess)


    def convlayers(self):
        self.parameters = []

        # zero-mean input
        with tf.name_scope('preprocess') as scope:
            mean = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
            images = self.imgs-mean

        # conv1_1
        with tf.name_scope('conv1_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 3, 64], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(images, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv1_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv1_2
        with tf.name_scope('conv1_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 64, 64], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv1_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[64], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv1_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool1
        self.pool1 = tf.nn.max_pool(self.conv1_2,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool1')

        # conv2_1
        with tf.name_scope('conv2_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 64, 128], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv2_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv2_2
        with tf.name_scope('conv2_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 128, 128], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv2_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[128], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv2_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool2
        self.pool2 = tf.nn.max_pool(self.conv2_2,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool2')

        # conv3_1
        with tf.name_scope('conv3_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 128, 256], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv3_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv3_2
        with tf.name_scope('conv3_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv3_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv3_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv3_3
        with tf.name_scope('conv3_3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 256], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv3_2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[256], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv3_3 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool3
        self.pool3 = tf.nn.max_pool(self.conv3_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool3')

        # conv4_1
        with tf.name_scope('conv4_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 256, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool3, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv4_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv4_2
        with tf.name_scope('conv4_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv4_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv4_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv4_3
        with tf.name_scope('conv4_3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv4_2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv4_3 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool4
        self.pool4 = tf.nn.max_pool(self.conv4_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool4')

        # conv5_1
        with tf.name_scope('conv5_1') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.pool4, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv5_1 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv5_2
        with tf.name_scope('conv5_2') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv5_1, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv5_2 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # conv5_3
        with tf.name_scope('conv5_3') as scope:
            kernel = tf.Variable(tf.truncated_normal([3, 3, 512, 512], dtype=tf.float32,
                                                     stddev=1e-1), name='weights')
            conv = tf.nn.conv2d(self.conv5_2, kernel, [1, 1, 1, 1], padding='SAME')
            biases = tf.Variable(tf.constant(0.0, shape=[512], dtype=tf.float32),
                                 trainable=True, name='biases')
            out = tf.nn.bias_add(conv, biases)
            self.conv5_3 = tf.nn.relu(out, name=scope)
            self.parameters += [kernel, biases]

        # pool5
        self.pool5 = tf.nn.max_pool(self.conv5_3,
                               ksize=[1, 2, 2, 1],
                               strides=[1, 2, 2, 1],
                               padding='SAME',
                               name='pool4')

    def fc_layers(self):
        # fc1
        with tf.name_scope('fc1') as scope:
            shape = int(np.prod(self.pool5.get_shape()[1:]))
            fc1w = tf.Variable(tf.truncated_normal([shape, 4096],
                                                         dtype=tf.float32,
                                                         stddev=1e-1), name='weights')
            fc1b = tf.Variable(tf.constant(1.0, shape=[4096], dtype=tf.float32),
                                 trainable=True, name='biases')
            pool5_flat = tf.reshape(self.pool5, [-1, shape])
            fc1l = tf.nn.bias_add(tf.matmul(pool5_flat, fc1w), fc1b)
            self.fc1 = tf.nn.relu(fc1l)
            self.parameters += [fc1w, fc1b]

        # fc2
        with tf.name_scope('fc2') as scope:
            fc2w = tf.Variable(tf.truncated_normal([4096, 4096],
                                                         dtype=tf.float32,
                                                         stddev=1e-1), name='weights')
            fc2b = tf.Variable(tf.constant(1.0, shape=[4096], dtype=tf.float32),
                                 trainable=True, name='biases')
            fc2l = tf.nn.bias_add(tf.matmul(self.fc1, fc2w), fc2b)
            self.fc2 = tf.nn.relu(fc2l)
            self.parameters += [fc2w, fc2b]

        # fc3
        with tf.name_scope('fc3') as scope:
            fc3w = tf.Variable(tf.truncated_normal([4096, 1000],
                                                         dtype=tf.float32,
                                                         stddev=1e-1), name='weights')
            fc3b = tf.Variable(tf.constant(1.0, shape=[1000], dtype=tf.float32),
                                 trainable=True, name='biases')
            self.fc3l = tf.nn.bias_add(tf.matmul(self.fc2, fc3w), fc3b)
            self.parameters += [fc3w, fc3b]

    def load_weights(self, weight_file, sess):
        weights = np.load(weight_file)
        keys = sorted(weights.keys())
        for i, k in enumerate(keys):
            print (i, k, np.shape(weights[k]))
            sess.run(self.parameters[i].assign(weights[k]))

if __name__ == '__main__':
    sess = tf.Session()
    imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
    vgg = vgg16(imgs, 'vgg16_weights.npz', sess)

    img1 = imread('gou.jpg', mode='RGB')
    img1 = imresize(img1, (224, 224))

    prob = sess.run(vgg.probs, feed_dict={vgg.imgs: [img1]})[0]
    preds = (np.argsort(prob)[::-1])[0:5]
    for p in preds:
        print (class_names[p], prob[p])

以上代码在在VGG16.py文件中。这段代码还不够，需要两个文件 文件地址在上面写着。

imagenet_classes.py     https://www.cs.toronto.edu/~frossard/vgg16/imagenet_classes.py

vgg16_weights.npz        https://www.cs.toronto.edu/~frossard/vgg16/vgg16_weights.npz

把这两个和上面的代码放在一个文件中。

再找一个图片引入测试就可以看识别的情况了。

我的运行结果

个人感觉识别率不高。不过识别的范围还是挺广的。 

希望后期能够改进（改进是不可能的，这辈子都不可能）

 

VGG16系列I: 基于Tensorflow代码
bmwlwg的博客
09-10 4381
目录 0. 数据集 I. VGG16 Tensorflow 模型代码 II. VGG16 Tensorflow 模型训练代码 II. VGG16 Tensorflow 模型预测代码 0. 数据集 cat-and-dog 文件夹结构如下 | I. VGG16 Tensorflow 模型代码 model.py import numpy as np import ...
基于tensorflow使用VGG16实现猫狗识别
2303_77224751的博客
11-22 1015
【代码】基于tensorflow使用VGG16实现猫狗识别。
tensorflow-vgg16代码
11-24
忘了是哪本外国书的源代码了，只是当时看书的时候顺便Copy了作者给的代码，
pytorch入门 - VGG16神经网络
最新发布
weixin_36842364的博客
06-29 17
VGG16是由牛津大学Visual Geometry Group(VGG)在2014年提出的深度卷积神经网络模型，它在当年的ImageNet图像分类竞赛中取得了优异成绩。VGG16的主要贡献在于展示了网络深度(层数)对模型性能的重要性，通过使用多个小尺寸(3×3)卷积核堆叠来代替大尺寸卷积核，在保持相同感受野的同时减少了参数数量，提高了模型的非线性表达能力。VGG16之所以著名，是因为它结构简洁规整，全部使用3×3小卷积核和2×2最大池化层，这种设计理念对后续的CNN架构设计产生了深远影响。
VGG16模型tensorflow实现
05-05
包括数据集预处理以及生成tfrecord文件，用自己数据集训练VGG16，亲测可用
tensorflow微调vgg16 程序代码汇总
小小鹿luby的博客
06-14 8466
一、【深度学习图像识别课程】tensorflow迁移学习系列：VGG16花朵分类转自：https://blog.youkuaiyun.com/weixin_41770169/article/details/80330581花朵数据库介绍种类5种：daisy雏菊，dandelion蒲公英，rose玫瑰，sunflower向日葵，tulips郁金香数量：     633，            898，     ...
tensorflow-vgg16
10-09
vgg16的tensorflow模型，可直接修改或应用到自己的代码中，也可将caffe模型转成tensorflow。
VGG16_TF:简单实现VGG16
04-28
学习Tensorflow，拿VGG16练练手，没有其他骚操作，只有数据集制作，训练及测试。 训练数据-17flowers，百度网盘链接: : 3nc4 VGG16.npy，百度网盘链接: : 4wvq create_tfrecords.py为生成tfrecords数据脚本 VGG16....
tensorflow-VGG猫狗识别
tjl521314_21的博客
02-19 408
前面已经对tensorflow训练框架已经有了熟悉的了解，这周主要使用VGG16实现猫狗识别，同时学习model.train_on_batch方法。VGG16总共有16层，13个卷积层和3个全连接层，第一次经过64个卷积核的两次卷积后，采用一次池化，第二次经过两次128个卷积核卷积后，再采用池化，再重复两次三个512个卷积核卷积后，再池化，最后经过三次全连接。
vgg16模型tensorflow2.64实现
m0_73817310的博客
09-23 374
vgg16模型tensorflow2.64实现
深度学习与TensorFlow实战（十）卷积神经网络—VGG（16）神经网络
法兰西流浪者博客
08-27 1万+
架构： 训练输入：固定尺寸224x224的RGB图像。 预处理：每个像素减去训练集上的RGB均值。 卷积核：一系列3X3卷积核堆叠，步长为1，采用padding保持卷积后图像空间分辨率不变。 空间池化：紧随卷积堆的最大池化，为2x2滑动窗口，步长2. 全连接层：特征提取后，接三个全连接层，前两个为4096，第三个为1000通道，最后是一个softmax层，输出概率。 所有隐藏层都用非线...
VGG16_vgg16代码_VGG16_vgg16代码详解_
09-29
vgg16代码，最简单版本，容易看懂，易上手，按照论文敲的
VGG16-Tensorflow:VGG16的Tensorflow实现
05-02
VGG16的实施 除了代码本身的注释外，我还写了一篇文章，您可以在找到有关VGGNet的进一步说明。 内容 vgg16.py ：带有vgg16.py的图形定义的类。 VGG16 Train.ipynb ：笔记本，用于培训和测试VGG16的实现。 如果您在查看笔记本文件时遇到问题，请单击。
使用深度学习（tensorflow）识别动物的简单案例（vgg16）包含数据集及代码——0基础版
小白
01-03 1988
1.Tensorflow 版本 tensorflow的版本是1.12.0 如何安装tensorflow1.12.0？首先使用conda创建python版本为3.6的虚拟环境，然后再在虚拟环境中使用命令conda install tensorflow==1.12.0安装tensorflow 1.12.0版本。具体过程请百度。 2.VGG16模型权重数据集下载 链接：https://pan.baidu.com/s/1OBQUWafOF8LYY73-sW7SUw 提取码：xcmp 下载后的数据移动至目录：C
利用TensorFlow实现VGG16
Cheese的博客
09-08 2万+
本篇文章实现了一个 TensorFlow版本的Vgg16,完成了数据从制作，到输入，训练的整个过程。
tensorflow系列之_vgg16网络编写
qq_24975309的博客
06-20 848
#!/usr/bin/env python # -*- coding: utf-8 -*- # @time: 2020/6/19 15:39 import tensorflow as tf from tensorflow.contrib import slim import numpy as np def vgg16(x, num_classes=1000, is_training=True, keep_prob=0.6, s.
VGG16-tensorflow
qq_35482604的博客
03-01 300
Tensorflow: 从checkpoint文件中读取tensor方式 import os from tensorflow.python import pywrap_tensorflow checkpoint_path = os.path.join(model_dir, "model.ckpt") # Read data from checkpoint file reader = pywra...
TensorFlow VGG16
Claroja
07-26 562
VGG 2014年牛津大学提出，在2014年的ILSVRC比赛中，VGG 在Top-5中取得了92.3%的正确率。 参考： VGG16原文 卷积神经网络VGG16这么简单 VGG16学习笔记 VGG16学习笔记 ...
利用Tensorflow实现VGG16及训练自己的数据
热门推荐
weixin_31200719的博客
07-26 3万+
 参考：《Tensorflow实战》《Tensorflow 实战Google深度学习框架》 https://blog.youkuaiyun.com/sinat_16823063/article/details/53946549 https://blog.youkuaiyun.com/yaoqi_isee/article/details/77526497 https://blog.youkuaiyun.com/u0127591...
tensorflow中vgg16进行猫狗大战的完成代码
05-14
<think>嗯，用户想要使用TensorFlow和VGG16实现猫狗分类的完整代码。首先，我需要确认用户的环境是否配置正确，特别是TensorFlow的版本。根据引用[1]，有些版本比如2.2.0可能会有image_dataset_from_directory的问题，所以需要确保用户升级到较新的版本，比如2.4.0以上。 接下来，用户的需求是完整的代码，所以我需要提供一个端到端的解决方案，包括数据加载、模型构建、训练和评估。VGG16通常是通过迁移学习来应用，所以应该使用预训练的模型，冻结前面的卷积层，然后添加自定义的全连接层进行分类。 数据预处理部分，引用[1]提到了使用image_dataset_from_directory来加载数据集，这很方便，应该采用这个方法。同时，数据增强也是必要的，比如旋转、翻转等，这可以提高模型的泛化能力，引用[3]中的ImageDataGenerator也可以考虑，但根据TensorFlow版本，可能更推荐使用tf.keras.utils.image_dataset_from_directory。 模型构建方面，引用[3]和[4]展示了如何导入VGG16模型，并在顶部添加全连接层。需要注意的是，要设置include_top=False，这样可以使用自己的分类层。同时，需要冻结VGG16的卷积层，只训练顶部的层。此外，优化器的选择，比如使用SGD或者Adam，以及学习率的设置也很重要。 训练过程中，引用[4]提到使用train_on_batch，但通常更常见的是使用fit方法，尤其是当数据集已经通过image_dataset_from_directory加载为tf.data.Dataset格式时。需要配置回调函数，比如ModelCheckpoint和EarlyStopping，以保存最佳模型和防止过拟合。 评估部分需要包含准确率和损失曲线的可视化，以及测试集的评估。用户可能需要看到训练过程的效果，所以绘制训练和验证的准确率/损失变化图是必要的。 可能还需要注意数据集的路径结构是否正确，猫和狗的图片应该分别存放在train和test目录下的cat和dog子目录中。另外，输入图像的尺寸需要调整到VGG16默认的224x224，但根据引用[2]，CIFAR-10使用的是32x32，不过VGG16通常需要更大的尺寸，所以可能需要调整。 最后，确保代码的每一步都有注释，说明其作用，这样用户能够理解每个部分的功能。同时，提醒用户注意可能的常见问题，比如数据集路径错误、TensorFlow版本问题，以及是否需要GPU支持等。</think>以下是用TensorFlow和VGG16实现猫狗分类的完整代码实现，包含数据预处理、模型构建、训练与评估全流程： ```python import tensorflow as tf from tensorflow.keras.applications import VGG16 from tensorflow.keras.models import Model from tensorflow.keras.layers import Dense, Flatten, Dropout from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.optimizers import Adam from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping # 参数设置 IMG_SIZE = (224, 224) # VGG16默认输入尺寸 BATCH_SIZE = 32 EPOCHS = 15 TRAIN_DIR = "./data/train" # 训练集路径，需包含cat/dog子目录 VAL_DIR = "./data/validation" # 验证集路径，结构同上 # 数据预处理与增强 train_datagen = ImageDataGenerator( rescale=1./255, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True, validation_split=0.2 # 80%训练，20%验证 ) train_generator = train_datagen.flow_from_directory( TRAIN_DIR, target_size=IMG_SIZE, batch_size=BATCH_SIZE, class_mode='binary', subset='training' ) val_generator = train_datagen.flow_from_directory( TRAIN_DIR, target_size=IMG_SIZE, batch_size=BATCH_SIZE, class_mode='binary', subset='validation' ) # 构建VGG16迁移学习模型 base_model = VGG16( weights='imagenet', include_top=False, # 不包含顶层全连接层 input_shape=(224, 224, 3) ) # 冻结卷积基 base_model.trainable = False # 添加自定义顶层 x = base_model.output x = Flatten()(x) x = Dense(512, activation='relu')(x) x = Dropout(0.5)(x) predictions = Dense(1, activation='sigmoid')(x) model = Model(inputs=base_model.input, outputs=predictions) # 编译模型 model.compile( optimizer=Adam(learning_rate=1e-4), loss='binary_crossentropy', metrics=['accuracy'] ) # 训练回调函数 callbacks = [ ModelCheckpoint( 'best_vgg16_model.h5', monitor='val_accuracy', save_best_only=True ), EarlyStopping( monitor='val_loss', patience=3, restore_best_weights=True ) ] # 训练模型 history = model.fit( train_generator, steps_per_epoch=train_generator.samples // BATCH_SIZE, validation_data=val_generator, validation_steps=val_generator.samples // BATCH_SIZE, epochs=EPOCHS, callbacks=callbacks ) # 模型评估 test_datagen = ImageDataGenerator(rescale=1./255) test_generator = test_datagen.flow_from_directory( VAL_DIR, target_size=IMG_SIZE, batch_size=BATCH_SIZE, class_mode='binary' ) loss, accuracy = model.evaluate(test_generator) print(f"测试集准确率：{accuracy*100:.2f}%") ```
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值