Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
Browse Source

modify scripts for pylint

tags/v0.3.0-alpha
meixiaowei 5 years ago
parent
f1cec60dc8
commit
99bbb3a3b2
6 changed files with 37 additions and 42 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -3
      example/resnet101_imagenet/crossentropy.py
  2. +1
    -1
      example/resnet101_imagenet/dataset.py
  3. +2
    -3
      example/resnet101_imagenet/lr_generator.py
  4. +8
    -12
      example/resnet101_imagenet/train.py
  5. +22
    -21
      example/resnet101_imagenet/var_init.py
  6. +1
    -2
      mindspore/model_zoo/resnet.py

+ 3
- 3
example/resnet101_imagenet/crossentropy.py View File

@@ -12,15 +12,16 @@
# See the License for the specific language governing permissions and
# limitations under the License.
# ============================================================================
"""define loss function for network"""
from mindspore.nn.loss.loss import _Loss
from mindspore.ops import operations as P
from mindspore.ops import functional as F
from mindspore import Tensor
from mindspore.common import dtype as mstype
import mindspore.nn as nn
"""define loss function for network"""

class CrossEntropy(_Loss):
"""the redefined loss function with SoftmaxCrossEntropyWithLogits"""
def __init__(self, smooth_factor=0., num_classes=1001):
super(CrossEntropy, self).__init__()
self.onehot = P.OneHot()
@@ -28,7 +29,6 @@ class CrossEntropy(_Loss):
self.off_value = Tensor(1.0 * smooth_factor / (num_classes -1), mstype.float32)
self.ce = nn.SoftmaxCrossEntropyWithLogits()
self.mean = P.ReduceMean(False)
def construct(self, logit, label):
one_hot_label = self.onehot(label, F.shape(logit)[1], self.on_value, self.off_value)
loss = self.ce(logit, one_hot_label)


+ 1
- 1
example/resnet101_imagenet/dataset.py View File

@@ -57,7 +57,7 @@ def create_dataset(dataset_path, do_train, repeat_num=1, batch_size=32):
normalize_op = C.Normalize((0.475, 0.451, 0.392), (0.275, 0.267, 0.278))
changeswap_op = C.HWC2CHW()

trans=[]
trans = []
if do_train:
trans = [decode_op,
random_resize_crop_op,


+ 2
- 3
example/resnet101_imagenet/lr_generator.py View File

@@ -13,9 +13,8 @@
# limitations under the License.
# ============================================================================
"""learning rate generator"""
import numpy as np
import math
import numpy as np

def linear_warmup_lr(current_step, warmup_steps, base_lr, init_lr):
lr_inc = (float(base_lr) - float(init_lr)) / float(warmup_steps)
@@ -50,7 +49,7 @@ def warmup_cosine_annealing_lr(lr, steps_per_epoch, warmup_epochs, max_epoch):
decayed = linear_decay * cosine_decay + 0.00001
lr = base_lr * decayed
lr_each_step.append(lr)
return np.array(lr_each_step).astype(np.float32)
return np.array(lr_each_step).astype(np.float32)

def get_lr(global_step, lr_init, lr_end, lr_max, warmup_epochs, total_epochs, steps_per_epoch, lr_decay_mode):
"""


+ 8
- 12
example/resnet101_imagenet/train.py View File

@@ -14,11 +14,12 @@
# ============================================================================
"""train_imagenet."""
import os
import math
import argparse
import random
import numpy as np
from dataset import create_dataset
from lr_generator import get_lr
from lr_generator import get_lr, warmup_cosine_annealing_lr
from config import config
from mindspore import context
from mindspore import Tensor
@@ -33,7 +34,7 @@ from mindspore.communication.management import init
import mindspore.nn as nn
from crossentropy import CrossEntropy
from var_init import default_recurisive_init, KaimingNormal
from mindspore.common import initializer as weight_init
import mindspore.common.initializer as weight_init

random.seed(1)
np.random.seed(1)
@@ -69,23 +70,20 @@ if __name__ == '__main__':

epoch_size = config.epoch_size
net = resnet101(class_num=config.class_num)
# weight init
default_recurisive_init(net)
for name, cell in net.cells_and_names():
if isinstance(cell, nn.Conv2d):
cell.weight.default_input = weight_init.initializer(KaimingNormal(a=math.sqrt(5),
mode='fan_out', nonlinearity='relu'),
mode='fan_out', nonlinearity='relu'),
cell.weight.default_input.shape(),
cell.weight.default_input.dtype())
if not config.label_smooth:
config.label_smooth_factor = 0.0
loss = CrossEntropy(smooth_factor=config.label_smooth_factor, num_classes=config.class_num)

loss = CrossEntropy(smooth_factor=config.label_smooth_factor, num_classes=config.class_num)
if args_opt.do_train:
dataset = create_dataset(dataset_path=args_opt.dataset_path, do_train=True,
repeat_num=epoch_size, batch_size=config.batch_size)
repeat_num=epoch_size, batch_size=config.batch_size)
step_size = dataset.get_dataset_size()
loss_scale = FixedLossScaleManager(config.loss_scale, drop_overflow_update=False)

@@ -96,12 +94,10 @@ if __name__ == '__main__':
lr = Tensor(get_lr(global_step=0, lr_init=config.lr_init, lr_end=config.lr_end, lr_max=config.lr_max,
warmup_epochs=config.warmup_epochs, total_epochs=epoch_size, steps_per_epoch=step_size,
lr_decay_mode='poly'))
opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, config.momentum,
config.weight_decay, config.loss_scale)

model = Model(net, loss_fn=loss, optimizer=opt, amp_level='O2', keep_batchnorm_fp32=False, loss_scale_manager=loss_scale, metrics={'acc'})

model = Model(net, loss_fn=loss, optimizer=opt, amp_level='O2', keep_batchnorm_fp32=False,
loss_scale_manager=loss_scale, metrics={'acc'})
time_cb = TimeMonitor(data_size=step_size)
loss_cb = LossMonitor()
cb = [time_cb, loss_cb]


+ 22
- 21
example/resnet101_imagenet/var_init.py View File

@@ -18,12 +18,10 @@ import numpy as np
from mindspore.common import initializer as init
import mindspore.nn as nn
from mindspore import Tensor

def calculate_gain(nonlinearity, param=None):
r"""Return the recommended gain value for the given nonlinearity function.
The values are as follows:
The values are as follows:
================= ====================================================
nonlinearity gain
================= ====================================================
@@ -34,11 +32,9 @@ def calculate_gain(nonlinearity, param=None):
ReLU :math:`\sqrt{2}`
Leaky Relu :math:`\sqrt{\frac{2}{1 + \text{negative\_slope}^2}}`
================= ====================================================
Args:
nonlinearity: the non-linear function (`nn.functional` name)
param: optional parameter for the non-linear function
"""
linear_fns = ['linear', 'conv1d', 'conv2d', 'conv3d', 'conv_transpose1d', 'conv_transpose2d', 'conv_transpose3d']
if nonlinearity in linear_fns or nonlinearity == 'sigmoid':
@@ -57,17 +53,15 @@ def calculate_gain(nonlinearity, param=None):
raise ValueError("negative_slope {} not a valid number".format(param))
return math.sqrt(2.0 / (1 + negative_slope ** 2))
else:
raise ValueError("Unsupported nonlinearity {}".format(nonlinearity))
raise ValueError("Unsupported nonlinearity {}".format(nonlinearity))
def _calculate_correct_fan(array, mode):
mode = mode.lower()
valid_modes = ['fan_in', 'fan_out']
if mode not in valid_modes:
raise ValueError("Mode {} not supported, please use one of {}".format(mode, valid_modes))
raise ValueError("Mode {} not supported, please use one of {}".format(mode, valid_modes))
fan_in, fan_out = _calculate_fan_in_and_fan_out(array)
return fan_in if mode == 'fan_in' else fan_out
return fan_in if mode == 'fan_in' else fan_out

def kaiming_uniform_(array, a=0, mode='fan_in', nonlinearity='leaky_relu'):
r"""Fills the input `Tensor` with values according to the method
@@ -75,12 +69,10 @@ def kaiming_uniform_(array, a=0, mode='fan_in', nonlinearity='leaky_relu'):
performance on ImageNet classification` - He, K. et al. (2015), using a
uniform distribution. The resulting tensor will have values sampled from
:math:`\mathcal{U}(-\text{bound}, \text{bound})` where
.. math::
\text{bound} = \text{gain} \times \sqrt{\frac{3}{\text{fan\_mode}}}
Also known as He initialization.
Args:
array: an n-dimensional `tensor`
a: the negative slope of the rectifier used after this layer (only
@@ -91,8 +83,7 @@ def kaiming_uniform_(array, a=0, mode='fan_in', nonlinearity='leaky_relu'):
backwards pass.
nonlinearity: the non-linear function (`nn.functional` name),
recommended to use only with ``'relu'`` or ``'leaky_relu'`` (default).
"""
"""
fan = _calculate_correct_fan(array, mode)
gain = calculate_gain(nonlinearity, a)
std = gain / math.sqrt(fan)
@@ -129,6 +120,7 @@ def kaiming_normal_(array, a=0, mode='fan_in', nonlinearity='leaky_relu'):
return np.random.normal(0, std, array.shape)
def _calculate_fan_in_and_fan_out(array):
"""calculate the fan_in and fan_out for input array"""
dimensions = len(array.shape)
if dimensions < 2:
raise ValueError("Fan in and fan out can not be computed for array with fewer than 2 dimensions")
@@ -166,18 +158,27 @@ class KaimingNormal(init.Initializer):
init._assignment(arr, tmp)

def default_recurisive_init(custom_cell):
"""weight init for conv2d and dense"""
for name, cell in custom_cell.cells_and_names():
if isinstance(cell, nn.Conv2d):
cell.weight.default_input = init.initializer(KaimingUniform(a=math.sqrt(5)), cell.weight.default_input.shape(), cell.weight.default_input.dtype())
cell.weight.default_input = init.initializer(KaimingUniform(a=math.sqrt(5)),
cell.weight.default_input.shape(),
cell.weight.default_input.dtype())
if cell.bias is not None:
fan_in, _ = _calculate_fan_in_and_fan_out(cell.weight.default_input.asnumpy())
bound = 1 / math.sqrt(fan_in)
cell.bias.default_input = Tensor(np.random.uniform(-bound, bound, cell.bias.default_input.shape()), cell.bias.default_input.dtype())
cell.bias.default_input = Tensor(np.random.uniform(-bound, bound,
cell.bias.default_input.shape()),
cell.bias.default_input.dtype())
elif isinstance(cell, nn.Dense):
cell.weight.default_input = init.initializer(KaimingUniform(a=math.sqrt(5)), cell.weight.default_input.shape(), cell.weight.default_input.dtype())
cell.weight.default_input = init.initializer(KaimingUniform(a=math.sqrt(5)),
cell.weight.default_input.shape(),
cell.weight.default_input.dtype())
if cell.bias is not None:
fan_in, _ = _calculate_fan_in_and_fan_out(cell.weight.default_input.asnumpy())
bound = 1 / math.sqrt(fan_in)
cell.bias.default_input = Tensor(np.random.uniform(-bound, bound, cell.bias.default_input.shape()), cell.bias.default_input.dtype())
elif isinstance(cell, nn.BatchNorm2d) or isinstance(cell, nn.BatchNorm1d):
cell.bias.default_input = Tensor(np.random.uniform(-bound, bound,
cell.bias.default_input.shape()),
cell.bias.default_input.dtype())
elif isinstance(cell, (nn.BatchNorm2d, nn.BatchNorm1d)):
pass

+ 1
- 2
mindspore/model_zoo/resnet.py View File

@@ -279,5 +279,4 @@ def resnet101(class_num=1001):
[64, 256, 512, 1024],
[256, 512, 1024, 2048],
[1, 2, 2, 2],
class_num)
class_num)

Write Preview
Loading…
Cancel
Save