深度残差网络+自适应参数化ReLU激活函数（调参记录21）Cifar10~95.12%

article/2025/7/22 10:13:10

本文在调参记录20的基础上，将残差模块的个数，从27个增加到60个，继续测试深度残差网络ResNet+自适应参数化ReLU激活函数在Cifar10数据集上的表现。

自适应参数化ReLU函数被放在了残差模块的第二个卷积层之后，这与Squeeze-and-Excitation Networks或者深度残差收缩网络是相似的。其基本原理如下
在这里插入图片描述
Keras程序如下：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 14 04:17:45 2020
Implemented using TensorFlow 1.10.0 and Keras 2.2.1Minghang Zhao, Shisheng Zhong, Xuyun Fu, Baoping Tang, Shaojiang Dong, Michael Pecht,
Deep Residual Networks with Adaptively Parametric Rectifier Linear Units for Fault Diagnosis, 
IEEE Transactions on Industrial Electronics, 2020,  DOI: 10.1109/TIE.2020.2972458 @author: Minghang Zhao
"""from __future__ import print_function
import keras
import numpy as np
from keras.datasets import cifar10
from keras.layers import Dense, Conv2D, BatchNormalization, Activation, Minimum
from keras.layers import AveragePooling2D, Input, GlobalAveragePooling2D, Concatenate, Reshape
from keras.regularizers import l2
from keras import backend as K
from keras.models import Model
from keras import optimizers
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import LearningRateScheduler
K.set_learning_phase(1)# The data, split between train and test sets
(x_train, y_train), (x_test, y_test) = cifar10.load_data()# Noised data
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_test = x_test-np.mean(x_train)
x_train = x_train-np.mean(x_train)
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)# Schedule the learning rate, multiply 0.1 every 150 epoches
def scheduler(epoch):if epoch % 150 == 0 and epoch != 0:lr = K.get_value(model.optimizer.lr)K.set_value(model.optimizer.lr, lr * 0.1)print("lr changed to {}".format(lr * 0.1))return K.get_value(model.optimizer.lr)# An adaptively parametric rectifier linear unit (APReLU)
def aprelu(inputs):# get the number of channelschannels = inputs.get_shape().as_list()[-1]# get a zero feature mapzeros_input = keras.layers.subtract([inputs, inputs])# get a feature map with only positive featurespos_input = Activation('relu')(inputs)# get a feature map with only negative featuresneg_input = Minimum()([inputs,zeros_input])# define a network to obtain the scaling coefficientsscales_p = GlobalAveragePooling2D()(pos_input)scales_n = GlobalAveragePooling2D()(neg_input)scales = Concatenate()([scales_n, scales_p])scales = Dense(channels//16, activation='linear', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(scales)scales = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(scales)scales = Activation('relu')(scales)scales = Dense(channels, activation='linear', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(scales)scales = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(scales)scales = Activation('sigmoid')(scales)scales = Reshape((1,1,channels))(scales)# apply a paramtetric reluneg_part = keras.layers.multiply([scales, neg_input])return keras.layers.add([pos_input, neg_part])# Residual Block
def residual_block(incoming, nb_blocks, out_channels, downsample=False,downsample_strides=2):residual = incomingin_channels = incoming.get_shape().as_list()[-1]for i in range(nb_blocks):identity = residualif not downsample:downsample_strides = 1residual = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(residual)residual = Activation('relu')(residual)residual = Conv2D(out_channels, 3, strides=(downsample_strides, downsample_strides), padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(residual)residual = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(residual)residual = Activation('relu')(residual)residual = Conv2D(out_channels, 3, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(residual)residual = aprelu(residual)# Downsamplingif downsample_strides > 1:identity = AveragePooling2D(pool_size=(1,1), strides=(2,2))(identity)# Zero_padding to match channelsif in_channels != out_channels:zeros_identity = keras.layers.subtract([identity, identity])identity = keras.layers.concatenate([identity, zeros_identity])in_channels = out_channelsresidual = keras.layers.add([residual, identity])return residual# define and train a model
inputs = Input(shape=(32, 32, 3))
net = Conv2D(16, 3, padding='same', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(inputs)
net = residual_block(net, 20, 32, downsample=False)
net = residual_block(net, 1, 32, downsample=True)
net = residual_block(net, 19, 32, downsample=False)
net = residual_block(net, 1, 64, downsample=True)
net = residual_block(net, 19, 64, downsample=False)
net = BatchNormalization(momentum=0.9, gamma_regularizer=l2(1e-4))(net)
net = Activation('relu')(net)
net = GlobalAveragePooling2D()(net)
outputs = Dense(10, activation='softmax', kernel_initializer='he_normal', kernel_regularizer=l2(1e-4))(net)
model = Model(inputs=inputs, outputs=outputs)
sgd = optimizers.SGD(lr=0.1, decay=0., momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])# data augmentation
datagen = ImageDataGenerator(# randomly rotate images in the range (deg 0 to 180)rotation_range=30,# Range for random zoomzoom_range = 0.2,# shear angle in counter-clockwise direction in degreesshear_range = 30,# randomly flip imageshorizontal_flip=True,# randomly shift images horizontallywidth_shift_range=0.125,# randomly shift images verticallyheight_shift_range=0.125)reduce_lr = LearningRateScheduler(scheduler)
# fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(x_train, y_train, batch_size=100),validation_data=(x_test, y_test), epochs=500, verbose=1, callbacks=[reduce_lr], workers=4)# get results
K.set_learning_phase(0)
DRSN_train_score = model.evaluate(x_train, y_train, batch_size=100, verbose=0)
print('Train loss:', DRSN_train_score[0])
print('Train accuracy:', DRSN_train_score[1])
DRSN_test_score = model.evaluate(x_test, y_test, batch_size=100, verbose=0)
print('Test loss:', DRSN_test_score[0])
print('Test accuracy:', DRSN_test_score[1])

实验结果如下：

Using TensorFlow backend.
x_train shape: (50000, 32, 32, 3)
50000 train samples
10000 test samples
Epoch 1/500
156s 312ms/step - loss: 3.7450 - acc: 0.4151 - val_loss: 3.1432 - val_acc: 0.5763
Epoch 2/500
113s 226ms/step - loss: 2.9954 - acc: 0.5750 - val_loss: 2.5940 - val_acc: 0.6689
Epoch 3/500
113s 226ms/step - loss: 2.5203 - acc: 0.6476 - val_loss: 2.1871 - val_acc: 0.7254
Epoch 4/500
113s 225ms/step - loss: 2.1855 - acc: 0.6865 - val_loss: 1.9171 - val_acc: 0.7488
Epoch 5/500
113s 225ms/step - loss: 1.9224 - acc: 0.7144 - val_loss: 1.6662 - val_acc: 0.7774
Epoch 6/500
113s 225ms/step - loss: 1.7111 - acc: 0.7331 - val_loss: 1.4882 - val_acc: 0.7915
Epoch 7/500
113s 226ms/step - loss: 1.5472 - acc: 0.7483 - val_loss: 1.3414 - val_acc: 0.7994
Epoch 8/500
113s 226ms/step - loss: 1.4095 - acc: 0.7633 - val_loss: 1.2149 - val_acc: 0.8194
Epoch 9/500
113s 226ms/step - loss: 1.3008 - acc: 0.7739 - val_loss: 1.1264 - val_acc: 0.8234
Epoch 10/500
113s 226ms/step - loss: 1.2077 - acc: 0.7824 - val_loss: 1.0474 - val_acc: 0.8322
Epoch 11/500
113s 225ms/step - loss: 1.1382 - acc: 0.7885 - val_loss: 0.9929 - val_acc: 0.8343
Epoch 12/500
113s 225ms/step - loss: 1.0722 - acc: 0.7955 - val_loss: 0.9418 - val_acc: 0.8400
Epoch 13/500
113s 225ms/step - loss: 1.0242 - acc: 0.8032 - val_loss: 0.9018 - val_acc: 0.8421
Epoch 14/500
113s 225ms/step - loss: 0.9843 - acc: 0.8083 - val_loss: 0.8639 - val_acc: 0.8506
Epoch 15/500
113s 225ms/step - loss: 0.9520 - acc: 0.8101 - val_loss: 0.8522 - val_acc: 0.8491
Epoch 16/500
113s 226ms/step - loss: 0.9313 - acc: 0.8130 - val_loss: 0.8124 - val_acc: 0.8541
Epoch 17/500
113s 226ms/step - loss: 0.9033 - acc: 0.8190 - val_loss: 0.8156 - val_acc: 0.8484
Epoch 18/500
113s 226ms/step - loss: 0.8791 - acc: 0.8223 - val_loss: 0.7796 - val_acc: 0.8572
Epoch 19/500
113s 226ms/step - loss: 0.8628 - acc: 0.8289 - val_loss: 0.7842 - val_acc: 0.8559
Epoch 20/500
113s 225ms/step - loss: 0.8528 - acc: 0.8292 - val_loss: 0.7725 - val_acc: 0.8533
Epoch 21/500
113s 225ms/step - loss: 0.8432 - acc: 0.8292 - val_loss: 0.7405 - val_acc: 0.8687
Epoch 22/500
113s 225ms/step - loss: 0.8260 - acc: 0.8347 - val_loss: 0.7425 - val_acc: 0.8648
Epoch 23/500
113s 225ms/step - loss: 0.8180 - acc: 0.8357 - val_loss: 0.7319 - val_acc: 0.8666
Epoch 24/500
113s 226ms/step - loss: 0.8146 - acc: 0.8385 - val_loss: 0.7158 - val_acc: 0.8761
Epoch 25/500
113s 226ms/step - loss: 0.8029 - acc: 0.8387 - val_loss: 0.7228 - val_acc: 0.8705
Epoch 26/500
113s 225ms/step - loss: 0.7968 - acc: 0.8425 - val_loss: 0.7160 - val_acc: 0.8725
Epoch 27/500
113s 225ms/step - loss: 0.7940 - acc: 0.8433 - val_loss: 0.7176 - val_acc: 0.8747
Epoch 28/500
113s 226ms/step - loss: 0.7904 - acc: 0.8439 - val_loss: 0.7080 - val_acc: 0.8747
Epoch 29/500
113s 225ms/step - loss: 0.7810 - acc: 0.8450 - val_loss: 0.7234 - val_acc: 0.8679
Epoch 30/500
113s 225ms/step - loss: 0.7807 - acc: 0.8457 - val_loss: 0.6999 - val_acc: 0.8754
Epoch 31/500
113s 225ms/step - loss: 0.7795 - acc: 0.8487 - val_loss: 0.7116 - val_acc: 0.8745
Epoch 32/500
113s 225ms/step - loss: 0.7722 - acc: 0.8497 - val_loss: 0.7064 - val_acc: 0.8798
Epoch 33/500
113s 226ms/step - loss: 0.7678 - acc: 0.8533 - val_loss: 0.7148 - val_acc: 0.8709
Epoch 34/500
113s 226ms/step - loss: 0.7634 - acc: 0.8528 - val_loss: 0.7095 - val_acc: 0.8741
Epoch 35/500
113s 225ms/step - loss: 0.7684 - acc: 0.8535 - val_loss: 0.7070 - val_acc: 0.8768
Epoch 36/500
113s 225ms/step - loss: 0.7630 - acc: 0.8540 - val_loss: 0.6935 - val_acc: 0.8804
Epoch 37/500
113s 225ms/step - loss: 0.7557 - acc: 0.8566 - val_loss: 0.6997 - val_acc: 0.8785
Epoch 38/500
113s 225ms/step - loss: 0.7518 - acc: 0.8591 - val_loss: 0.7090 - val_acc: 0.8771
Epoch 39/500
113s 225ms/step - loss: 0.7537 - acc: 0.8581 - val_loss: 0.6784 - val_acc: 0.8879
Epoch 40/500
113s 226ms/step - loss: 0.7537 - acc: 0.8566 - val_loss: 0.6778 - val_acc: 0.8854
Epoch 41/500
113s 226ms/step - loss: 0.7461 - acc: 0.8613 - val_loss: 0.6941 - val_acc: 0.8800
Epoch 42/500
113s 226ms/step - loss: 0.7518 - acc: 0.8586 - val_loss: 0.7230 - val_acc: 0.8731
Epoch 43/500
113s 225ms/step - loss: 0.7562 - acc: 0.8561 - val_loss: 0.6876 - val_acc: 0.8859
Epoch 44/500
113s 225ms/step - loss: 0.7398 - acc: 0.8626 - val_loss: 0.6793 - val_acc: 0.8861
Epoch 45/500
113s 225ms/step - loss: 0.7402 - acc: 0.8638 - val_loss: 0.6860 - val_acc: 0.8857
Epoch 46/500
113s 225ms/step - loss: 0.7430 - acc: 0.8626 - val_loss: 0.6878 - val_acc: 0.8857
Epoch 47/500
113s 225ms/step - loss: 0.7372 - acc: 0.8656 - val_loss: 0.6758 - val_acc: 0.8885
Epoch 48/500
113s 225ms/step - loss: 0.7364 - acc: 0.8649 - val_loss: 0.6837 - val_acc: 0.8849
Epoch 49/500
113s 226ms/step - loss: 0.7374 - acc: 0.8639 - val_loss: 0.6730 - val_acc: 0.8902
Epoch 50/500
113s 226ms/step - loss: 0.7389 - acc: 0.8657 - val_loss: 0.6848 - val_acc: 0.8868
Epoch 51/500
113s 227ms/step - loss: 0.7354 - acc: 0.8654 - val_loss: 0.6788 - val_acc: 0.8892
Epoch 52/500
113s 227ms/step - loss: 0.7286 - acc: 0.8691 - val_loss: 0.6942 - val_acc: 0.8800
Epoch 53/500
113s 225ms/step - loss: 0.7365 - acc: 0.8653 - val_loss: 0.6929 - val_acc: 0.8820
Epoch 54/500
113s 226ms/step - loss: 0.7295 - acc: 0.8685 - val_loss: 0.6761 - val_acc: 0.8892
Epoch 55/500
113s 226ms/step - loss: 0.7319 - acc:

http://chatgpt.dhexx.cn/article/UTc1XB0B.shtml

相关文章

已知两个长度分别为m 和 n 的升序链表，合并降序链表，求时间复杂度

已知两个长度分别为m 和 n 的升序链表，合并降序链表，求时间复杂度

王道数据结构上一道题： 之前我看到一个电子版的书，上边答案解析写的有点错误， 听说有些同学买的实体书上，答案解析也是这样写的 这个是刊印错误，很显然2Max( m , n )大于等于 m n 而且这个解析也不够清晰。 解析&a…
阅读更多...
波束形成 常见自适应波束形成算法信(干)噪比增益影响因素

波束形成 常见自适应波束形成算法信(干)噪比增益影响因素

0、其他补充 均匀线阵波束形成器的信噪比增益上确界可由下式表示： 其中为阵元数，所以为了方便起见，一般的稳健自适应波束形成算法在仿真过程中的阵元数量均设置为10。 阵列的导向矢量可由下式表示： 以首个阵元为参考阵元&#xff…
阅读更多...
两个升序链表合并成一个降序链表的时间复杂度

两个升序链表合并成一个降序链表的时间复杂度

王道考研P7 第六题 【2013年统考真题】已知两个长度分别为m和n的升序链表，若将它们合并为长度为mn的一个降序链表，则最坏情况下的时间复杂度是（） A. O(n) B. O(mn) C. O(min(m,n)) D. O(max(m,n)) 答案是D 注意，此题…
阅读更多...
无线传感器网络路由优化中的能量均衡LEACH改进算法

无线传感器网络路由优化中的能量均衡LEACH改进算法

文章目录 一、理论基础1、LEACH算法概述2、改进的LEACH算法 二、算法流程图三、仿真实验与分析四、参考文献 一、理论基础 1、LEACH算法概述 请参考这里。 2、改进的LEACH算法 改进的LEACH算法（LEACH-N）主要针对LEACH算法分簇阶段的缺陷而改进的&…
阅读更多...
机器学习之自适应增强(Adaboost)

机器学习之自适应增强(Adaboost)

1.Adaboost简介 **Adaptive boosting(自适应增强)是一种迭代算法，其核心思想是针对同一个训练集训练不同的弱分类器，然后把这些弱分类器集合起来，构成一个强分类器，Adaboost可处理分类和回归问题。了解Adaboost算法之前&#xff…
阅读更多...
自适应阈值（adaptiveThreshold）分割原理及实现

自适应阈值（adaptiveThreshold）分割原理及实现

背景介绍及原理 前面介绍了OTSU算法和最大熵算法，但这两种算法都属于全局阈值法，所以对于某些光照不均的图像，这种全局阈值分割的方法会显得苍白无力，如下图： 显然，这样的阈值处理结果不是我们想要的&…
阅读更多...
优化算法+神经网络：神经网络自动参数优化

优化算法+神经网络：神经网络自动参数优化

当智能群优化算法遇上神经网络 优化算法进行神经网络的参数寻优，解放深度调参1.已经实现的Genetic Algorithm优化Neural Network2.已经实现的PSO优化Neural Network3.已实现的SSA[^1]优化Neural Network 三种方法的可视化搜索过程对比三种优化算法性能总结总结目前来…
阅读更多...
Java stream().sorted()实现排序(升序、降序、多字段排序)

Java stream().sorted()实现排序(升序、降序、多字段排序)

1 自然排序 sorted()&#xff1a;自然排序&#xff0c;流中元素需实现Comparable接口 package com.entity;import lombok.*;Data ToString AllArgsConstructor NoArgsConstructor public class Student implements Comparable<Student> {private int id;private String …
阅读更多...
linux centos查找某个文件,Linux查找命令（文件、文件中的关键字）

linux centos查找某个文件,Linux查找命令（文件、文件中的关键字）

1、grep &#xff1a;查找文件中的内容 $ grep [option] pattern [file] 例&#xff1a; $ grep un day Sunday 例: $grep include doulinked.c doulinked1.c doulinked.c:#include doulinked.c:#include doulinked.c:#include doulinked1.c:#include doulinked1.c:#includ…
阅读更多...
Linux下查找\命令(收集整理）

Linux下查找\命令(收集整理）

以下为总结&#xff0c;其实可直接跳过&#xff0c;查看locate部分&#xff0c;这个是类似windows下verything搜索工具&#xff01; 一.Linux查找文件的相关命令 常 用 命 令 简要中文说明 程序所在目录 whereis 寻找文件工具 /usr/bin find 寻找文件工具 /usr/bin l…
阅读更多...
Linux查找命令 which和find命令

Linux查找命令 which和find命令

目录 前言一、which命令二、find命令 前言 一、which命令 格式&#xff1a; which [选项] 命令|程序名 #默认当找到第一个目标后不再继续查找选项说明-a查找全部内容&#xff0c;而非第一个文件-n<文件名长度> 　指定文件名长度&#xff0c;指定的长度必须大于或等于所有…
阅读更多...
Linux文件查找的4个命令

Linux文件查找的4个命令

1. find find 命令应该是最经典的命令了&#xff0c;谈到搜索工具第一个想到的肯定是 find 命令。但是&#xff0c;find 命令非常强大&#xff0c;想要把它的功能都介绍一遍&#xff0c;恐怕要写好几篇文章。 所以&#xff0c;这里介绍最基本的&#xff0c;根据文件名查找文件…
阅读更多...
Linux下的查找命令合集（which/whereis/locate/find）

Linux下的查找命令合集（which/whereis/locate/find）

Linux 下的查找命令有很多&#xff0c;常用的有which、whereis、locate、find。那么这4个命令之间各自有什么特点&#xff0c;又有什么区别&#xff0c;什么时候该用哪个才最合适呢&#xff1f;方便我们在开发和学习中能更加有效的使用。 1、which 该命令主要是用来查找系统P…
阅读更多...
【Linux命令】查找文件命令

【Linux命令】查找文件命令

文章目录 一、查找文件locateupdatedbfind测试条件操作符操作预定义操作自定义操作 find命令选项&#xff08;常用&#xff09; 一、查找文件 locate locate命令会查找其路径名数据库&#xff0c;输出所有包含查找字符串的匹配项&#xff1a; locate settings.xmlupdatedb …
阅读更多...
Linux常用查找命令

Linux常用查找命令

1、命令名称&#xff1a;which&#xff08;查看命令文件位置和命令可能出现的别名&#xff09; which 命令 2、whereis&#xff08;查找命令及帮助文档所在位置&#xff09; whereis 命令 3、locate&#xff08;按照文件名查找&#xff0c;按照数据库查找&#xff09; locate…
阅读更多...
【Linux学习笔记】8. Linux查找命令：find和grep详解

【Linux学习笔记】8. Linux查找命令：find和grep详解

Linux查找命令 find查找文件grep查找字符串 1. find命令 有多种使用方式&#xff1a; 根据文件名搜索根据文件大小搜索根据文件类型搜索根据修改时间搜索根据文件权限搜索根据文件所有者搜索 上面的各种方式可以利用逻辑与或非组合起来使用。 功能一&#xff1a;按文件名…
阅读更多...
linux查找命令,文件就这些which,whereis,locate,find,grep,|

linux查找命令,文件就这些which,whereis,locate,find,grep,|

linux生产中我们经常需要查看某个软件是否安装&#xff0c;某个文件在哪里等&#xff0c;某个命令是否存在等。 1. which 查看可执行文件的位置 which命令的作用是&#xff0c;在PATH变量指定的路径中&#xff0c;搜索某个系统命令的位置&#xff0c;并且返回第一个搜索结果…
阅读更多...
linux 查找命令

linux 查找命令

CentOS Linux学习笔记总结（八十六）-CentOS Linux系统的查找命令find find命令是用于在指定目录下查找文件，并可以对查找到的文件进行指定的操作。它的查找是从指定目录开始，并向下递归搜索它的所有各个子目录，查到后标准输出，并对其进行指定操作。 find语法： find [参…
阅读更多...
Linux下4个查找命令which、whereis、locate、find

Linux下4个查找命令which、whereis、locate、find

1.which 作用：从环境变量PATH中，定位、返回与指定名字相匹配的可执行文件所在的路径 原理：执行which命令时，which会在当前环境变量PATH中依次寻找能够匹配所找命令名字的可执行文件 适用场合：一般用于查找命令、可执行文件所在的路径 2.whereis 作用：定位、返回与指定名字…
阅读更多...
Linux 查找命令(find、locate 、grep )

Linux 查找命令(find、locate 、grep )

学习Linux系统的第五篇博客&#xff1a;学习如何查询文件。 一、find 命令 作用&#xff1a; 在指定范围内迅速查找到文件。 用法&#xff1a; find 路径 参数 文件名 例如&#xff1a; 查找自己账户下文件名为test.txt的文件 命令&#xff1a;find /home/ygt -name test.tx…
阅读更多...
推荐文章

Copyright @ 2022~2023