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

From: @yonibaehr_admin
Reviewed-by: 
Signed-off-by:
pull/13361/MERGE
mindspore-ci-bot 4 years ago committed by Gitee
commit c69d72f840

@ -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)

@ -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:

@ -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}

@ -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 $@

@ -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

@ -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);

@ -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_

@ -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;

@ -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);
}

@ -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);
}

@ -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;
}

@ -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;
}

@ -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,

@ -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;

@ -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

@ -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

@ -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;

@ -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;

@ -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);

@ -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;

@ -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

Loading…
Cancel
Save