【tensorflow】T7.VGG16的咖啡豆识别

最新推荐文章于 2024-07-17 21:40:42 发布
最新推荐文章于 2024-07-17 21:40:42 发布
阅读量902 收藏 12
点赞数 14
文章标签： tensorflow 人工智能 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pung0302/article/details/140353977
版权

>- **🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客**
>- **🍖 原作者：[K同学啊](https://mtyjkh.blog.csdn.net/)**

一、前言：

  本次包含了vgg16的官方模型和自建模型，在我的理解下，官方模型貌似不能很容易的增加或删除某些层，所以在日后可能会加上一些轻量化的内容（虽然100%准确率还没解决hhh）

二、一如即往的先导包导数据：
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models
import PIL, pathlib
import matplotlib.pyplot as plt
import numpy as np

data_dir = "/kaggle/input/dataset2"
data_dir = pathlib.Path(data_dir)

image_count = len(list(data_dir.glob("*/*.png")))
print(image_count)

batch_size = 32
img_height = 224
img_wdith = 224

train_ds = keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split = 0.2,
    subset = "training",
    seed = 123,
    batch_size = batch_size,
    image_size = (img_height, img_wdith)

)

val_ds = keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split = 0.2,
    subset = "validation",
    seed = 123,
    batch_size = batch_size,
    image_size = (img_height, img_wdith)

)

class_names = train_ds.class_names
print(class_names)

plt.figure(figsize = (20, 10))

for image, labels in train_ds.take(1):
    for i in range(20):
        plt.subplot(5, 10, i+1)
        
        plt.imshow(image[i].numpy().astype("uint8"))
        plt.title(class_names[labels[i]])
        plt.axis("off")
        
for image_batch, labels_batch in train_ds:
    print(image_batch.shape)
    print(labels_batch.shape)
    break

#输出：

#图片总数：1200

#数据集分割内容：

Found 1200 files belonging to 4 classes.
Using 960 files for training.
Found 1200 files belonging to 4 classes.
Using 240 files for validation.

 #类别输出：

['Dark', 'Green', 'Light', 'Medium']

 #查看数据集格式：

(32, 224, 224, 3)
(32,)

#数据集的样本：

 三、配置数据集和归一化：
AUTOTUNE = tf.data.AUTOTUNE
train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size = AUTOTUNE)
val_ds = val_ds.cache().prefetch(buffer_size = AUTOTUNE)

#归一化
normalization_layer = layers.Rescaling(1. / 255)

train_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
val_ds = val_ds.map(lambda x, y: (normalization_layer(x), y))

image_batch, labels_batch = next(iter(val_ds))
image_1 = image_batch[0]

print(np.min(image_1), np.max(image_1))

#归一化后的数据内最大为1最小为0 ：

0.0 1.0
四、调用官方的vgg16模型
model = tf.keras.applications.VGG16(weights='imagenet')
model.summary()
#输出内容如下：：
Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5
553467096/553467096 ━━━━━━━━━━━━━━━━━━━━ 21s 0us/step

Model: "vgg16"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input_layer (InputLayer)        │ (None, 224, 224, 3)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_conv1 (Conv2D)           │ (None, 224, 224, 64)   │         1,792 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_conv2 (Conv2D)           │ (None, 224, 224, 64)   │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_pool (MaxPooling2D)      │ (None, 112, 112, 64)   │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_conv1 (Conv2D)           │ (None, 112, 112, 128)  │        73,856 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_conv2 (Conv2D)           │ (None, 112, 112, 128)  │       147,584 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_pool (MaxPooling2D)      │ (None, 56, 56, 128)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv1 (Conv2D)           │ (None, 56, 56, 256)    │       295,168 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv2 (Conv2D)           │ (None, 56, 56, 256)    │       590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv3 (Conv2D)           │ (None, 56, 56, 256)    │       590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_pool (MaxPooling2D)      │ (None, 28, 28, 256)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv1 (Conv2D)           │ (None, 28, 28, 512)    │     1,180,160 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv2 (Conv2D)           │ (None, 28, 28, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv3 (Conv2D)           │ (None, 28, 28, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_pool (MaxPooling2D)      │ (None, 14, 14, 512)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv1 (Conv2D)           │ (None, 14, 14, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv2 (Conv2D)           │ (None, 14, 14, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv3 (Conv2D)           │ (None, 14, 14, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_pool (MaxPooling2D)      │ (None, 7, 7, 512)      │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten (Flatten)               │ (None, 25088)          │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ fc1 (Dense)                     │ (None, 4096)           │   102,764,544 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ fc2 (Dense)                     │ (None, 4096)           │    16,781,312 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ predictions (Dense)             │ (None, 1000)           │     4,097,000 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 138,357,544 (527.79 MB)

 Trainable params: 138,357,544 (527.79 MB)

 Non-trainable params: 0 (0.00 B)

 #两种方法的训练结果放在后面比较

 五、自建vgg16模型： 
from tensorflow.keras import layers, models, Input
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dense, Flatten, Dropout

def VGG16(nb_classes, input_shape):
    input_tensor = Input(shape=input_shape)
    # 1st block
    x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv1')(input_tensor)
    x = Conv2D(64, (3,3), activation='relu', padding='same',name='block1_conv2')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block1_pool')(x)
    # 2nd block
    x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv1')(x)
    x = Conv2D(128, (3,3), activation='relu', padding='same',name='block2_conv2')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block2_pool')(x)
    # 3rd block
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv1')(x)
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv2')(x)
    x = Conv2D(256, (3,3), activation='relu', padding='same',name='block3_conv3')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block3_pool')(x)
    # 4th block
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv1')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv2')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block4_conv3')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block4_pool')(x)
    # 5th block
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv1')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv2')(x)
    x = Conv2D(512, (3,3), activation='relu', padding='same',name='block5_conv3')(x)
    x = MaxPooling2D((2,2), strides=(2,2), name = 'block5_pool')(x)
    # full connection
    x = Flatten()(x)
    x = Dense(4096, activation='relu',  name='fc1')(x)
    x = Dense(4096, activation='relu', name='fc2')(x)
    x = Dropout(0.3)(x)
    output_tensor = Dense(nb_classes, activation='softmax', name='predictions')(x)

    model = Model(input_tensor, output_tensor)
    return model

model=VGG16(6, (img_wdith, img_height, 3))
model.summary()

 #模型summary一下：

Model: "functional_1"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input_layer (InputLayer)        │ (None, 224, 224, 3)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_conv1 (Conv2D)           │ (None, 224, 224, 64)   │         1,792 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_conv2 (Conv2D)           │ (None, 224, 224, 64)   │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block1_pool (MaxPooling2D)      │ (None, 112, 112, 64)   │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_conv1 (Conv2D)           │ (None, 112, 112, 128)  │        73,856 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_conv2 (Conv2D)           │ (None, 112, 112, 128)  │       147,584 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block2_pool (MaxPooling2D)      │ (None, 56, 56, 128)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv1 (Conv2D)           │ (None, 56, 56, 256)    │       295,168 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv2 (Conv2D)           │ (None, 56, 56, 256)    │       590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_conv3 (Conv2D)           │ (None, 56, 56, 256)    │       590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block3_pool (MaxPooling2D)      │ (None, 28, 28, 256)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv1 (Conv2D)           │ (None, 28, 28, 512)    │     1,180,160 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv2 (Conv2D)           │ (None, 28, 28, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_conv3 (Conv2D)           │ (None, 28, 28, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block4_pool (MaxPooling2D)      │ (None, 14, 14, 512)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv1 (Conv2D)           │ (None, 14, 14, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv2 (Conv2D)           │ (None, 14, 14, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_conv3 (Conv2D)           │ (None, 14, 14, 512)    │     2,359,808 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ block5_pool (MaxPooling2D)      │ (None, 7, 7, 512)      │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten (Flatten)               │ (None, 25088)          │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ fc1 (Dense)                     │ (None, 4096)           │   102,764,544 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ fc2 (Dense)                     │ (None, 4096)           │    16,781,312 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dropout (Dropout)               │ (None, 4096)           │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ predictions (Dense)             │ (None, 6)              │        24,582 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 134,285,126 (512.26 MB)

 Trainable params: 134,285,126 (512.26 MB)

 Non-trainable params: 0 (0.00 B)
六、编译及训练
initial_learning_rate = 0.0001
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
    initial_learning_rate,
    decay_steps = 20,
    decay_rate = 0.92,
    staircase = True
    
    )

opt = keras.optimizers.Adam(learning_rate = initial_learning_rate)

model.compile(
    optimizer = opt,
    loss = keras.losses.SparseCategoricalCrossentropy(from_logits = True),
    metrics = ["accuracy"]
    
    )

epochs = 100

history = model.fit(
    train_ds,
    validation_data = val_ds,
    epochs = epochs,
    
    )
 七、两种模型的效果比较：

 #官方vgg16模型&参数的效果：

 #自建的vgg16模型效果：

八、loss和accuracy的曲线： 

#官方模型的结果：

#自建模型的结果：

九、总结：

  总结一下还是预训练的模型好用，调半天不如直接调，，，日后的方向可以在预训练参数的基础上着手提高准确率，最近会试试测试准确能不能到达100%，然后的任务是对vgg16进行轻量化。

 

矮山
关注
  • 14
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
tensorflow2.X搭建/调用VGG16及加载预训练参数
zzpl139的博客
09-04 2183
tensorflow2.X如何自己搭建、调用VGG16及加载预训练参数
调用tensorflow2中的tf.keras.applications.VGG16并进行微调
San_Zhang123的博客
07-29 2182
调用tensorflow2中的tf.keras.applications.VGG16并进行微调 环境配置：tensorflow版本2.3.0；cuda 10.1；python3.8 数据集：cifar10 代码如下： import tensorflow as tf (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data() #图像大小是32×32×3 base_model = tf.keras.applica
tensorflow2.0 Keras VGG16 VGG19 系列 代码实现
Forrest97的博客
05-15 5141
模型介绍参看：博文 VGG16 迁移模型 先看看标准答案 import tensorflow as tf from tensorflow import keras base_model = keras.applications.VGG16(weights='imagenet') base_model.summary() 自建模型 import tensorflow as tf from tensorflow import keras from tensorflow.keras
深度学习之基于Tensorflow2.0实现VGG16网络
starlet_kiss的博客
10-01 3876
VGG系列的网络，在网络深度上相比于其之前的网络有了提升，VGG16与VGG19是VGG系列的代表，本次基于Tensorflow2.0实现VGG16网络。 1.VGG16 网络简介 VGG16网络模型在2014年ImageNet比赛上脱颖而出，取得了在分类任务上排名第二，在定位任务上排名第一的好成绩。VGG16网络相比于之前的LexNet以及LeNet网络，在当时的网络层数上达到了空前的程度。 2.网络结构 3.创新点 ① 使用3x3的卷积核代替7x7的卷积核。 3x3 卷积核是能够感受到上下、左右重点的
如何使用Tensorflow的VGG16预置模型
qq_42635142的博客
06-29 1858
使用的是矩池云+Pycharm进行Tensorflow 预置的VGG16进行测试
基于tensorflow + Vgg16进行图像分类识别
热门推荐
daydayup_668819的博客
03-22 3万+
1. VGG-16介绍 vgg是在Very Deep Convolutional Networks for Large-Scale Image Recognition期刊上提出的。模型可以达到92.7%的测试准确度,在ImageNet的前5位。它的数据集包括1400万张图像，1000个类别。 vgg-16是一种深度卷积神经网络模型，16表示其深度，在图像分类等任务中取得了不错的效果。 vgg...
用tensorflow手动实现VGG16
weixin_43193071的博客
06-25 1945
用tensorflow手动实现VGG16 1简介 VGG卷积神经网络是牛津大学在2014年提出来的模型。当这个模型被提出时，由于它的简洁性和实用性，马上成为了当时最流行的卷积神经网络模型。它在图像分类和目标检测任务中都表现出非常好的结果。在2014年的ILSVRC比赛中，VGG 在Top-5中取得了92.3%的正确率。 2结构图 我们将其结构拆解开：具体每步过程如下 ​ 表4.5...
vgg16 清华镜像_Python models.vgg16方法代码示例
weixin_33264203的博客
12-31 2323
本文整理汇总了Python中torchvision.models.vgg16方法的典型用法代码示例。如果您正苦于以下问题：Python models.vgg16方法的具体用法？Python models.vgg16怎么用？Python models.vgg16使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在模块torchvision.models的...
vgg16识别咖啡豆
m0_60524373的博客
09-12 916
vgg16识别咖啡豆
TensorFlow keras vgg16net的使用
高颜值的杀生丸(此博客转载自我的博客园)
02-03 708
from tensorflow.python.keras.applications.vgg16 import VGG16,preprocess_input,decode_predictions from tensorflow.python.keras.preprocessing.image import load_img,img_to_array def predict(): ...
TensorFlow VGG-16 预训练模型-vgg_16.ckpt
02-01
TensorFlow VGG-16 预训练模型，用于SSD-TensorFlow的Demo训练.
tensorflow-使用tensorflow实现的vgg19+vgg16算法.zip
03-02
本项目聚焦于使用TensorFlow实现两种经典的卷积神经网络（Convolutional Neural Networks，简称CNN）：VGG19和VGG16。VGG模型由牛津大学的Visual Geometry Group在2014年的ImageNet竞赛中提出，因其深而窄的结构而...
基于 tensorflow+VGG-16 的图像分类识别算法
12-03
本次图像的分类识别实验采用的是基于 tensorflow+VGG-16 的图像分类识别模型。vgg是由 Simonyan 和 Zisserman 在文献《Very Deep Convolutional Networks for Large-Scale ImageRecognition》上提出的卷积神经网络...
VGG16-Tensorflow:VGG16的Tensorflow实现
05-02
VGG16的实施除了代码本身的注释外，我还写了一篇文章，您可以...内容vgg16.py ：带有vgg16.py的图形定义的类。 VGG16 Train.ipynb ：笔记本，用于培训和测试VGG16的实现。 如果您在查看笔记本文件时遇到问题，请单击。
基于TensorFlow1.x的人脸表情识别项目.zip
03-14
《基于TensorFlow1.x的人脸表情识别项目》 在当今的计算机视觉领域，人脸识别和情感分析已经成为热门的研究方向。这个项目以TensorFlow1.x为工具，实现了一个针对人脸表情识别的任务，旨在帮助我们理解并应用深度...
深度学习-2-TensorFlow和PyTorch深度学习框架的选择
qq_20466211的博客
07-14 126
深度学习常用框架TensorFlow和PyTorch的对比选择
2024Datawhale AI夏令营---基于术语词典干预的机器翻译挑战赛--学习笔记
weixin_61573157的博客
07-15 1079
机器翻译（Machine Translation，简称MT）是自然语言处理领域的一个重要分支，其目标是将一种语言的文本自动转换为另一种语言的文本。机器翻译的发展可以追溯到20世纪50年代，经历了从基于规则的方法、统计方法到深度学习方法的演变过程。当前，机器翻译正朝着更加智能化和个性化方向发展。一方面，结合上下文理解、情感分析等技术，提高翻译的准确性和自然度；另一方面，通过用户反馈和个性化学习，提供更加符合用户需求的翻译服务。同时，跨语言信息检索、多模态翻译等新兴领域也正在成为研究热点。
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
最新发布
wwt72的博客
07-17 603
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
揭示生成式 AI 在数据叙事和分析中的影响
gongdiwudu的专栏
07-16 1071
在广阔的数据分析领域，改变游戏规则的最深刻的发展之一是生成式人工智能 （GAI）。这是一个激动人心的时刻，人工智能不仅仅是基于历史数据进行处理和预测;它正在创造一些全新的东西，彻底改变数据叙事和分析过程。在最近的一次会议中，我有机会探讨了这项技术创新的基本原理、架构和潜在影响。以下是我们介绍的内容的简明摘要。
tensorflow.keras.applications.vgg16
07-07
tensorflow.keras.applications.vgg16模块提供了VGG16模型的预训练版本。VGG16是一个经典的卷积神经网络模型，由Karen Simonyan和Andrew Zisserman于2014年提出。它在ImageNet数据集上取得了很好的性能，并成为了深度学习图像分类任务的重要基准模型之一。 使用tensorflow.keras.applications.vgg16可以加载VGG16模型的预训练权重，并进行图像分类任务。下面是一个加载VGG16模型并进行图像分类的示例： ```python from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input, decode_predictions from tensorflow.keras.preprocessing import image import numpy as np # 加载VGG16模型（不包括顶部的全连接层） model = VGG16(weights='imagenet', include_top=False) # 载入并预处理图像 img_path = 'path/to/your/image.jpg' img = image.load_img(img_path, target_size=(224, 224)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) # 使用VGG16模型进行预测 features = model.predict(x) # 解码预测结果 decoded_predictions = decode_predictions(features, top=3)[0] for pred_class in decoded_predictions: print(pred_class[1], pred_class[2]) ``` 以上示例代码中，我们首先加载了VGG16模型，并指定了使用ImageNet数据集上预训练的权重。然后，我们加载了待预测的图像，并进行了预处理，包括调整尺寸和归一化。接下来，使用VGG16模型对图像进行预测，并通过decode_predictions函数解码预测结果，输出前三个最可能的类别标签和对应的概率。 需要注意的是，VGG16模型的输入尺寸为224x224像素的RGB图像。在使用该模型进行预测时，需要将输入图像调整为相应的尺寸，并进行适当的预处理操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值