YOLO

最新推荐文章于 2023-06-30 16:32:45 发布
最新推荐文章于 2023-06-30 16:32:45 发布
阅读量790 收藏
点赞数 1
分类专栏： 深度学习 文章标签： yolo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/joker_shy/article/details/102720332
版权

you only look once

yolo的架构

代码

import tensorflow as tf
import numpy as np
import yolo.config as cfg


class yolo_v2(object):
    def __init__(self, isTraining=True):
        self.classes = cfg.CLASSES  # 类别
        self.num_class = len(self.classes)  # 20类

        self.box_per_cell = cfg.BOX_PRE_CELL  # 每个网格预测的边界框数
        self.cell_size = cfg.CELL_SIZE  # 最后一层的大小
        self.batch_size = cfg.BATCH_SIZE  # 每次训练的批量
        self.image_size = cfg.IMAGE_SIZE  # 输入图像的大小
        self.anchor = cfg.ANCHOR
        self.alpha = cfg.ALPHA

        self.class_scale = 1.0
        self.object_scale = 5.0
        self.noobject_scale = 1.0
        self.coordinate_scale = 1.0

        self.offset = np.transpose(
            np.reshape(np.array([np.arange(self.cell_size)] * self.cell_size * self.box_per_cell),
                       [self.box_per_cell, self.cell_size, self.cell_size]), (1, 2, 0))
        # print(self.offset.shape)
        self.offset = tf.reshape(tf.constant(self.offset, dtype=tf.float32),
                                 [1, self.cell_size, self.cell_size, self.box_per_cell])
        self.offset = tf.tile(self.offset, (self.batch_size, 1, 1, 1))
        # print(self.offset)

        self.images = tf.placeholder(tf.float32, [None, self.image_size, self.image_size, 3],
                                     name='images')  # 416,416,3
        self.logits = self.build_networks(self.images)
        print(self.logits.shape)

        if isTraining:
            self.labels = tf.placeholder(tf.float32,
                                         [None, self.cell_size, self.cell_size, self.box_per_cell, self.num_class + 5],
                                         name='labels')
            self.total_loss = self.loss_layer(self.logits, self.labels)
            tf.summary.scalar('total_loss', self.total_loss)

    def build_networks(self, inputs):  # 416,416,3
        net = self.conv_layer(inputs, [3, 3, 3, 32], name='0_conv')
        net = self.pooling_layer(net, name='1_pool')

        net = self.conv_layer(net, [3, 3, 32, 64], name='2_conv')
        net = self.pooling_layer(net, name='3_pool')

        net = self.conv_layer(net, [3, 3, 64, 128], name='4_conv')
        net = self.conv_layer(net, [1, 1, 128, 64], name='5_conv')
        net = self.conv_layer(net, [3, 3, 64, 128], name='6_conv')
        net = self.pooling_layer(net, name='7_pool')

        net = self.conv_layer(net, [3, 3, 128, 256], name='8_conv')
        net = self.conv_layer(net, [1, 1, 256, 128], name='9_conv')
        net = self.conv_layer(net, [3, 3, 128, 256], name='10_conv')
        net = self.pooling_layer(net, name='11_pool')

        net = self.conv_layer(net, [3, 3, 256, 512], name='12_conv')
        net = self.conv_layer(net, [1, 1, 512, 256], name='13_conv')
        net = self.conv_layer(net, [3, 3, 256, 512], name='14_conv')
        net = self.conv_layer(net, [1, 1, 512, 256], name='15_conv')
        net16 = self.conv_layer(net, [3, 3, 256, 512], name='16_conv')
        net = self.pooling_layer(net16, name='17_pool')

        net = self.conv_layer(net, [3, 3, 512, 1024], name='18_conv')
        net = self.conv_layer(net, [1, 1, 1024, 512], name='19_conv')
        net = self.conv_layer(net, [3, 3, 512, 1024], name='20_conv')
        net = self.conv_layer(net, [1, 1, 1024, 512], name='21_conv')
        net = self.conv_layer(net, [3, 3, 512, 1024], name='22_conv')

        net = self.conv_layer(net, [3, 3, 1024, 1024], name='23_conv')
        #
        net24 = self.conv_layer(net, [3, 3, 1024, 1024], name='24_conv')

        net = self.conv_layer(net16, [1, 1, 512, 64], name='26_conv')
        net = self.reorg(net)

        net = tf.concat([net, net24], 3)

        net = self.conv_layer(net, [3, 3, int(net.get_shape()[3]), 1024], name='29_conv')
        net = self.conv_layer(net, [1, 1, 1024, self.box_per_cell * (self.num_class + 5)], batch_norm=False,
                              name='30_conv')

        return net

        # 416,416,3

    def conv_layer(self, inputs, shape, batch_norm=True, name='0_conv'):
        weight = tf.Variable(tf.truncated_normal(shape, stddev=0.1), name='weight')
        biases = tf.Variable(tf.constant(0.1, shape=[shape[3]]), name='biases')

        conv = tf.nn.conv2d(inputs, weight, strides=[1, 1, 1, 1], padding='SAME', name=name)

        if batch_norm:
            depth = shape[3]
            scale = tf.Variable(tf.ones([depth, ], dtype='float32'), name='scale')
            shift = tf.Variable(tf.zeros([depth, ], dtype='float32'), name='shift')
            mean = tf.Variable(tf.ones([depth, ], dtype='float32'), name='rolling_mean')
            variance = tf.Variable(tf.ones([depth, ], dtype='float32'), name='rolling_variance')

            conv_bn = tf.nn.batch_normalization(conv, mean, variance, shift, scale, 1e-05)
            conv = tf.add(conv_bn, biases)
            # 返回最大值
            conv = tf.maximum(self.alpha * conv, conv)
        else:
            conv = tf.add(conv, biases)

        return conv

    def pooling_layer(self, inputs, name='1_pool'):
        pool = tf.nn.max_pool(inputs, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', name=name)
        return pool

    def reorg(self, inputs):
        outputs_1 = inputs[:, ::2, ::2, :]
        outputs_2 = inputs[:, ::2, 1::2, :]
        outputs_3 = inputs[:, 1::2, ::2, :]
        outputs_4 = inputs[:, 1::2, 1::2, :]
        output = tf.concat([outputs_1, outputs_2, outputs_3, outputs_4], axis=3)
        return output

    def loss_layer(self, predict, label):
        predict = tf.reshape(predict,
                             [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell, self.num_class + 5])
        box_coordinate = tf.reshape(predict[:, :, :, :, :4],
                                    [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell, 4])
        box_confidence = tf.reshape(predict[:, :, :, :, 4],
                                    [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell, 1])
        box_classes = tf.reshape(predict[:, :, :, :, 5:],
                                 [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell, self.num_class])

        boxes1 = tf.stack([(1.0 / (1.0 + tf.exp(-1.0 * box_coordinate[:, :, :, :, 0])) + self.offset) / self.cell_size,
                           (1.0 / (1.0 + tf.exp(-1.0 * box_coordinate[:, :, :, :, 1])) + tf.transpose(self.offset, (
                           0, 2, 1, 3))) / self.cell_size,
                           tf.sqrt(tf.exp(box_coordinate[:, :, :, :, 2]) * np.reshape(self.anchor[:5],
                                                                                      [1, 1, 1, 5]) / self.cell_size),
                           tf.sqrt(tf.exp(box_coordinate[:, :, :, :, 3]) * np.reshape(self.anchor[5:],
                                                                                      [1, 1, 1, 5]) / self.cell_size)])
        box_coor_trans = tf.transpose(boxes1, (1, 2, 3, 4, 0))
        box_confidence = 1.0 / (1.0 + tf.exp(-1.0 * box_confidence))
        box_classes = tf.nn.softmax(box_classes)

        response = tf.reshape(label[:, :, :, :, 0],
                              [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell])
        boxes = tf.reshape(label[:, :, :, :, 1:5],
                           [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell, 4])
        classes = tf.reshape(label[:, :, :, :, 5:],
                             [self.batch_size, self.cell_size, self.cell_size, self.box_per_cell, self.num_class])

        iou = self.calc_iou(box_coor_trans, boxes)
        best_box = tf.to_float(tf.equal(iou, tf.reduce_max(iou, axis=-1, keep_dims=True)))
        confs = tf.expand_dims(best_box * response, axis=4)

        conid = self.noobject_scale * (1.0 - confs) + self.object_scale * confs
        cooid = self.coordinate_scale * confs
        proid = self.class_scale * confs

        coo_loss = cooid * tf.square(box_coor_trans - boxes)
        con_loss = conid * tf.square(box_confidence - confs)
        pro_loss = proid * tf.square(box_classes - classes)

        loss = tf.concat([coo_loss, con_loss, pro_loss], axis=4)
        loss = tf.reduce_mean(tf.reduce_sum(loss, axis=[1, 2, 3, 4]), name='loss')

        return loss

    def calc_iou(self, boxes1, boxes2):
        boxx = tf.square(boxes1[:, :, :, :, 2:4])
        boxes1_square = boxx[:, :, :, :, 0] * boxx[:, :, :, :, 1]
        box = tf.stack([boxes1[:, :, :, :, 0] - boxx[:, :, :, :, 0] * 0.5,
                        boxes1[:, :, :, :, 1] - boxx[:, :, :, :, 1] * 0.5,
                        boxes1[:, :, :, :, 0] + boxx[:, :, :, :, 0] * 0.5,
                        boxes1[:, :, :, :, 1] + boxx[:, :, :, :, 1] * 0.5])
        boxes1 = tf.transpose(box, (1, 2, 3, 4, 0))

        boxx = tf.square(boxes2[:, :, :, :, 2:4])
        boxes2_square = boxx[:, :, :, :, 0] * boxx[:, :, :, :, 1]
        box = tf.stack([boxes2[:, :, :, :, 0] - boxx[:, :, :, :, 0] * 0.5,
                        boxes2[:, :, :, :, 1] - boxx[:, :, :, :, 1] * 0.5,
                        boxes2[:, :, :, :, 0] + boxx[:, :, :, :, 0] * 0.5,
                        boxes2[:, :, :, :, 1] + boxx[:, :, :, :, 1] * 0.5])
        boxes2 = tf.transpose(box, (1, 2, 3, 4, 0))

        left_up = tf.maximum(boxes1[:, :, :, :, :2], boxes2[:, :, :, :, :2])
        right_down = tf.minimum(boxes1[:, :, :, :, 2:], boxes2[:, :, :, :, 2:])

        intersection = tf.maximum(right_down - left_up, 0.0)
        inter_square = intersection[:, :, :, :, 0] * intersection[:, :, :, :, 1]
        union_square = boxes1_square + boxes2_square - inter_square

        return tf.clip_by_value(1.0 * inter_square / union_square, 0.0, 1.0)


yolo_v2()
joker_shy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
xml数据转换成txt格式
独酌浅醉的博客
07-30 856
import xml.etree.ElementTree as ET import pickle import os from os import listdir, getcwd from os.path import join import random from shutil import copyfile # 根据自己的数据标签修改 classes=["person"] def clear_hidden_files(path): dir_list = os.listdir(path) ...
YOLO+PaddleOCR实现车牌检测识别
wFitting的博客
05-02 7384
本篇文章将会使用Keras-YOLOV3来训练自己的车牌检测的模型，结合PaddleOCR来识别车牌，最终使用OpenCV将其整体进行串联。
YOLO基本用法
qq_42693842的博客
06-30 830
【代码】YOLO基本用法。
yolov5进阶之零环境快速创建及测试
buaaweibin的博客
06-19 609
yolov5 快速环境搭建
YOLOv5模型环境搭建及使用google colab训练
kuokay的博客
04-20 3750
环境搭建 环境 ubuntu 18.04 64bit GTX 1070Ti anaconda with python 3.8 pytorch 1.7.1 cuda 10.1 yolov5 5.0.9 为了方便使用 yolov5 目标检测，有网友已经将其做成了库，提交到了官方的索引库 pypi 上，这样，我们就可以直接使用 pip进行安装了，其项目地址: https://github.com/fcakyon/yolov5-pip 安装 首先创建一个干净的 python 虚拟环境 conda create
yolo6666666666666666
02-12
YOLO（You Only Look Once）是一种著名的实时目标检测系统，其设计目的是为了在保持高效率的同时，实现对图像中物体的快速和准确检测。YOLO系列算法自2016年首次提出以来，已经经历了多次迭代，从YOLOv1到YOLOv5，每...
yolo.cfg和yolo.weight
02-20
YOLO（You Only Look Once）是一种实时目标检测系统，它在计算机视觉领域有着广泛的应用，尤其是在自动驾驶、视频监控和图像分析等场景。标题中的"yolo.cfg"和"yolo.weight"是YOLO模型的核心组成部分。 `yolo.cfg`...
yolo-tracking实践资料
03-25
YOLO（You Only Look Once）是一种著名的实时目标检测系统，由Joseph Redmon等人在2016年提出。YOLO的主要优点在于其速度与准确性之间的平衡，使得它非常适合于实时应用，比如自动驾驶、视频监控等领域。YOLOv3和...
CCTSDB YOLO格式标注txt，附转换代码
03-31
在计算机视觉领域，YOLO（You Only Look Once）是一种广泛使用的实时目标检测系统。它以其高效和准确性赢得了研究人员和开发者的青睐。CCTSDB（可能是某个特定的数据集名称）提供了YOLO格式的标注文件，用于训练YOLO...
YOLO基础教程（四）：yolo v3 训练自己的数据集
小明同学
03-07 1万+
本代码开发环境：Keras+python+yolo3 yolo3 Keras 代码地址：https://github.com/qqwweee/keras-yolo3 （请先下载此文件） 论文地址：YOLO V1https://pjreddie.com/darknet/yolov1/ YOLO V2https://pjreddie.com/darknet/yolov2/ YOLO...
xyolo？几行Python代码轻松完成yolo3目标检测
笔墨留年。
11-06 3646
前段时间在 qqwweee/keras-yolo3 的基础上改写出了一个支持TensorFlow 2.2版本的yolo3项目，我把它命名为tf2-keras-yolo3。 怎么说呢，用是肯定能用的，但操作步骤太过繁琐和反人性化，自己用起来嫌麻烦，别人用起来上手也有一定难度，于是，我萌生了重构并打包它的想法。 于是，就有了xyolo~ xyolo可以通过pip一键安装，而且使用起来非常简单，只需要几行代码就可以训练自己的yolo3模型，或者调用训练好的模型进行目标检测。废话少说，一起来看一下吧！ GitHu
YOLOv3源码阅读之一：test_single_image.py
DaVinciL的博客
09-03 1523
一、YOLO简介   YOLO（You Only Look Once）是一个高效的目标检测算法，属于One-Stage大家族，针对于Two-Stage目标检测算法普遍存在的运算速度慢的缺点，YOLO创造性的提出了One-Stage。也就是将物体分类和物体定位在一个步骤中完成。YOLO直接在输出层回归bounding box的位置和bounding box所属类别，从而实现one-stage。   ...
【Keras+TensorFlow+Yolo3】教你如何识别影视剧模型
cungudafa的博客
06-19 3995
文章目录一、前言二、手识别1.下载项目框架2.标签分类3.训练4.测试三、总结 一、前言 前面一篇文章算是打通了【yolo3识别】的任督二脉， 【Yolo3】一文掌握图像标注、训练、识别（Keras+TensorFlow-gpu） 本文是对手语数据集训练的一个记录，算是keras-yolo3复现。 本次使用的数据集来自：牛津大学Arpit Mittal， Andrew Zisserman和 Phi...
YOLO多张图片预测代码
kaxiaokui的博客
12-22 1155
# #-------------------------------------# # 对单张图片进行预测 #-------------------------------------# # from yolo import YOLO # from PIL import Image # yolo = YOLO() # while True: # img = input('Input image filename:') # try: # image = Imag
YOLOV2-源代码详细解析（逐语句进行解释）
herr_kun的博客
11-17 9327
前言：一直以来想接触下图像检测和识别，但是苦于没有机会进行练手，最近终于腾出时间看看yolo，你可以从github上找到一大堆yolo的项目，但是你难道仅仅满足于调用作者封装好的接口进行调用么，或者你想训练自己数据集，仅仅是将分好的img和ａｎｎｏｔａｔｉｏｎ放到对应的文件夹就行了么？下面就拿一个ｇｉｔｈｕｂ上的一个yolo v2项目的源码进行解析，大多数的yolo代码大同小异，懂了一个其余的也便...
YOLOV1详解
yanxiaopan的博客
08-23 606
yolo入门之一----yolo的使用
热门推荐
一只小菜鸟的博客
09-29 1万+
主要参考了此链接，对此博主表示感谢~！！ https://blog.csdn.net/u012746060/article/details/81183006 但其中有一些不同之处，在这里从头到尾走一遍流程 二、快速使用 1、下载yolov3代码：https://github.com/qqwweee/keras-yolo3 ，并解压缩之后用pycharm打开。 2、下载权重：https://pjre...
深度学习笔记（四）---YOLO目标检测
一一
03-19 4665
以下笔记来源： [1] . Andrew Ng的卷积神经网络week3 [2] .【吴恩达课后编程作业】Course 4 - 卷积神经网络 - 第三周作业 （https://blog.csdn.net/u013733326/article/details/80341740#commentsedit） [3].yolo.h5文件问题的解决 -...
PEnet yolo
最新发布
05-25
PENet YOLO是一种基于深度学习的目标检测算法，它结合了两个经典的目标检测算法：PENet和YOLOv3。PENet是一种高效的轻量级网络结构，可以实现实时的目标检测，而YOLOv3则是一种非常流行的目标检测算法，具有准确率高...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值