tf VGG model

最新推荐文章于 2024-01-11 20:01:10 发布
最新推荐文章于 2024-01-11 20:01:10 发布
阅读量450 收藏
点赞数
分类专栏： tensorflow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_27655147/article/details/79403712
版权 
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Thu Jan  4 14:18:15 2018

@author: stefan
"""
import tensorflow as tf
def mmodel(images,batch_size):
    with tf.variable_scope('conv1_1') as scope:
        weights = tf.get_variable('weights', 
                                  shape = [3,3,3, 64],
                                  dtype = tf.float32, 
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases', 
                                 shape=[64],
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(images, weights, strides=[1,1,1,1], padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv1_1 = tf.nn.relu(pre_activation, name= scope.name)
    with tf.variable_scope('conv1_2') as scope:
        weights = tf.get_variable('weights', 
                                  shape = [3,3,64, 64],
                                  dtype = tf.float32, 
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases', 
                                 shape=[64],
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv1_1, weights, strides=[1,1,1,1], padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv1_2 = tf.nn.relu(pre_activation, name= scope.name)
    with tf.variable_scope('pooling1_lrn') as scope:
        pool1 = tf.nn.max_pool(conv1_2, ksize=[1,2,2,1],strides=[1,2,2,1],
                               padding='SAME', name='pooling1')
        #norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001/9.0,
        #                  beta=0.75,name='norm1')
        
        
    with tf.variable_scope('conv2_1') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,64,128],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[128], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(pool1, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv2_1 = tf.nn.relu(pre_activation, name='conv2_1')
    with tf.variable_scope('conv2_2') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,128,128],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[128], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv2_1, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv2_2 = tf.nn.relu(pre_activation, name='conv2_2') 
    with tf.variable_scope('pooling2_lrn') as scope:
        #norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                          #beta=0.75,name='norm2')
        pool2 = tf.nn.max_pool(conv2_2, ksize=[1,2,2,1], strides=[1,2,2,1],
                               padding='SAME',name='pooling2')
        
        
    with tf.variable_scope('conv3_1') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,128,256],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[256], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(pool2, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv3_1 = tf.nn.relu(pre_activation, name='conv3_1')
    with tf.variable_scope('conv3_2') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,256,256],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[256], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv3_1, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv3_2 = tf.nn.relu(pre_activation, name='conv3_2')
    with tf.variable_scope('conv3_3') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,256,256],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[256], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv3_2, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv3_3 = tf.nn.relu(pre_activation, name='conv3_3')
    with tf.variable_scope('pooling3_lrn') as scope:
        #norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                          #beta=0.75,name='norm2')
        pool3 = tf.nn.max_pool(conv3_3, ksize=[1,2,2,1], strides=[1,2,2,1],
                               padding='SAME',name='pooling3')
    
    
    with tf.variable_scope('conv4_1') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,256,512],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[512], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(pool3, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv4_1 = tf.nn.relu(pre_activation, name='conv4_1')
    with tf.variable_scope('conv4_2') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,512,512],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[512], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv4_1, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv4_2 = tf.nn.relu(pre_activation, name='conv4_2')
    with tf.variable_scope('conv4_3') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,512,512],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[512], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv4_2, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv4_3 = tf.nn.relu(pre_activation, name='conv4_3')
    with tf.variable_scope('pooling4_lrn') as scope:
        #norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                          #beta=0.75,name='norm2')
        pool4 = tf.nn.max_pool(conv4_3, ksize=[1,2,2,1], strides=[1,2,2,1],
                               padding='SAME',name='pooling4')
    
    
    with tf.variable_scope('conv5_1') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,512,512],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[512], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(pool4, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv5_1 = tf.nn.relu(pre_activation, name='conv5_1')
    with tf.variable_scope('conv5_2') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,512,512],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[512], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv5_1, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv5_2 = tf.nn.relu(pre_activation, name='conv5_2')
    with tf.variable_scope('conv5_3') as scope:
        weights = tf.get_variable('weights',
                                  shape=[3,3,512,512],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer_conv2d())
        biases = tf.get_variable('biases',
                                 shape=[512], 
                                 dtype=tf.float32,
                                 initializer=tf.constant_initializer(0.1))
        conv = tf.nn.conv2d(conv5_2, weights, strides=[1,1,1,1],padding='SAME')
        pre_activation = tf.nn.bias_add(conv, biases)
        conv5_3 = tf.nn.relu(pre_activation, name='conv5_3')
    with tf.variable_scope('pooling5_lrn') as scope:
        #norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001/9.0,
                          #beta=0.75,name='norm2')
        pool5 = tf.nn.max_pool(conv5_3, ksize=[1,2,2,1], strides=[1,2,2,1],
                               padding='SAME',name='pooling5')
    
    
    with tf.variable_scope('fc6') as scope:
        reshape = tf.reshape(pool5, shape=[batch_size, -1])
        dim = reshape.get_shape()[1].value
        weights = tf.get_variable('weights',
                                  shape=[dim,4096],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer())
        biases = tf.get_variable('biases',
                                 shape=[4096],
                                 dtype=tf.float32, 
                                 initializer=tf.constant_initializer(0.1))
        fc6 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
        fc6_drop = tf.nn.dropout(fc6, 0.5, name = "fc6_drop")
        
    with tf.variable_scope('fc7') as scope:
        
        dim = fc6_drop.get_shape()[1].value
        weights = tf.get_variable('weights',
                                  shape=[dim,4096],
                                  dtype=tf.float32,
                                  initializer=tf.contrib.layers.xavier_initializer())
        biases = tf.get_variable('biases',
                                 shape=[4096],
                                 dtype=tf.float32, 
                                 initializer=tf.constant_initializer(0.1))
        fc7 = tf.nn.relu(tf.matmul(fc6_drop, weights) + biases, name=scope.name)
        fc7_drop = tf.nn.dropout(fc7, 0.5, name = "fc7_drop")
    
    with tf.variable_scope('softmax_linear') as scope:
        weights = tf.get_variable('softmax_linear',
                                  shape=[4096, 5],
                                  dtype=tf.float32,
                                  initializer=tf.truncated_normal_initializer(stddev=0.005,dtype=tf.float32))
        biases = tf.get_variable('biases', 
                                 shape=[5],
                                 dtype=tf.float32, 
                                 initializer=tf.constant_initializer(0.1))
        softmax_linear = tf.add(tf.matmul(fc7_drop, weights), biases, name='softmax_linear')
    return softmax_linear

def loss(logits,label_batches):
     cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits,labels=label_batches)
     cost = tf.reduce_mean(cross_entropy)
     #add loss in summary
     tf.summary.scalar("loss", cost)
     return cost

def get_accuracy(logits, labels):
    acc = tf.nn.in_top_k(logits, labels , 1)
    acc = tf.cast(acc, tf.float32)
    acc = tf.reduce_mean(acc)
    #add acc in summary
    tf.summary.scalar("acc", acc)
    return acc

def training(loss, lr):
    train_op = tf.train.RMSPropOptimizer(lr, 0.9).minimize(loss)
    return train_op

Tensorflow实例：实现VGG
蚊子爱牛牛的博客
11-23 3009
VGGNet探索了卷积神经网络的深度与其性能之间的关系
keras vgg 代码实例
04-30
keras vgg 训练自己的数据.详细的观看 https://blog.keras.io/building-powerful-image-classification-models-using-very-little-data.html
VGG-Model(pytorch版本)
Major_S的博客
11-24 577
VGG−Model(pytorch版本)VGG-Model(pytorch版本)VGG−Model(pytorch版本) 补充:SE_VGG import torch.nn as nn import torch class SE_VGG(nn.Module): def __init__(self, num_classes): super().__init__() self.num_classes = num_classes # define an
VGG 案例
pangxing6491的博客
04-26 661
基于tensorflow + Vgg16进行图像分类识别：https://blog.csdn.net/daydayup_668819/article/details/79651137
VGG实战
xiaobian_的博客
05-10 687
卷积层参数： 卷积层 conv3conv3conv3 表示卷积核尺寸为 3×33\times33×3，conv3−64conv3-64conv3−64 表示卷积后通道数为 646464，所有卷积步长 stride=1stride=1stride=1，填充方式 padding=samepadding=samepadding=same（即输出大小和输入大小一致），这样卷积操作不会改变图像大小，仅改变通道数。 池化层参数： 池化层 maxpoolingmaxpoolingmaxpooling 的参数均为 2×2.
使用caffe微调VGG的一个例子
jinbeibei0606的博客
04-26 5091
1.得到数据集,对数据集做处理，处理成模型需要的数据格式，分出训练集，验证集以及测试集; 2.为数据集生成标签文件，生成均值文件。http://www.2cto.com/kf/201704/623027.html 3.人脸数据划分，转换为LMDB。 4.使用该数据通过以models/finetune_flickr_style/train_val.prototxt 为模板，以vgg_face_c
vgg16_weights_tf_dim_ordering_tf_kernels.h5
11-15
model = VGG16(weights='path_to_vgg16_weights_tf_dim_ordering_tf_kernels.h5', include_top=False) ``` 在这里，`include_top=False`表示不包括模型的顶部全连接层，因为这些层通常是针对ImageNet分类任务训练的...
vgg16_weights_tf_dim_ordering_tf_kernels_notop.rar
07-06
base_model = VGG16(weights='vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5', include_top=False) ``` 这里`include_top=False` 表示不加载预训练模型的顶层（即密集连接层）。之后，你可以添加自己的分类层...
vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5
01-18
base_model.load_weights('vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5') # 添加自己的全连接层 x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) ...
vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5.zip
02-24
base_model = VGG16(weights='vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5', include_top=False) ``` 接下来，根据具体需求，可以对模型的输出添加自定义的全连接层： ```python x = base_model.output x ...
简单易懂Pytorch实战实例VGG深度网络
09-18
主要介绍了简单易懂Pytorch实战实例VGG深度网络
VGG网络分析与demo实例
m0_60921016的博客
12-25 871
参考自VGG 在2014年由牛津大学著名研究组）提出，斩获该年 ImageNet 竞赛中 Localization Task（定位任务）第一名和 Classification Task（分类任务）第二名。VGG 的创新点：通过堆叠多个小卷积核来替代大尺度卷积核，可以减少训练参数，同时能保证相同的感受野。论文中提到，可以通过堆叠两个3×3的卷积核替代5x5的卷积核，堆叠三个3×3的卷积核替代7x7的卷积核。
动手学深度学习学习笔记tf2.0版（5.7 使用重复元素的网络（VGG））
岁月如歌
03-14 432
import tensorflow as tf import os print(tf.__version__) VGG块的组成规律是：连续使用数个相同的填充为1、窗口形状为 3×3 的卷积层后接上一个步幅为2、窗口形状为 2×2 的最大池化层。卷积层保持输入的高和宽不变，而池化层则对其减半。我们使用vgg_block函数来实现这个基础的VGG块，它可以指定卷积层的数量num_convs和输...
VGG神经网络搭建实例----pytorch
Strive_LiJiaLe的博客
03-21 491
笔记，感谢B站up：霹雳巴拉Wz 1.搭建模型脚本model.py import torch.nn as nn import torch # 定义分类网络结构（全连接层） class VGG(nn.Module): # 初始化函数 # feature是后面make_features函数提取特征网络结构； # num_classes:分类的类别个数 # 是否对网络权重进行初始化 def __init__(self, features, num_classes=1000, init_weigh
深度学习案例--猫狗大战（vgg16实现）
最新发布
m0_62412733的博客
01-11 1316
这是一个基于OneAPI并使用vgg16实现猫狗图像识别的深度学习小项目
卷积神经网络入门五大网络之一 VGGNet网络案例
weixin_46969441的博客
11-26 931
VGGNet VGG的实质:AlexNet增强版 VGG网络用了更小的3x3的卷积核，两个连续的3x3的卷积核相当于5x5的感受野。 三个3x3的连续的卷积核也就相当于7x7的感受野。 VGG池化层特征池化核2x2；AlexNet网络中池化核3x3； 从而层数变多，训练参数减少。 层数多，提取特征效果好，但是计算量就大了。 特点： 小尺寸卷积核 减少参数 提升准确率 16层网络 f分别是 CBA CBAPT 35 CBA CBAPT 35 CBA CBA CBAPT 335 CBA CBA CBAPT
基于TF的迁移学习VGG16网络，并进行图片的测试。
格子衫的博客
05-04 2597
vgg16.py文件1.一开始在通过vgg =Vgg16()的调用，会自动初始化，在初始化过程中，会找到目录下的vgg16.npy文件，也就是在imagenet上训练好的权重文件，然后通过np.load()完成权重文件的加载。代码如下：class Vgg16: def __init__(self, vgg16_npy_path=None): if vgg16_npy_pat...
tf vgg19 微调 flowers 分类网络
阿豪
10-23 169
原文链接: tf vgg19 微调 flowers 分类网络 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值