!13361 [MSLITE][TOD] ci tests for version 1.2

From: @yonibaehr_admin
Reviewed-by: 
Signed-off-by:

mindspore/lite/examples/export_models/models/lenet_train_export.py

@@ -25,7 +25,6 @@ from mindspore.train.serialization import export
 context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU", save_graphs=False)
 
 n = LeNet5()
-loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
 loss_fn = nn.MSELoss()
 optimizer = nn.Adam(n.trainable_params(), learning_rate=1e-2, beta1=0.5, beta2=0.7, eps=1e-2, use_locking=True,
                     use_nesterov=False, weight_decay=0.0, loss_scale=0.3)

mindspore/lite/examples/export_models/models/nin_train_export.py

@@ -25,14 +25,14 @@ from mindspore.train.serialization import export
 context.set_context(mode=context.PYNATIVE_MODE, device_target="GPU", save_graphs=False)
 
 n = NiN(num_classes=10)
-loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=False)
+loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 optimizer = nn.SGD(n.trainable_params(), learning_rate=0.01, momentum=0.9, dampening=0.0, weight_decay=5e-4,
                    nesterov=True, loss_scale=0.9)
 net = TrainWrap(n, loss_fn, optimizer)
 
 batch = 2
 x = Tensor(np.random.randn(batch, 3, 32, 32), mstype.float32)
-label = Tensor(np.zeros([batch, 10]).astype(np.float32))
+label = Tensor(np.zeros([batch]).astype(np.int32))
 export(net, x, label, file_name="mindir/nin_train", file_format='MINDIR')
 
 if len(sys.argv) > 1:

mindspore/lite/examples/export_models/prepare.sh

@@ -2,9 +2,10 @@
 
 display_usage()
 {
-  echo "Usage: prepare.sh [-d mindspore_docker] [-i]"
+  echo "Usage: prepare.sh [-d mindspore_docker] [-c model_config_file] [-i]"
   echo "Options:"
   echo "    -d docker where mindspore is installed. If no docker is provided script will use local python"
+  echo "    -c network configuration file. default is models_train.cfg"
   echo "    -i create input and output files"
 
 }
@@ -13,9 +14,13 @@ checkopts()
 {
   DOCKER=""
   TRAIN_IO=""
-  while getopts 'd:r:i' opt
+  CONFIG_FILE="models_train.cfg"
+  while getopts 'c:d:i' opt
   do
     case "${opt}" in
+      c)
+        CONFIG_FILE=$OPTARG
+        ;;
       d)
         DOCKER=$OPTARG
         ;;
@@ -78,7 +83,7 @@ while read line; do
     else
       export_result='export mindspore '${model_name}'_train_export failed';echo ${export_result} >> ${export_result_file}
     fi
-done < models_train.cfg
+done < ${CONFIG_FILE}
 
 Print_Result ${export_result_file}
 rm ${export_result_file}

mindspore/lite/examples/train_lenet/Makefile

@@ -1,7 +1,7 @@
 BASE_DIR=$(realpath ../../../../)
 APP:=bin/net_runner
-MSLIB:=mindspore-lite
-LMDLIB:=-lminddata-lite -ljpeg 
+LMSLIB:=-lmindspore-lite
+LMDLIB:=-lminddata-lite
 MSDIR:=$(realpath package-$(TARGET)/lib)
 ifneq ("$(wildcard $(MSDIR)/libhiai.so)","")
   LHIAILIB:=-lhiai_ir_build  -lhiai_ir -lhiai
@@ -23,17 +23,17 @@ ifeq ($(TARGET),arm64)
 CXX :=  ${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64/bin/clang++
 CFLAGS  += --target=aarch64-none-linux-android21 --gcc-toolchain=${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64 --sysroot=${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64/sysroot -fdata-sections -ffunction-sections 
 LDFLAGS := --target=aarch64-none-linux-android21 --gcc-toolchain=${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64 --sysroot=${ANDROID_NDK}/toolchains/llvm/prebuilt/linux-x86_64/sysroot -Wl,--gc-sections 
-LDFLAGS += -L$(MSDIR) -l$(MSLIB) $(LMDLIB) -pthread -llog -latomic -lm  $(LHIAILIB) -Wl,-rpath,$(MSDIR)
+LDFLAGS += -L$(MSDIR) $(LMSLIB) $(LMDLIB) -pthread -llog -latomic -lm  $(LHIAILIB) -Wl,-rpath,$(MSDIR)
 else
 CFLAGS += -g
-LDFLAGS := -L$(MSDIR) -l$(MSLIB) $(LMDLIB) -lpthread -Wl,-rpath,$(MSDIR)
+LDFLAGS := -L$(MSDIR) $(LMSLIB) $(LMDLIB) -lpthread -Wl,-rpath,$(MSDIR)
 endif  
 LD := ${CXX}
 
 
 all:$(APP)
 
-$(APP): $(OBJ) $(MSDIR)/lib$(MSLIB).so
+$(APP): $(OBJ)
 	@mkdir -p bin
 	$(LD) $(OBJ) $(LDFLAGS) -o $@
 

mindspore/lite/examples/train_lenet/scripts/train.sh

@@ -15,4 +15,4 @@
 # ============================================================================
 
 # an simple tutorial as follows, more parameters can be setting
-LD_LIBRARY_PATH=./lib/ bin/net_runner -f model/lenet_tod.ms -e 3 -d dataset
+LD_LIBRARY_PATH=./lib/ bin/net_runner -f model/lenet_tod.ms -e 5 -d dataset

mindspore/lite/examples/train_lenet/src/net_runner.cc

@@ -109,17 +109,22 @@ void NetRunner::InitAndFigureInputs() {
 
   auto inputs = session_->GetInputs();
   MS_ASSERT(inputs.size() > 1);
+  auto nhwc_input_dims = inputs.at(0)->shape();
+  MS_ASSERT(nhwc_input_dims.size() == 4);
+  batch_size_ = nhwc_input_dims.at(0);
+  h_ = nhwc_input_dims.at(1);
+  w_ = nhwc_input_dims.at(2);
 }
 
 float NetRunner::CalculateAccuracy(int max_tests) {
   test_ds_ = Mnist(data_dir_ + "/test", "all");
   TypeCast typecast_f("float32");
-  Resize resize({32, 32});
+  Resize resize({h_, w_});
   test_ds_ = test_ds_->Map({&resize, &typecast_f}, {"image"});
 
   TypeCast typecast("int32");
   test_ds_ = test_ds_->Map({&typecast}, {"label"});
-  test_ds_ = test_ds_->Batch(32, true);
+  test_ds_ = test_ds_->Batch(batch_size_, true);
 
   Rescaler rescale(255.0);
 
@@ -133,16 +138,14 @@ int NetRunner::InitDB() {
   train_ds_ = Mnist(data_dir_ + "/train", "all");
 
   TypeCast typecast_f("float32");
-  Resize resize({32, 32});
-  // Normalize rescale_op({0.0, 0.0, 0.0}, {255.0, 255.0, 255.0}); pending on Minddata operator
-  // Rescale rescale_op(255.0, 0.0);
+  Resize resize({h_, w_});
   train_ds_ = train_ds_->Map({&resize, &typecast_f}, {"image"});
 
   TypeCast typecast("int32");
   train_ds_ = train_ds_->Map({&typecast}, {"label"});
 
   train_ds_ = train_ds_->Shuffle(2);
-  train_ds_ = train_ds_->Batch(32, true);
+  train_ds_ = train_ds_->Batch(batch_size_, true);
 
   if (verbose_) {
     std::cout << "DatasetSize is " << train_ds_->GetDatasetSize() << std::endl;
@@ -156,8 +159,8 @@ int NetRunner::InitDB() {
 }
 
 int NetRunner::TrainLoop() {
-  struct mindspore::lite::StepLRLambda step_lr_lambda(1, 0.9);
-  mindspore::lite::LRScheduler step_lr_sched(mindspore::lite::StepLRLambda, static_cast<void *>(&step_lr_lambda), 100);
+  struct mindspore::lite::StepLRLambda step_lr_lambda(1, 0.8);
+  mindspore::lite::LRScheduler step_lr_sched(mindspore::lite::StepLRLambda, static_cast<void *>(&step_lr_lambda), 1);
 
   mindspore::lite::LossMonitor lm(100);
   mindspore::lite::ClassificationTrainAccuracyMonitor am(1);

mindspore/lite/examples/train_lenet/src/net_runner.h

@@ -59,6 +59,9 @@ class NetRunner {
   unsigned int epochs_ = 10;
   bool verbose_ = false;
   int save_checkpoint_ = 0;
+  int batch_size_ = 32;
+  int h_ = 32;
+  int w_ = 32;
 };
 
 #endif  // MINDSPORE_LITE_EXAMPLES_TRAIN_LENET_SRC_NET_RUNNER_H_

mindspore/lite/include/train_session.h

@@ -19,6 +19,7 @@
 #include <string>
 #include <tuple>
 #include "include/lite_session.h"
+#include "include/errorcode.h"
 
 namespace mindspore {
 namespace session {
@@ -135,7 +136,11 @@ class TrainSession : public session::LiteSession {
 
   /// \brief Set part of the name that identify a loss kernel
   /// \param[in] loss_name Identifucation name for loss kernels
-  void SetLossName(std::string loss_name) { loss_name_ = loss_name; }
+  /// \return STATUS as an error code of the set operation, STATUS is defined in errorcode.h
+  virtual int SetLossName(std::string loss_name) {
+    loss_name_ = loss_name;
+    return mindspore::lite::RET_OK;
+  }
 
  protected:
   bool train_mode_ = false;

mindspore/lite/java/java/common/src/main/java/com/mindspore/lite/TrainSession.java

@@ -150,6 +150,11 @@ public class TrainSession {
         return this.setupVirtualBatch(this.sessionPtr, virtualBatchMultiplier, -1.0f, -1.0f);
     }
 
+    public boolean setLossName(String lossName) {
+        return this.setLossName(this.sessionPtr,lossName);
+    }
+    
+    
     private native long createSession(String modelFilename, long msConfigPtr);
 
     private native void bindThread(long sessionPtr, boolean if_bind);
@@ -185,4 +190,6 @@ public class TrainSession {
     private native boolean setLearningRate(long sessionPtr, float learning_rate);
 
     private native boolean setupVirtualBatch(long sessionPtr, int virtualBatchMultiplier, float learningRate, float momentum);
+
+    private native boolean setLossName(long sessionPtr,String lossName);
 }

mindspore/lite/java/native/runtime/train_session.cpp

@@ -318,3 +318,16 @@ extern "C" JNIEXPORT jboolean JNICALL Java_com_mindspore_lite_TrainSession_setup
   auto ret = train_session_ptr->SetupVirtualBatch(virtualBatchMultiplier, learningRate, momentum);
   return (jboolean)(ret == mindspore::lite::RET_OK);
 }
+
+extern "C" JNIEXPORT jboolean JNICALL Java_com_mindspore_lite_TrainSession_setLossName(JNIEnv *env, jobject thiz,
+                                                                                       jlong session_ptr,
+                                                                                       jstring lossName) {
+  auto *session_pointer = reinterpret_cast<void *>(session_ptr);
+  if (session_pointer == nullptr) {
+    MS_LOGE("Session pointer from java is nullptr");
+    return (jboolean) false;
+  }
+  auto *train_session_ptr = static_cast<mindspore::session::TrainSession *>(session_pointer);
+  auto ret = train_session_ptr->SetLossName(JstringToChar(env, lossName));
+  return (jboolean)(ret == mindspore::lite::RET_OK);
+}

mindspore/lite/nnacl/infer/conv2d_grad_filter_infer.c

@@ -19,19 +19,23 @@
 
 int Conv2dGradFilterInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                                OpParameter *parameter) {
-  if (inputs_size < 2 || outputs_size != 1) {
+  if (inputs_size < 3 || outputs_size != 1) {
     return NNACL_ERR;
   }
   SetDataTypeFormat(outputs[0], inputs[0]);
 
-  size_t filter_shape_size_ = 4;
-  int filter_shape_[MAX_SHAPE_SIZE];
+  size_t filter_shape_size = inputs[2]->shape_[0];
+  if (filter_shape_size != 4) {
+    return NNACL_ERR;
+  }
+
+  int filter_shape[MAX_SHAPE_SIZE];
   const int nchw2nhwc[4] = {0, 2, 3, 1};
-  for (size_t i = 0; i < filter_shape_size_; i++) {
-    filter_shape_[i] = *((int *)(inputs[2]->data_) + nchw2nhwc[i]);
+  for (size_t i = 0; i < filter_shape_size; i++) {
+    filter_shape[i] = *((int *)(inputs[2]->data_) + nchw2nhwc[i]);
   }
 
-  SetShapeArray(outputs[0], filter_shape_, filter_shape_size_);
+  SetShapeArray(outputs[0], filter_shape, filter_shape_size);
   return NNACL_OK;
 }
 

mindspore/lite/nnacl/infer/conv2d_grad_input_infer.c

@@ -19,7 +19,7 @@
 
 int Conv2dGradInputInferShape(const TensorC *const *inputs, size_t inputs_size, TensorC **outputs, size_t outputs_size,
                               OpParameter *parameter) {
-  if (inputs_size < 2 || outputs_size != 1) {
+  if (inputs_size < 3 || outputs_size != 1) {
     return NNACL_ERR;
   }
   const TensorC *in0 = inputs[0];
@@ -30,13 +30,16 @@ int Conv2dGradInputInferShape(const TensorC *const *inputs, size_t inputs_size,
   }
   SetDataTypeFormat(out, in0);
 
-  size_t shape_size_ = in0->shape_size_;
-  int shape_[MAX_SHAPE_SIZE];
+  size_t shape_size = inputs[2]->shape_[0];
+  if (shape_size != 4) {
+    return NNACL_ERR;
+  }
+  int shape[MAX_SHAPE_SIZE];
   const int nchw2nhwc[4] = {0, 2, 3, 1};
-  for (int i = 0; i < shape_size_; i++) {
-    shape_[i] = *((int *)(inputs[2]->data_) + nchw2nhwc[i]);
+  for (int i = 0; i < shape_size; i++) {
+    shape[i] = *((int *)(inputs[2]->data_) + nchw2nhwc[i]);
   }
-  SetShapeArray(out, shape_, shape_size_);
+  SetShapeArray(out, shape, shape_size);
 
   return NNACL_OK;
 }

mindspore/lite/src/train/train_session.cc

@@ -148,7 +148,7 @@ int TrainSession::CompileTrainGraph(mindspore::lite::TrainModel *model) {
   }
   orig_output_node_map_ = output_node_map_;
   orig_output_tensor_map_ = output_tensor_map_;
-
+  orig_output_tensor_names_ = output_tensor_names_;
   for (auto inTensor : inputs_) inTensor->MutableData();
   RestoreOps(restore);
   CompileTrainKernels();      // Prepare a list of train kernels
@@ -246,7 +246,7 @@ int TrainSession::Train() {
   // set train outputs
   output_node_map_ = train_output_node_map_;
   output_tensor_map_ = train_output_tensor_map_;
-
+  output_tensor_names_ = train_output_tensor_names_;
   return RET_OK;
 }
 
@@ -265,12 +265,14 @@ int TrainSession::Eval() {
   // set eval outputs
   output_node_map_ = eval_output_node_map_;
   output_tensor_map_ = eval_output_tensor_map_;
+  output_tensor_names_ = eval_output_tensor_names_;
   return RET_OK;
 }
 
 void TrainSession::CompileEvalOutputs() {
   eval_output_node_map_.clear();
   eval_output_tensor_map_.clear();
+  eval_output_tensor_names_.clear();
   for (auto kernel : this->train_kernels_) {
     if (IsLossKernel(kernel) && !(IsGradKernel(kernel))) {
       for (auto in_kernel : kernel->in_kernels()) {
@@ -283,6 +285,11 @@ void TrainSession::CompileEvalOutputs() {
             auto index = TSFindTensor(tensors_, ms_tensor);
             if (index != tensors_.size()) {
               eval_output_tensor_map_.insert(std::make_pair(std::to_string(index), ms_tensor));
+              if (!ms_tensor->tensor_name().empty()) {
+                eval_output_tensor_names_.emplace_back(ms_tensor->tensor_name());
+              } else {
+                eval_output_tensor_names_.emplace_back(std::to_string(index));
+              }
             }
           }
         }
@@ -291,11 +298,13 @@ void TrainSession::CompileEvalOutputs() {
   }
   if (eval_output_node_map_.size() == 0) eval_output_node_map_ = orig_output_node_map_;
   if (eval_output_tensor_map_.size() == 0) eval_output_tensor_map_ = orig_output_tensor_map_;
+  if (eval_output_tensor_names_.size() == 0) eval_output_tensor_names_ = orig_output_tensor_names_;
 }
 
 void TrainSession::CompileTrainOutputs() {
   train_output_node_map_.clear();
   train_output_tensor_map_.clear();
+  train_output_tensor_names_.clear();
   for (auto kernel : this->train_kernels_) {
     if (orig_output_node_map_.find(kernel->name()) == orig_output_node_map_.end()) continue;
     // Mask out optimizer out tensors
@@ -308,12 +317,18 @@ void TrainSession::CompileTrainOutputs() {
         auto index = TSFindTensor(tensors_, ms_tensor);
         if (index != tensors_.size()) {
           train_output_tensor_map_.insert(std::make_pair(std::to_string(index), ms_tensor));
+          if (!ms_tensor->tensor_name().empty()) {
+            train_output_tensor_names_.emplace_back(ms_tensor->tensor_name());
+          } else {
+            train_output_tensor_names_.emplace_back(std::to_string(index));
+          }
         }
       }
     }
   }
   if (train_output_node_map_.size() == 0) train_output_node_map_ = orig_output_node_map_;
   if (train_output_tensor_map_.size() == 0) train_output_tensor_map_ = orig_output_tensor_map_;
+  if (train_output_tensor_names_.size() == 0) train_output_tensor_names_ = orig_output_tensor_names_;
 }
 
 void TrainSession::BuildInferenceKernelsRecursive(kernel::LiteKernel *kernel, std::vector<kernel::LiteKernel *> *v) {
@@ -340,6 +355,7 @@ void TrainSession::CompileTrainKernels() {
 }
 
 void TrainSession::CompileInferenceKernels() {
+  inference_kernels_.clear();
   for (auto item : eval_output_node_map_) {
     std::string kernel_name = item.first;
     auto kernel = TSFindKernel(train_kernels_, kernel_name);
@@ -351,17 +367,17 @@ void TrainSession::CompileInferenceKernels() {
 }
 
 void TrainSession::CompileOptimizedKernels() {
-  std::vector<lite::Tensor *> ot;
+  std::vector<lite::Tensor *> out_tensor;
   for (auto kernel : this->train_kernels_) {
     if (IsOptimizer(kernel)) {
-      std::copy(kernel->in_tensors().begin(), kernel->in_tensors().end(), std::back_inserter(ot));
+      std::copy(kernel->in_tensors().begin(), kernel->in_tensors().end(), std::back_inserter(out_tensor));
     }
   }
 
   for (auto kernel : this->train_kernels_) {
     if (!IsOptimizer(kernel)) {
       for (auto it : kernel->in_tensors()) {
-        if (std::find(ot.begin(), ot.end(), it) != ot.end()) {
+        if (std::find(out_tensor.begin(), out_tensor.end(), it) != out_tensor.end()) {
           kernel->set_trainable(true);
           break;
         }
@@ -394,7 +410,7 @@ float TrainSession::GetLearningRate() {
   return 0.0;
 }
 
-int TrainSession::SetupVirtualBatch(int virtual_batch_multiplier, float lr, float momentum) {
+int TrainSession::AdminSetupVirtualBatch(int virtual_batch_multiplier, float lr, float momentum) {
   auto mod = (virtual_batch_multiplier <= 1) ? kernel::OptimizerKernel::WeightUpdateMode::NORMAL
                                              : kernel::OptimizerKernel::WeightUpdateMode::VIRTUAL_BATCH;
   virtual_batch_multiplier_ = (virtual_batch_multiplier <= 1) ? 0 : virtual_batch_multiplier;
@@ -437,6 +453,13 @@ int TrainSession::SetupVirtualBatch(int virtual_batch_multiplier, float lr, floa
   }
   return RET_OK;
 }
+int TrainSession::SetupVirtualBatch(int virtual_batch_multiplier, float lr, float momentum) {
+  int tmp = (virtual_batch_multiplier <= 1) ? 0 : virtual_batch_multiplier;
+  if (tmp != 0 && virtual_batch_multiplier_ != 0) {
+    AdminSetupVirtualBatch(0, lr, momentum);
+  }
+  return AdminSetupVirtualBatch(virtual_batch_multiplier, lr, momentum);
+}
 
 int TrainSession::OptimizerStep() {
   for (auto kernel : this->train_kernels_) {
@@ -480,6 +503,17 @@ bool TrainSession::IsBN(kernel::LiteKernel *kernel) const {
           (kernel->Type() == schema::PrimitiveType_FusedBatchNorm));
 }
 
+int TrainSession::SetLossName(std::string loss_name) {
+  session::TrainSession::SetLossName(loss_name);
+  CompileEvalOutputs();
+  CompileInferenceKernels();
+  if (IsEval()) {
+    output_node_map_ = eval_output_node_map_;
+    output_tensor_map_ = eval_output_tensor_map_;
+    output_tensor_names_ = eval_output_tensor_names_;
+  }
+  return RET_OK;
+}
 }  // namespace lite
 
 session::TrainSession *session::TrainSession::CreateSession(const char *model_buf, size_t size, lite::Context *context,

mindspore/lite/src/train/train_session.h

@@ -62,6 +62,7 @@ class TrainSession : virtual public session::TrainSession, virtual public lite::
   int SetLearningRate(float learning_rate) override;
   float GetLearningRate() override;
   int SetupVirtualBatch(int virtual_batch_multiplier, float lr = -1.0f, float momentum = -1.0f) override;
+  int SetLossName(std::string loss_name) override;
 
   void BindThread(bool if_bind) override { return lite::LiteSession::BindThread(if_bind); }
   std::vector<tensor::MSTensor *> GetInputs() const override { return lite::LiteSession::GetInputs(); }
@@ -110,18 +111,22 @@ class TrainSession : virtual public session::TrainSession, virtual public lite::
   TrainModel *model_ = nullptr;
   std::unordered_map<std::string, std::vector<mindspore::tensor::MSTensor *>> orig_output_node_map_;
   std::unordered_map<std::string, mindspore::tensor::MSTensor *> orig_output_tensor_map_;
+  std::vector<std::string> orig_output_tensor_names_;
 
   std::unordered_map<std::string, std::vector<mindspore::tensor::MSTensor *>> eval_output_node_map_;
   std::unordered_map<std::string, mindspore::tensor::MSTensor *> eval_output_tensor_map_;
+  std::vector<std::string> eval_output_tensor_names_;
 
   std::unordered_map<std::string, std::vector<mindspore::tensor::MSTensor *>> train_output_node_map_;
   std::unordered_map<std::string, mindspore::tensor::MSTensor *> train_output_tensor_map_;
+  std::vector<std::string> train_output_tensor_names_;
 
   std::vector<kernel::LiteKernel *> inference_kernels_;
   std::vector<kernel::LiteKernel *> train_kernels_;
 
  private:
   void BuildInferenceKernelsRecursive(kernel::LiteKernel *ker, std::vector<kernel::LiteKernel *> *req_kernels);
+  int AdminSetupVirtualBatch(int virtual_batch_multiplier, float lr, float momentum);
   int OptimizerStep();
   int virtual_batch_idx_ = 0;
   int virtual_batch_multiplier_ = 0;

mindspore/lite/test/models_ms_train.cfg

@@ -1,22 +1,14 @@
-#
-mini_alexnet_r1.1
-mobilenetv1_r1.1
-mobilenetv2_r1.1
-lenet_r1.1
-effnet_r1.1
-effnet_tune_r1.1
-googlenet_r1.1
-# mini_alexnet
-# nin
-# lenet
-# mobilenetv1
-# mobilenetv2
-# mobilenetv3
-# effnet
-# resnet
-# effnet_tune
-# googlenet
-# densenet
-# shufflenetv2
-# xception
+mini_alexnet
+#nin
+lenet
+mobilenetv1
+mobilenetv2
+mobilenetv3
+effnet
+resnet
+effnet_tune
+googlenet
+densenet
+shufflenetv2
+#xception
 # LAST

mindspore/lite/test/run_net_export.sh

@@ -1,91 +0,0 @@
-#!/bin/bash
-
-# Print start msg after run testcase
-function MS_PRINT_TESTCASE_END_MSG() {
-    echo -e "-----------------------------------------------------------------------------------------------------------------------------------"
-}
-
-function Print_Result() {
-    MS_PRINT_TESTCASE_END_MSG
-    while read line; do
-        arr=("${line}")
-        printf "%-15s %-20s %-90s %-7s\n" ${arr[0]} ${arr[1]} ${arr[2]} ${arr[3]}
-    done < $1
-    MS_PRINT_TESTCASE_END_MSG
-}
-
-basepath=$(pwd)
-echo ${basepath}
-# Set models default config filepath
-models_mindspore_train_config=${basepath}/models_ms_train.cfg
-
-
-# Example:run_net_export.sh -m /home/emir/Work/TestingEnv/train_models 
-epoch_num=1
-while getopts "c:m:t:" opt; do
-    case ${opt} in
-        c)
-            models_mindspore_train_config=${OPTARG}
-            echo "models_mindspore_train_config is ${models_mindspore_train_config}"
-            ;;
-        m)
-            models_path=${OPTARG}"/models_train"
-            echo "models_path is ${OPTARG}"
-            ;;        
-        t)
-            epoch_num=${OPTARG}
-            echo "train epoch num is ${OPTARG}"
-            ;;                    
-        ?)
-            echo "unknown para"
-            exit 1;;
-    esac
-done
-
-
-logs_path=${basepath}/logs_train
-rm -rf ${logs_path}
-mkdir -p ${logs_path}
-
-docker_image=mindspore_build:210311
-#docker_image=mindspore/mindspore-gpu:1.1.1
-# Export models
-echo "Start Exporting models ..."
-# Set log files
-export_log_file=${logs_path}/export_log.txt
-echo ' ' > ${export_log_file}
-
-export_result_file=${logs_path}/export_result.txt
-echo ' ' > ${export_result_file}
-
-# Run export according to config file 
-cd $models_path || exit 1
-if [[ -z "${CLOUD_MODEL_ZOO}" ]]; then
-    echo "CLOUD_MODEL_ZOO is not defined - exiting export models"
-    exit 1
-fi  
-
-# Export mindspore train models:
-fail=0
-while read line; do
-    LFS=" " read -r -a line_array <<< ${line}
-    model_name=${line_array[0]}
-    if [[ $model_name == \#* ]]; then
-        continue
-    fi
-    echo ${model_name}'_train_export.py' >> "${export_log_file}"
-    rm -f ${models_path}/${model_name}_train.mindir
-    echo 'exporting' ${model_name}
-    echo 'docker run --user '"$(id -u):$(id -g)"' --env CLOUD_MODEL_ZOO=${CLOUD_MODEL_ZOO} -w $PWD --runtime=nvidia -v /home/$USER:/home/$USER -v /opt/share:/opt/share --privileged=true '${docker_image}' python '${models_path}'/'${model_name}'_train_export.py' >>  "${export_log_file}"
-    docker run --user "$(id -u):$(id -g)" --env CLOUD_MODEL_ZOO=${CLOUD_MODEL_ZOO} -w $PWD --runtime=nvidia -v /home/$USER:/home/$USER -v /opt/share:/opt/share --privileged=true "${docker_image}" python ${models_path}'/'${model_name}_train_export.py "${epoch_num}"
-    if [ $? = 0 ]; then
-        export_result='export mindspore '${model_name}'_train_export pass';echo ${export_result} >> ${export_result_file}
-    else
-        export_result='export mindspore '${model_name}'_train_export failed';echo ${export_result} >> ${export_result_file}
-        fail=1
-    fi
-done < ${models_mindspore_train_config}
-
-Print_Result ${export_result_file}
-exit $fail
- 

mindspore/lite/test/ut/nnacl/infer/conv2d_grad_filter_infer_test.cc

@@ -24,12 +24,18 @@ class Conv2dGradFilterInferTest : public mindspore::CommonTest {
 };
 
 TEST_F(Conv2dGradFilterInferTest, Conv2dGradFilterInferTest0) {
-  size_t inputs_size = 2;
+  size_t inputs_size = 3;
   std::vector<TensorC *> inputs(inputs_size, NULL);
-  inputs[0] = new TensorC;
+  for (size_t i = 0; i < inputs_size; i++) {
+    inputs[i] = new TensorC;
+  }
   inputs[0]->data_type_ = kNumberTypeInt32;
   inputs[0]->format_ = Format_NHWC;
-  inputs[1] = new TensorC;
+  inputs[0]->shape_size_ = 4;
+  inputs[2]->shape_size_ = 1;
+  inputs[2]->shape_[0] = 4;
+  std::vector<int> nchw_shape = {32, 3, 15, 15};
+  inputs[2]->data_ = static_cast<void *>(nchw_shape.data());
   std::vector<TensorC *> outputs(1, NULL);
   outputs[0] = new TensorC;
   ConvParameter *parameter = new ConvParameter;
@@ -37,9 +43,11 @@ TEST_F(Conv2dGradFilterInferTest, Conv2dGradFilterInferTest0) {
   int ret = Conv2dGradFilterInferShape((const TensorC **)inputs.data(), inputs.size(), outputs.data(), outputs.size(),
                                        reinterpret_cast<OpParameter *>(parameter));
   ASSERT_EQ(ret, NNACL_OK);
-  ASSERT_EQ(outputs[0]->shape_size_, 2);
-  ASSERT_EQ(outputs[0]->shape_[0], 3);
-  ASSERT_EQ(outputs[0]->shape_[1], 4);
+  ASSERT_EQ(outputs[0]->shape_size_, 4);
+  ASSERT_EQ(outputs[0]->shape_[0], 32);
+  ASSERT_EQ(outputs[0]->shape_[1], 15);
+  ASSERT_EQ(outputs[0]->shape_[2], 15);
+  ASSERT_EQ(outputs[0]->shape_[3], 3);
   ASSERT_EQ(outputs[0]->data_type_, kNumberTypeInt32);
   ASSERT_EQ(outputs[0]->format_, Format_NHWC);
   delete parameter;

mindspore/lite/test/ut/nnacl/infer/conv2d_grad_input_infer_test.cc

@@ -24,12 +24,18 @@ class Conv2dGradInputInferTest : public mindspore::CommonTest {
 };
 
 TEST_F(Conv2dGradInputInferTest, Conv2dGradInputInferTest0) {
-  size_t inputs_size = 2;
+  size_t inputs_size = 3;
   std::vector<TensorC *> inputs(inputs_size, NULL);
-  inputs[0] = new TensorC;
-  inputs[1] = new TensorC;
+  for (size_t i = 0; i < inputs_size; i++) {
+    inputs[i] = new TensorC;
+  }
   inputs[0]->data_type_ = kNumberTypeInt32;
   inputs[0]->format_ = Format_NHWC;
+  inputs[0]->shape_size_ = 4;
+  std::vector<int> nchw_shape = {32, 3, 15, 15};
+  inputs[2]->shape_size_ = 1;
+  inputs[2]->shape_[0] = 4;
+  inputs[2]->data_ = static_cast<void *>(nchw_shape.data());
   std::vector<TensorC *> outputs(1, NULL);
   outputs[0] = new TensorC;
   ConvParameter *parameter = new ConvParameter;
@@ -37,9 +43,11 @@ TEST_F(Conv2dGradInputInferTest, Conv2dGradInputInferTest0) {
   int ret = Conv2dGradInputInferShape((const TensorC **)inputs.data(), inputs.size(), outputs.data(), outputs.size(),
                                       reinterpret_cast<OpParameter *>(parameter));
   ASSERT_EQ(ret, NNACL_OK);
-  ASSERT_EQ(outputs[0]->shape_size_, 2);
-  ASSERT_EQ(outputs[0]->shape_[0], 4);
-  ASSERT_EQ(outputs[0]->shape_[1], 3);
+  ASSERT_EQ(outputs[0]->shape_size_, 4);
+  ASSERT_EQ(outputs[0]->shape_[0], 32);
+  ASSERT_EQ(outputs[0]->shape_[1], 15);
+  ASSERT_EQ(outputs[0]->shape_[2], 15);
+  ASSERT_EQ(outputs[0]->shape_[3], 3);
   ASSERT_EQ(outputs[0]->data_type_, kNumberTypeInt32);
   ASSERT_EQ(outputs[0]->format_, Format_NHWC);
   delete parameter;

mindspore/lite/test/ut/nnacl/infer/flatten_grad_infer_test.cc

@@ -24,15 +24,17 @@ class FlattenGradInferTest : public mindspore::CommonTest {
 };
 
 TEST_F(FlattenGradInferTest, FlattenGradInferTest0) {
-  size_t inputs_size = 1;
+  size_t inputs_size = 2;
   std::vector<TensorC *> inputs(inputs_size, NULL);
   inputs[0] = new TensorC;
-  inputs[0]->shape_size_ = 3;
-  inputs[0]->shape_[0] = 4;
-  inputs[0]->shape_[1] = 3;
-  inputs[0]->shape_[2] = 5;
+  inputs[1] = new TensorC;
   inputs[0]->data_type_ = kNumberTypeInt32;
   inputs[0]->format_ = Format_NHWC;
+  inputs[1]->shape_size_ = 1;
+  inputs[1]->shape_[0] = 2;
+  std::vector<int> nchw_shape = {32, 15};
+  inputs[1]->data_ = static_cast<void *>(nchw_shape.data());
+
   std::vector<TensorC *> outputs(1, NULL);
   outputs[0] = new TensorC;
   OpParameter *parameter = new OpParameter;
@@ -41,7 +43,7 @@ TEST_F(FlattenGradInferTest, FlattenGradInferTest0) {
                                   reinterpret_cast<OpParameter *>(parameter));
   ASSERT_EQ(ret, NNACL_OK);
   ASSERT_EQ(outputs[0]->shape_size_, 2);
-  ASSERT_EQ(outputs[0]->shape_[0], 4);
+  ASSERT_EQ(outputs[0]->shape_[0], 32);
   ASSERT_EQ(outputs[0]->shape_[1], 15);
   ASSERT_EQ(outputs[0]->data_type_, kNumberTypeInt32);
   ASSERT_EQ(outputs[0]->format_, Format_NHWC);

mindspore/lite/test/ut/nnacl/infer/group_conv2d_grad_input_infer_test.cc

@@ -30,6 +30,9 @@ TEST_F(GroupConv2dGradInputInferTest, GroupConv2dGradInputInferTest0) {
   inputs[1] = new TensorC;
   inputs[0]->data_type_ = kNumberTypeInt32;
   inputs[0]->format_ = Format_NHWC;
+  inputs[0]->shape_size_ = 2;
+  inputs[0]->shape_[0] = 4;
+  inputs[0]->shape_[1] = 3;
   std::vector<TensorC *> outputs(1, NULL);
   outputs[0] = new TensorC;
   ConvParameter *parameter = new ConvParameter;

mindspore/lite/test/ut/src/runtime/kernel/arm/fp32_grad/network_test.cc

@@ -32,6 +32,7 @@
 #include "src/kernel_registry.h"
 #include "src/runtime/kernel/arm/fp32_grad/convolution.h"
 
+using mindspore::lite::RET_OK;
 namespace mindspore {
 class NetworkTest : public mindspore::CommonTest {
  public:
@@ -554,4 +555,35 @@ TEST_F(NetworkTest, mobileface_net) {
   delete context;
 }
 
+TEST_F(NetworkTest, setname) {
+  std::string net = "./test_data/nets/lenet_train.ms";
+  lite::Context context;
+  context.device_list_[0].device_info_.cpu_device_info_.cpu_bind_mode_ = lite::NO_BIND;
+  context.thread_num_ = 1;
+  auto session = mindspore::session::TrainSession::CreateSession(net, &context);
+  ASSERT_NE(session, nullptr);
+
+  auto tensors_map = session->GetOutputs();
+  auto tensor_names = session->GetOutputTensorNames();
+  EXPECT_EQ(tensors_map.size(), 1);
+  EXPECT_EQ(tensors_map.begin()->first, "24");
+  EXPECT_EQ(tensor_names.size(), 1);
+  EXPECT_EQ(tensor_names.at(0), "Default/network-WithLossCell/_backbone-LeNet5/fc3-Dense/BiasAdd-op107");
+
+  auto res = session->SetLossName("nhwc");
+  EXPECT_EQ(res, RET_OK);
+  tensors_map = session->GetOutputs();
+  tensor_names = session->GetOutputTensorNames();
+  EXPECT_EQ(tensors_map.begin()->first, "8");
+  EXPECT_EQ(tensor_names.at(0), "Default/network-WithLossCell/_backbone-LeNet5/max_pool2d-MaxPool2d/MaxPool-op88");
+
+  res = session->SetLossName("loss");
+  EXPECT_EQ(res, RET_OK);
+  tensors_map = session->GetOutputs();
+  tensor_names = session->GetOutputTensorNames();
+  EXPECT_EQ(tensors_map.begin()->first, "24");
+  EXPECT_EQ(tensor_names.at(0), "Default/network-WithLossCell/_backbone-LeNet5/fc3-Dense/BiasAdd-op107");
+  delete session;
+}
+
 }  // namespace mindspore