Darknet19详细原理（含tensorflow版源码）

Darknet19原理
Darknet19是一个轻量级的卷积神经网络，用于图像分类和检测任务。 它是YOLOv2目标检测算法的主干网络，它的优点在于具有较少的参数和计算量，在计算速度和精度之间取得了良好的平衡，同时在训练过程中也具有较高的准确率和收敛速度。

    Darknet19主要由卷积层、池化层和批量归一化层组成。根据名称可以看出，这些层是计算密集型的，且在网络的后端叠加了几个全连接层来输出预测，网络结构如下：

输入层：输入尺寸为224x224x3的图像。

    卷积层1：使用32个3x3的卷积核，步长为1，填充为2，激活函数为ReLU。

    池化层1：使用2x2的最大池化，步长为2，不进行填充。

    卷积层2：使用64个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    池化层2：使用2x2的最大池化，步长为2，不进行填充。

    卷积层3：使用128个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    卷积层4：使用64个1x1的卷积核，步长为1，填充为0，激活函数为ReLU。

    卷积层5：使用128个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    池化层3：使用2x2的最大池化，步长为2，不进行填充。

    卷积层6：使用256个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    卷积层7：使用128个1x1的卷积核，步长为1，填充为0，激活函数为ReLU。

    卷积层8：使用256个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    池化层4：使用2x2的最大池化，步长为2，不进行填充。

    卷积层9：使用512个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    卷积层10：使用256个1x1的卷积核，步长为1，填充为0，激活函数为ReLU。

    卷积层11：使用512个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    卷积层12：使用256个1x1的卷积核，步长为1，填充为0，激活函数为ReLU。

    卷积层13：使用512个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    池化层5：使用2x2的最大池化，步长为2，不进行填充。

    卷积层14：使用1024个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    卷积层15：使用512个1x1的卷积核，步长为1，填充为0，激活函数为ReLU。

    卷积层16：使用1024个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    卷积层17：使用512个1x1的卷积核，步长为1，填充为0，激活函数为ReLU。

    卷积层18：使用1024个3x3的卷积核，步长为1，填充为1，激活函数为ReLU。

    全连接层1：输出维度为1000，表示1000个类别。

    激活层1：使用softmax激活函数，将输出转换为概率分布。

    Darknet19中使用3 x 3的卷积核来减少参数数量，并使用1 x 1的卷积核来降低计算负担。同时，池化层和批量归一化层用于提高模型的稳定性和泛化能力。

    总体来说，Darknet19是一个简单而高效的卷积神经网络，它通过一系列精心设计的层来达到高精度和高效率深度学习目标，也能够在对计算资源受限的环境下进行高效的物体识别和分类任务。

Darknet19源码（tensorflow版）
数据集请自行下载

链接：https://pan.baidu.com/s/1LvyCBfIl_rWg20n-Q_aPrw#list/path=%2F
提取码：bwx0

如果没有GPU导致运行失败，就把device删除，使用默认CPU运行。

import os
import cv2
import numpy as np
import random
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from tensorflow.keras import layers,models,optimizers,losses
#开启GPU
device = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(device[0],True)


Data_dir = 'cat&dog'


def ReadLoad(Data_dir):
    images = []
    labels = []
    for i,class_name in enumerate(os.listdir(Data_dir)):
        sub_name = os.path.join(Data_dir,class_name)
        for img_name in os.listdir(sub_name):
            img = os.path.join(sub_name,img_name)
            img = cv2.imread(img) / 255.0
            img = cv2.resize(img,(256,256))
            b,g,r = cv2.split(img)
            img = cv2.merge([r,g,b])
            images.append(img)
            labels.append(i)
    return np.array(images),np.array(labels)

def ConvBnRelu(inputs,filters,kernels = 3):
    x = layers.Conv2D(filters,(kernels,kernels),padding='same')(inputs)
    x = layers.BatchNormalization()(x)
    x = layers.LeakyReLU(alpha=0.05)(x)
    return x

def DarkNet19(inputs):
    x = ConvBnRelu(inputs,32,3)
    x = layers.MaxPooling2D((2,2),strides=2)(x)

    x = ConvBnRelu(x, 64, 3)
    x = layers.MaxPooling2D((2, 2), strides=2)(x)

    x = ConvBnRelu(x, 128, 3)
    x = ConvBnRelu(x, 64, 1)
    x = ConvBnRelu(x, 128, 3)
    x = layers.MaxPooling2D((2, 2), strides=2)(x)

    x = ConvBnRelu(x, 256, 3)
    x = ConvBnRelu(x, 128, 1)
    x = ConvBnRelu(x, 256, 3)
    x = layers.MaxPooling2D((2, 2), strides=2)(x)

    x = ConvBnRelu(x, 512, 3)
    x = ConvBnRelu(x, 256, 1)
    x = ConvBnRelu(x, 512, 3)
    x = ConvBnRelu(x, 256, 1)
    x = ConvBnRelu(x, 512, 3)
    x = layers.MaxPooling2D((2, 2), strides=2)(x)

    x = ConvBnRelu(x, 1024, 3)
    x = ConvBnRelu(x, 512, 1)
    x = ConvBnRelu(x, 1024, 3)
    x = ConvBnRelu(x, 512, 1)
    x = ConvBnRelu(x, 1024, 3)

    x = ConvBnRelu(x,2,1)
    x = layers.GlobalAveragePooling2D()(x)
    x = layers.Activation('softmax')(x)
    return x



def main():
    images,labels = ReadLoad(Data_dir)

    train_x,test_x,train_y,test_y = train_test_split(images,labels,train_size=0.8)

    inputs = keras.Input((256,256,3))
    outputs = DarkNet19(inputs)
    model = models.Model(inputs,outputs)
    model.summary()
    model.compile(loss = losses.SparseCategoricalCrossentropy(),
                  optimizer=optimizers.Adam(1e-4),
                  metrics=['accuracy'])
    model.fit(train_x,train_y,epochs=10,batch_size=2)
    score = model.evaluate(test_x,test_y,batch_size=2)
    print('loss:',score[0])
    print('acc:',score[1])
    model.save('save',save_format='tf')
    del model

    new_model = keras.models.load_model('save')
    new_model.compile(loss = losses.SparseCategoricalCrossentropy(),
                      optimizer=optimizers.Adam(1e-4),
                      metrics=['accuracy'])
    score = new_model.evaluate(test_x, test_y,batch_size = 2)
    print('loss:', score[0])
    print('acc:', score[1])

    for i in range(9):
        r = random.randint(0,len(test_x) - 9)
        pre = tf.argmax(new_model(test_x[i + r:i + r + 1]),axis=1)[0]
        print(f"pre:{pre}---label:{test_y[i + r]}")
        plt.subplot(3,3,i + 1)
        if pre == test_y[r + i]:
            plt.imshow(test_x[r + i])
            plt.title('cat' if pre == test_y[r + i] else 'dog',c = 'black')
        else:
            plt.imshow(test_x[r + i])
            plt.title('cat' if pre == test_y[r + i] else 'dog', c='red')
        plt.axis('off')
        plt.savefig('mg.jpg')
    plt.show()
    pass


if __name__ == '__main__':
    main()

训练10个epoch的效果