Merge code into open source

This commit is contained in:
Eric_lai 2021-09-30 09:44:07 +08:00
parent d2fb51b8a9
commit c032d28a5c
3 changed files with 153 additions and 153 deletions

View File

@ -1,153 +1,153 @@
import os import os
os.environ['TL_BACKEND'] = 'tensorflow' os.environ['TL_BACKEND'] = 'tensorflow'
import time import time
import multiprocessing import multiprocessing
import tensorflow as tf import tensorflow as tf
from tensorlayer.models import TrainOneStep from tensorlayer.models import TrainOneStep
from tensorlayer.layers import Module from tensorlayer.layers import Module
import tensorlayer as tl import tensorlayer as tl
from torchsummary import summary from torchsummary import summary
from tensorlayer import logging from tensorlayer import logging
from tensorlayer.files import (assign_weights, maybe_download_and_extract) from tensorlayer.files import (assign_weights, maybe_download_and_extract)
from tensorlayer.layers import (BatchNorm, Conv2d, Dense, Elementwise, AdaptiveMeanPool2d, MaxPool2d , MeanPool2d,Concat,Dropout) from tensorlayer.layers import (BatchNorm, Conv2d, Dense, Elementwise, AdaptiveMeanPool2d, MaxPool2d , MeanPool2d,Concat,Dropout)
from tensorlayer.layers import Module, SequentialLayer from tensorlayer.layers import Module, SequentialLayer
class _DenseLayer(Module): class _DenseLayer(Module):
def __init__(self, in_channels, growth_rate, bn_size): def __init__(self, in_channels, growth_rate, bn_size):
super(_DenseLayer, self).__init__() super(_DenseLayer, self).__init__()
W_init = tl.initializers.truncated_normal(stddev=5e-2) W_init = tl.initializers.truncated_normal(stddev=5e-2)
W_init2 = tl.initializers.truncated_normal(stddev=0.04) W_init2 = tl.initializers.truncated_normal(stddev=0.04)
b_init2 = tl.initializers.constant(value=0.1) b_init2 = tl.initializers.constant(value=0.1)
self.layer_list = [] self.layer_list = []
self.layer_list.append(Conv2d(bn_size * growth_rate,(1,1),in_channels=in_channels,W_init=W_init)) self.layer_list.append(Conv2d(bn_size * growth_rate,(1,1),in_channels=in_channels,W_init=W_init))
self.layer_list.append(BatchNorm(num_features=bn_size * growth_rate,act='relu')) self.layer_list.append(BatchNorm(num_features=bn_size * growth_rate,act='relu'))
self.layer_list.append(Conv2d(growth_rate, (3, 3), in_channels=bn_size * growth_rate,W_init=W_init)) self.layer_list.append(Conv2d(growth_rate, (3, 3), in_channels=bn_size * growth_rate,W_init=W_init))
self.layer_list.append(BatchNorm(num_features=growth_rate, act='relu')) self.layer_list.append(BatchNorm(num_features=growth_rate, act='relu'))
self.dense_layer = SequentialLayer(self.layer_list) self.dense_layer = SequentialLayer(self.layer_list)
self.concat = Concat(1) self.concat = Concat(1)
# 重载forward函数 # 重载forward函数
def forward(self, x): def forward(self, x):
new_features = self.dense_layer(x) new_features = self.dense_layer(x)
return self.concat([x, new_features]) return self.concat([x, new_features])
class _DenseBlock(Module): class _DenseBlock(Module):
def __init__(self, num_layers, in_channels, bn_size, growth_rate): def __init__(self, num_layers, in_channels, bn_size, growth_rate):
super(_DenseBlock, self).__init__() super(_DenseBlock, self).__init__()
W_init = tl.initializers.truncated_normal(stddev=5e-2) W_init = tl.initializers.truncated_normal(stddev=5e-2)
W_init2 = tl.initializers.truncated_normal(stddev=0.04) W_init2 = tl.initializers.truncated_normal(stddev=0.04)
b_init2 = tl.initializers.constant(value=0.1) b_init2 = tl.initializers.constant(value=0.1)
self.layer_list = [] self.layer_list = []
for i in range(num_layers): for i in range(num_layers):
self.layer_list.append(_DenseLayer(in_channels + growth_rate * i,growth_rate, bn_size)) self.layer_list.append(_DenseLayer(in_channels + growth_rate * i,growth_rate, bn_size))
self.dense_block = SequentialLayer(self.layer_list) self.dense_block = SequentialLayer(self.layer_list)
# 重载forward函数 # 重载forward函数
def forward(self, x): def forward(self, x):
return self.dense_block(x) return self.dense_block(x)
class _Transition(Module): class _Transition(Module):
def __init__(self, in_channels, out_channels): def __init__(self, in_channels, out_channels):
super(_Transition, self).__init__() super(_Transition, self).__init__()
W_init = tl.initializers.truncated_normal(stddev=5e-2) W_init = tl.initializers.truncated_normal(stddev=5e-2)
W_init2 = tl.initializers.truncated_normal(stddev=0.04) W_init2 = tl.initializers.truncated_normal(stddev=0.04)
b_init2 = tl.initializers.constant(value=0.1) b_init2 = tl.initializers.constant(value=0.1)
self.layer_list = [] self.layer_list = []
self.layer_list.append(Conv2d(out_channels,(1,1),in_channels=in_channels,W_init=W_init)) self.layer_list.append(Conv2d(out_channels,(1,1),in_channels=in_channels,W_init=W_init))
self.layer_list.append(BatchNorm(num_features=out_channels,act='relu')) self.layer_list.append(BatchNorm(num_features=out_channels,act='relu'))
self.layer_list.append(MeanPool2d((2,2),strides=(2,2))) self.layer_list.append(MeanPool2d((2,2),strides=(2,2)))
self.transition_layer = SequentialLayer(self.layer_list) self.transition_layer = SequentialLayer(self.layer_list)
# 重载forward函数 # 重载forward函数
def forward(self, x): def forward(self, x):
return self.transition_layer(x) return self.transition_layer(x)
class DenseNet_BC(Module): class DenseNet_BC(Module):
def __init__(self, growth_rate=12, block_config=(6, 12, 24, 16), def __init__(self, growth_rate=12, block_config=(6, 12, 24, 16),
bn_size=4, theta=0.5, num_classes=10): bn_size=4, theta=0.5, num_classes=10):
super(DenseNet_BC, self).__init__() super(DenseNet_BC, self).__init__()
W_init = tl.initializers.truncated_normal(stddev=5e-2) W_init = tl.initializers.truncated_normal(stddev=5e-2)
W_init2 = tl.initializers.truncated_normal(stddev=0.04) W_init2 = tl.initializers.truncated_normal(stddev=0.04)
b_init2 = tl.initializers.constant(value=0.1) b_init2 = tl.initializers.constant(value=0.1)
# 初始的卷积为filter:2倍的growth_rate # 初始的卷积为filter:2倍的growth_rate
num_init_feature = 2 * growth_rate num_init_feature = 2 * growth_rate
self.layer_list = [] self.layer_list = []
# 表示cifar-10 # 表示cifar-10
if num_classes == 10: if num_classes == 10:
self.layer_list.append(Conv2d(num_init_feature,(3,3),strides=(1,1),in_channels=3,W_init=W_init)) self.layer_list.append(Conv2d(num_init_feature,(3,3),strides=(1,1),in_channels=3,W_init=W_init))
else: else:
self.layer_list.append(Conv2d(num_init_feature,(7,7),strides=(2,2),padding="valid",in_channels=3,W_init=W_init)) self.layer_list.append(Conv2d(num_init_feature,(7,7),strides=(2,2),padding="valid",in_channels=3,W_init=W_init))
self.layer_list.append(BatchNorm(num_features=num_init_feature,act='relu')) self.layer_list.append(BatchNorm(num_features=num_init_feature,act='relu'))
self.layer_list.append(MaxPool2d((3, 3), strides=(2, 2))) self.layer_list.append(MaxPool2d((3, 3), strides=(2, 2)))
num_feature = num_init_feature num_feature = num_init_feature
for i, num_layers in enumerate(block_config): for i, num_layers in enumerate(block_config):
self.layer_list.append( _DenseBlock(num_layers, num_feature,bn_size, growth_rate)) self.layer_list.append( _DenseBlock(num_layers, num_feature,bn_size, growth_rate))
num_feature = num_feature + growth_rate * num_layers num_feature = num_feature + growth_rate * num_layers
if i != len(block_config) - 1: if i != len(block_config) - 1:
self.layer_list.append(_Transition(num_feature,int(num_feature * theta))) self.layer_list.append(_Transition(num_feature,int(num_feature * theta)))
num_feature = int(num_feature * theta) num_feature = int(num_feature * theta)
self.layer_list.append(BatchNorm(num_features=num_feature,act='relu')) self.layer_list.append(BatchNorm(num_features=num_feature,act='relu'))
self.layer_list.append(AdaptiveMeanPool2d((1,1))) self.layer_list.append(AdaptiveMeanPool2d((1,1)))
self.features = SequentialLayer(self.layer_list) self.features = SequentialLayer(self.layer_list)
self.classifier = Dense(num_feature, num_classes,W_init=W_init2,b_init=b_init2) self.classifier = Dense(num_feature, num_classes,W_init=W_init2,b_init=b_init2)
def forward(self, x): def forward(self, x):
features = self.features(x) features = self.features(x)
out = features.view(features.size(0), -1) out = features.view(features.size(0), -1)
out = self.classifier(out) out = self.classifier(out)
return out return out
# DenseNet_BC for ImageNet # DenseNet_BC for ImageNet
def DenseNet121(): def DenseNet121():
return DenseNet_BC(growth_rate=32, block_config=(6, 12, 24, 16), num_classes=1000) return DenseNet_BC(growth_rate=32, block_config=(6, 12, 24, 16), num_classes=1000)
def DenseNet169(): def DenseNet169():
return DenseNet_BC(growth_rate=32, block_config=(6, 12, 32, 32), num_classes=1000) return DenseNet_BC(growth_rate=32, block_config=(6, 12, 32, 32), num_classes=1000)
def DenseNet201(): def DenseNet201():
return DenseNet_BC(growth_rate=32, block_config=(6, 12, 48, 32), num_classes=1000) return DenseNet_BC(growth_rate=32, block_config=(6, 12, 48, 32), num_classes=1000)
def DenseNet161(): def DenseNet161():
return DenseNet_BC(growth_rate=48, block_config=(6, 12, 36, 24), num_classes=1000, ) return DenseNet_BC(growth_rate=48, block_config=(6, 12, 36, 24), num_classes=1000, )
# DenseNet_BC for cifar # DenseNet_BC for cifar
def densenet_BC_100(): def densenet_BC_100():
return DenseNet_BC(growth_rate=12, block_config=(16, 16, 16)) return DenseNet_BC(growth_rate=12, block_config=(16, 16, 16))
def builddensenet(name = "densenet-100"): def builddensenet(name = "densenet-100"):
if name == "densenet-100": if name == "densenet-100":
return densenet_BC_100() return densenet_BC_100()
elif name == "densenet-121": elif name == "densenet-121":
return DenseNet121() return DenseNet121()
else: else:
print("not found the net") print("not found the net")
exit(0) exit(0)
def test(): def test():
net = densenet_BC_100() net = densenet_BC_100()
print(summary(net, input_size=(3, 32, 32))) print(summary(net, input_size=(3, 32, 32)))
#x = torch.randn(2, 3, 32, 32) #x = torch.randn(2, 3, 32, 32)
# y = net(x) # y = net(x)
# print(y.size()) # print(y.size())
if __name__ == '__main__': if __name__ == '__main__':
test() test()