From fc127e14f84619d6625ffd1f1e9412cf566ddf1e Mon Sep 17 00:00:00 2001 From: GY-GitCode <165798068+GY-GitCode@users.noreply.github.com> Date: Tue, 21 May 2024 20:39:03 +0800 Subject: [PATCH] Add the autograd implementation of xceptionnet Add the autograd implementation of xceptionnet --- examples/cnn_ms/autograd/xceptionnet.py | 303 ++++++++++++++++++++++++ 1 file changed, 303 insertions(+) create mode 100644 examples/cnn_ms/autograd/xceptionnet.py diff --git a/examples/cnn_ms/autograd/xceptionnet.py b/examples/cnn_ms/autograd/xceptionnet.py new file mode 100644 index 000000000..8fb23d8cb --- /dev/null +++ b/examples/cnn_ms/autograd/xceptionnet.py @@ -0,0 +1,303 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================= + +from singa import autograd +from singa import tensor +from singa import device +from singa import layer +from singa import opt + +import numpy as np +from tqdm import trange + +# the code is modified from +# https://github.com/Cadene/pretrained-models.pytorch/blob/master/pretrainedmodels/models/xception.py + + +class Block(layer.Layer): + + def __init__(self, + in_filters, + out_filters, + reps, + strides=1, + padding=0, + start_with_relu=True, + grow_first=True): + super(Block, self).__init__() + + if out_filters != in_filters or strides != 1: + self.skip = layer.Conv2d(in_filters, + out_filters, + 1, + stride=strides, + padding=padding, + bias=False) + self.skipbn = layer.BatchNorm2d(out_filters) + else: + self.skip = None + + self.layers = [] + + filters = in_filters + if grow_first: + self.layers.append(layer.ReLU()) + self.layers.append( + layer.SeparableConv2d(in_filters, + out_filters, + 3, + stride=1, + padding=1, + bias=False)) + self.layers.append(layer.BatchNorm2d(out_filters)) + filters = out_filters + + for i in range(reps - 1): + self.layers.append(layer.ReLU()) + self.layers.append( + layer.SeparableConv2d(filters, + filters, + 3, + stride=1, + padding=1, + bias=False)) + self.layers.append(layer.BatchNorm2d(filters)) + + if not grow_first: + self.layers.append(layer.ReLU()) + self.layers.append( + layer.SeparableConv2d(in_filters, + out_filters, + 3, + stride=1, + padding=1, + bias=False)) + self.layers.append(layer.BatchNorm2d(out_filters)) + + if not start_with_relu: + self.layers = self.layers[1:] + else: + self.layers[0] = layer.ReLU() + + if strides != 1: + self.layers.append(layer.MaxPool2d(3, strides, padding + 1)) + + self.register_layers(*self.layers) + + self.add = layer.Add() + + def forward(self, x): + y = self.layers[0](x) + for layer in self.layers[1:]: + if isinstance(y, tuple): + y = y[0] + y = layer(y) + + if self.skip is not None: + skip = self.skip(x) + skip = self.skipbn(skip) + else: + skip = x + y = self.add(y, skip) + return y + + +__all__ = ['Xception'] + + +class Xception(layer.Layer): + """ + Xception optimized for the ImageNet dataset, as specified in + https://arxiv.org/pdf/1610.02357.pdf + """ + + def __init__(self, num_classes=1000): + """ Constructor + Args: + num_classes: number of classes + """ + super(Xception, self).__init__() + self.num_classes = num_classes + + self.conv1 = layer.Conv2d(3, 32, 3, 2, 0, bias=False) + self.bn1 = layer.BatchNorm2d(32) + self.relu1 = layer.ReLU() + + self.conv2 = layer.Conv2d(32, 64, 3, 1, 1, bias=False) + self.bn2 = layer.BatchNorm2d(64) + self.relu2 = layer.ReLU() + # do relu here + + self.block1 = Block(64, + 128, + 2, + 2, + padding=0, + start_with_relu=False, + grow_first=True) + self.block2 = Block(128, + 256, + 2, + 2, + padding=0, + start_with_relu=True, + grow_first=True) + self.block3 = Block(256, + 728, + 2, + 2, + padding=0, + start_with_relu=True, + grow_first=True) + + self.block4 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + self.block5 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + self.block6 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + self.block7 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + + self.block8 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + self.block9 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + self.block10 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + self.block11 = Block(728, + 728, + 3, + 1, + start_with_relu=True, + grow_first=True) + + self.block12 = Block(728, + 1024, + 2, + 2, + start_with_relu=True, + grow_first=False) + + self.conv3 = layer.SeparableConv2d(1024, 1536, 3, 1, 1) + self.bn3 = layer.BatchNorm2d(1536) + self.relu3 = layer.ReLU() + + # Relu Layer + self.conv4 = layer.SeparableConv2d(1536, 2048, 3, 1, 1) + self.bn4 = layer.BatchNorm2d(2048) + + self.relu4 = layer.ReLU() + self.globalpooling = layer.MaxPool2d(10, 1) + self.flatten = layer.Flatten() + self.fc = layer.Linear(2048, num_classes) + + def features(self, input): + x = self.conv1(input) + x = self.bn1(x) + x = self.relu1(x) + + x = self.conv2(x) + x = self.bn2(x) + x = self.relu2(x) + + x = self.block1(x) + x = self.block2(x) + x = self.block3(x) + x = self.block4(x) + x = self.block5(x) + x = self.block6(x) + x = self.block7(x) + x = self.block8(x) + x = self.block9(x) + x = self.block10(x) + x = self.block11(x) + x = self.block12(x) + + x = self.conv3(x) + x = self.bn3(x) + x = self.relu3(x) + + x = self.conv4(x) + x = self.bn4(x) + return x + + def logits(self, features): + x = self.relu4(features) + x = self.globalpooling(x) + x = self.flatten(x) + x = self.fc(x) + return x + + def forward(self, input): + x = self.features(input) + x = self.logits(x) + return x + + +if __name__ == '__main__': + model = Xception(num_classes=1000) + print('Start intialization............') + dev = device.create_cuda_gpu_on(0) + #dev = device.create_cuda_gpu() + + niters = 20 + batch_size = 16 + IMG_SIZE = 299 + sgd = opt.SGD(lr=0.1, momentum=0.9, weight_decay=1e-5) + + tx = tensor.Tensor((batch_size, 3, IMG_SIZE, IMG_SIZE), dev) + ty = tensor.Tensor((batch_size,), dev, tensor.int32) + autograd.training = True + x = np.random.randn(batch_size, 3, IMG_SIZE, IMG_SIZE).astype(np.float32) + y = np.random.randint(0, 1000, batch_size, dtype=np.int32) + tx.copy_from_numpy(x) + ty.copy_from_numpy(y) + + with trange(niters) as t: + for _ in t: + x = model(tx) + loss = autograd.softmax_cross_entropy(x, ty) + sgd(loss)