fix pix2pix

research/cv/Pix2Pix/README.md

@@ -49,7 +49,7 @@ C64-C128-C256-C512
 
 Dataset_1 used: [facades](http://efrosgans.eecs.berkeley.edu/pix2pix/datasets/facades.tar.gz)
 
-```markdown
+```text
     Dataset size: 29M, 606 images
                   400 train images
                   100 validation images
@@ -59,7 +59,7 @@ Dataset_1 used: [facades](http://efrosgans.eecs.berkeley.edu/pix2pix/datasets/fa
 
 Dataset_2 used: [maps](http://efrosgans.eecs.berkeley.edu/pix2pix/datasets/maps.tar.gz)
 
-```markdown
+```text
     Dataset size: 239M, 2194 images
                   1096 train images
                   1098 validation images
@@ -70,13 +70,13 @@ Dataset_2 used: [maps](http://efrosgans.eecs.berkeley.edu/pix2pix/datasets/maps.
 
 Download facades dataset
 
-```python
+```shell
 bash data/download_Pix2Pix_dataset.sh facades
 ```
 
 Download maps dataset
 
-```python
+```shell
 bash data/download_Pix2Pix_dataset.sh maps
 ```
 
@@ -101,7 +101,7 @@ bash data/download_Pix2Pix_dataset.sh maps
 
 The entire code structure is as following:
 
-```markdown
+```text
 .Pix2Pix
 ├─ README.md                           # descriptions about Pix2Pix
 ├─ data
@@ -109,10 +109,9 @@ The entire code structure is as following:
 ├── scripts
   └─run_infer_310.sh                   # launch ascend 310 inference
   └─run_distribute_train_ascend.sh     # launch ascend training(8 pcs)
-  └─run_eval_ascend.sh                 # launch ascend eval
+  └─run_eval.sh                        # launch evaluation
   └─run_train.sh                       # launch gpu/ascend training(1 pcs)
   └─run_distribute_train_gpu.sh        # launch gpu training(8 pcs)
-  └─run_eval_gpu.sh                    # launch gpu eval
   └─run_infer_onnx.sh                  # launch onnx infer
 ├─ imgs
   └─Pix2Pix-examples.jpg               # Pix2Pix Imgs
@@ -139,7 +138,6 @@ The entire code structure is as following:
 ├─ infer_onnx.py                       # Pix2Pix onnx inference
 ├─ train.py                            # train script
 ├─ requirements.txt                    # requirements file
-├─ export_onnx.py                      # export onnx script
 └─ export.py                           # export mindir and air script
 ```
 
@@ -147,7 +145,7 @@ The entire code structure is as following:
 
 Major parameters in train.py and config.py as follows:
 
-```python
+```text
 "device_target": Ascend                     # run platform, only support Ascend.
 "device_num": 1                             # device num, default is 1.
 "device_id": 0                              # device id, default is 0.
@@ -183,27 +181,27 @@ Major parameters in train.py and config.py as follows:
 
 - running on Ascend with default parameters
 
-```python
-python train.py --device_target [Ascend] --device_id [0]
+```shell
+python train.py --device_target=[Ascend] --device_id=[0]
 ```
 
 - running distributed trainning on Ascend with fixed parameters
 
-```python
+```shell
 bash scripts/run_distribute_train_ascend.sh [RANK_TABLE_FILE] [DATASET_PATH]
 ```
 
 - running on GPU with fixed parameters
 
-```python
-python train.py --device_target [GPU] --device_id [0]
-OR
+```shell
+python train.py --device_target=[GPU] --device_id=[0]
+# OR
 bash scripts/run_train.sh [DEVICE_TARGET] [DEVICE_ID]
 ```
 
 - running distributed trainning on GPU with fixed parameters
 
-```python
+```shell
 bash scripts/run_distribute_train_gpu.sh [DATASET_PATH] [DATASET_NAME]
 ```
 
@@ -211,25 +209,25 @@ bash scripts/run_distribute_train_gpu.sh [DATASET_PATH] [DATASET_NAME]
 
 - running on Ascend
 
-```python
-python eval.py --device_target [Ascend] --device_id [0] --val_data_dir [./data/facades/test] --ckpt [./results/ckpt/Generator_200.ckpt] --pad_mode REFLECT
-OR
-bash scripts/run_eval_ascend.sh [DATASET_PATH] [DATASET_NAME] [CKPT_PATH] [RESULT_DIR]
+```shell
+python eval.py --device_target=[Ascend] --device_id=[0] --val_data_dir=[./data/facades/test] --ckpt=[./results/ckpt/Generator_200.ckpt] --pad_mode=REFLECT
+# OR
+bash scripts/run_eval.sh [DEVICE_TARGET] [DEVICE_ID] [VAL_DATA_DIR] [CKPT_PATH]
 ```
 
 - running on GPU
 
-```python
-python eval.py --device_target [GPU] --device_id [0] --val_data_dir [./data/facades/test] --ckpt [./train/results/ckpt/Generator_200.ckpt]
-OR
-bash scripts/run_eval_gpu.sh [DATASET_PATH] [DATASET_NAME] [VAL_DATA_PATH] [CKPT_PATH]
+```shell
+python eval.py --device_target=[GPU] --device_id=[0] --val_data_dir=[./data/facades/test] --ckpt=[./train/results/ckpt/Generator_200.ckpt]
+# OR
+bash scripts/run_eval.sh [DEVICE_TARGET] [DEVICE_ID] [VAL_DATA_DIR] [CKPT_PATH]
 ```
 
 **Note:**: Before training and evaluating, create folders like "./results/...". Then you will get the results as following in "./results/predict".
 
 ## [310 infer](#contents)
 
-```python
+```shell
 bash scripts/run_infer_310.sh [The path of the MINDIR for 310 infer] [The path of the dataset for 310 infer] y Ascend 0
 ```
 
@@ -237,14 +235,14 @@ bash scripts/run_infer_310.sh [The path of the MINDIR for 310 infer] [The path o
 
 ## [Onnx export](#contents)
 
-```python
-python export_onnx.py --ckpt [/path/pix2pix.ckpt] --device_target [GPU] --device_id [0]
+```shell
+python export.py --ckpt=[/path/pix2pix.ckpt] --device_target=[GPU] --device_id=[0] --file_format=ONNX
 ```
 
 ## [Onnx infer](#contents)
 
-```python
-python infer_onnx.py --device_target [GPU] --device_id [0] --onnx_infer_data_dir [/path/data] --onnx_path [/path/pix2pix.onnx]
+```shell
+python infer_onnx.py --device_target=[GPU] --device_id=[0] --onnx_infer_data_dir=[/path/data] --onnx_path=[/path/pix2pix.onnx]
 OR
 bash scripts/run_infer_onnx.sh [DEVICE_TARGET] [DEVICE_ID] [ONNX_INFER_DATA_DIR] [ONNX_PATH]
 ```

research/cv/Pix2Pix/ascend310_infer/src/main.cc

@@ -28,8 +28,8 @@
 #include "include/api/context.h"
 #include "include/api/types.h"
 #include "include/api/serialization.h"
-#include "minddata/dataset/include/execute.h"
-#include "minddata/dataset/include/vision.h"
+#include "include/dataset/execute.h"
+#include "include/dataset/vision.h"
 #include "inc/utils.h"
 
 using mindspore::Context;

research/cv/Pix2Pix/default_config.yaml

@@ -16,7 +16,6 @@ need_modelarts_dataset_unzip: False
 run_distribute: False
 device_id: 0
 ckpt: None
-batch_size: 32
 
 # optimiter options
 workers: 24
@@ -82,7 +81,6 @@ workers: "Num parallel workers."
 lr: "Learning rate, default is 0.1."
 mode: "Run sink mode or not, default is sink."
 epoch_size: "Epoch size, default is 500."
-batch_size: "Batch size, default is 32."
 pre_trained: "Pretrained Checkpoint file path."
 pre_trained_epoch_size: "Pretrained epoch size."
 save_checkpoint_epochs: "Save checkpoint epochs, default is 1."
@@ -105,7 +103,6 @@ LAMBDA_GAN: "weight for GAN loss"
 LAMBDA_L1: "weight for L1 loss"
 beta1: "Adam beta1"
 beta2: "Adam beta2"
-lr: "initial learning rate"
 lr_policy: 'learning rate policy'
 epoch_num: "epoch number for training"
 n_epochs: "number of epochs with the initial learning rate"

research/cv/Pix2Pix/eval.py

@@ -19,13 +19,11 @@
 
 import os
 import mindspore as ms
-from mindspore import Tensor, nn
+from mindspore import Tensor
 from mindspore.train.serialization import load_checkpoint
-from mindspore.train.serialization import load_param_into_net
 from src.dataset.pix2pix_dataset import pix2pixDataset_val, create_val_dataset
-from src.models.pix2pix import Pix2Pix, get_generator, get_discriminator
-from src.models.loss import D_Loss, D_WithLossCell, G_Loss, G_WithLossCell, TrainOneStepCell
-from src.utils.tools import save_image, get_lr
+from src.models.pix2pix import get_generator
+from src.utils.tools import save_image
 from src.utils.config import config
 from src.utils.moxing_adapter import moxing_wrapper
 from src.utils.device_adapter import get_device_id
@@ -43,28 +41,9 @@ def pix2pix_eval():
     print("ds.shape:", ds_val.output_shapes())
 
     netG = get_generator()
-    netD = get_discriminator()
-
-    pix2pix = Pix2Pix(generator=netG, discriminator=netD)
-
-    d_loss_fn = D_Loss()
-    g_loss_fn = G_Loss()
-    d_loss_net = D_WithLossCell(backbone=pix2pix, loss_fn=d_loss_fn)
-    g_loss_net = G_WithLossCell(backbone=pix2pix, loss_fn=g_loss_fn)
-
-    d_opt = nn.Adam(pix2pix.netD.trainable_params(), learning_rate=get_lr(),
-                    beta1=config.beta1, beta2=config.beta2, loss_scale=1)
-    g_opt = nn.Adam(pix2pix.netG.trainable_params(), learning_rate=get_lr(),
-                    beta1=config.beta1, beta2=config.beta2, loss_scale=1)
-
-    train_net = TrainOneStepCell(loss_netD=d_loss_net, loss_netG=g_loss_net, optimizerD=d_opt, optimizerG=g_opt, sens=1)
-    train_net.set_train()
-
-    # Evaluating loop
-    ckpt_url = config.ckpt
-    print("CKPT:", ckpt_url)
-    param_G = load_checkpoint(ckpt_url)
-    load_param_into_net(netG, param_G)
+    netG.set_train()
+    print("CKPT:", config.ckpt)
+    load_checkpoint(config.ckpt, netG)
 
     if not os.path.isdir(config.predict_dir):
         os.makedirs(config.predict_dir)

research/cv/Pix2Pix/export.py

@@ -17,13 +17,10 @@
     export checkpoint file into air, onnx, mindir models
 """
 import numpy as np
-from mindspore import Tensor, nn, context
+from mindspore import Tensor, context
 from mindspore.train.serialization import export
 from mindspore.train.serialization import load_checkpoint
-from mindspore.train.serialization import load_param_into_net
-from src.models.pix2pix import Pix2Pix, get_generator, get_discriminator
-from src.models.loss import D_Loss, D_WithLossCell, G_Loss, G_WithLossCell, TrainOneStepCell
-from src.utils.tools import get_lr
+from src.models.pix2pix import get_generator
 from src.utils.config import config
 from src.utils.moxing_adapter import moxing_wrapper
 
@@ -33,33 +30,13 @@ def export_pix2pix():
     context.set_context(mode=context.GRAPH_MODE, device_target=config.device_target, device_id=config.device_id)
 
     netG = get_generator()
-    netD = get_discriminator()
-
-    pix2pix = Pix2Pix(generator=netG, discriminator=netD)
-
-    d_loss_fn = D_Loss()
-    g_loss_fn = G_Loss()
-    d_loss_net = D_WithLossCell(backbone=pix2pix, loss_fn=d_loss_fn)
-    g_loss_net = G_WithLossCell(backbone=pix2pix, loss_fn=g_loss_fn)
-
-    d_opt = nn.Adam(pix2pix.netD.trainable_params(), learning_rate=get_lr(), beta1=0.5, beta2=0.999, loss_scale=1)
-    g_opt = nn.Adam(pix2pix.netG.trainable_params(), learning_rate=get_lr(), beta1=0.5, beta2=0.999, loss_scale=1)
-
-    train_net = TrainOneStepCell(loss_netD=d_loss_net, loss_netG=g_loss_net, optimizerD=d_opt, optimizerG=g_opt, sens=1)
-    train_net.set_train()
-    train_net = train_net.loss_netG
-
-    ckpt_url = config.ckpt
-    param_G = load_checkpoint(ckpt_url)
-    load_param_into_net(netG, param_G)
+    netG.set_train()
+    print("CKPT:", config.ckpt)
+    load_checkpoint(config.ckpt, netG)
 
     input_shp = [config.batch_size, 3, config.image_size, config.image_size]
     input_array = Tensor(np.random.uniform(-1.0, 1.0, size=input_shp).astype(np.float32))
-    target_shp = [config.batch_size, 3, config.image_size, config.image_size]
-    target_array = Tensor(np.random.uniform(-1.0, 1.0, size=target_shp).astype(np.float32))
-    inputs = [input_array, target_array]
-    file = f"{config.file_name}"
-    export(train_net, *inputs, file_name=file, file_format=config.file_format)
+    export(netG, input_array, file_name=config.file_name, file_format=config.file_format)
 
 if __name__ == '__main__':
     export_pix2pix()

research/cv/Pix2Pix/export_onnx.py

-# Copyright 2022 Huawei Technologies Co., Ltd
-#
-# Licensed 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.
-# ============================================================================
-
-"""
-    export checkpoint file into onnx models
-"""
-import numpy as np
-from mindspore import Tensor, nn, context
-from mindspore.train.serialization import export
-from mindspore.train.serialization import load_checkpoint
-from mindspore.train.serialization import load_param_into_net
-from src.models.pix2pix import Pix2Pix, get_generator, get_discriminator
-from src.models.loss import D_Loss, D_WithLossCell, G_Loss, G_WithLossCell, TrainOneStepCell
-from src.utils.tools import get_lr
-from src.utils.config import config
-from src.utils.moxing_adapter import moxing_wrapper
-@moxing_wrapper()
-def export_pix2pix():
-    context.set_context(mode=context.GRAPH_MODE, device_target=config.device_target,
-                        device_id=config.device_id)
-    netG = get_generator()
-    netD = get_discriminator()
-    pix2pix = Pix2Pix(generator=netG, discriminator=netD)
-    d_loss_fn = D_Loss()
-    g_loss_fn = G_Loss()
-    d_loss_net = D_WithLossCell(backbone=pix2pix, loss_fn=d_loss_fn)
-    g_loss_net = G_WithLossCell(backbone=pix2pix, loss_fn=g_loss_fn)
-    d_opt = nn.Adam(pix2pix.netD.trainable_params(), learning_rate=get_lr(),
-                    beta1=config.beta1, beta2=config.beta2, loss_scale=1)
-    g_opt = nn.Adam(pix2pix.netG.trainable_params(), learning_rate=get_lr(),
-                    beta1=config.beta1, beta2=config.beta2, loss_scale=1)
-    train_net = TrainOneStepCell(loss_netD=d_loss_net, loss_netG=g_loss_net, optimizerD=d_opt, optimizerG=g_opt, sens=1)
-    train_net.set_train()
-    ckpt_url = config.ckpt
-    param_G = load_checkpoint(ckpt_url)
-    load_param_into_net(pix2pix, param_G)
-    input_shp = [1, 3, config.image_size, config.image_size]
-    input_array = Tensor(np.random.uniform(-1.0, 1.0, size=input_shp).astype(np.float32))
-    target_shp = [1, 3, config.image_size, config.image_size]
-    target_array = Tensor(np.random.uniform(-1.0, 1.0, size=target_shp).astype(np.float32))
-    inputs = [input_array, target_array]
-    file = f"{config.file_name}"
-    export(pix2pix, *inputs, file_name=file, file_format="ONNX")
-
-if __name__ == '__main__':
-    export_pix2pix()

research/cv/Pix2Pix/infer_onnx.py

@@ -53,8 +53,7 @@ def pix2pix_infer():
     print("=======Starting infer=======")
     for i, data in enumerate(data_loader_val):
         input_image = np.array(data["input_images"])
-        fake_image = onnx_session.run(None, {get_input_name(onnx_session)[0]: input_image,
-                                             get_input_name(onnx_session)[1]: None})
+        fake_image = onnx_session.run(None, {get_input_name(onnx_session)[0]: input_image})
         fake_image = Tensor(fake_image)[0]
         save_image(fake_image, config.onnx_infer_dir + str(i+1))
         print("=======image", i + 1, "saved success=======")

research/cv/Pix2Pix/postprocess.py

@@ -45,16 +45,16 @@ def decode_image(img):
     return (img * std + mean).astype(np.uint8).transpose((1, 2, 0))
 
 if __name__ == '__main__':
-    args = get_args()
-
     result_dir = "./result_Files"
     object_imageSize = 256
     rst_path = result_dir
-
+    out_dir = "310_infer_img"
+    if not os.ipath.isdir(out_dir):
+        os.makedirs(out_dir)
     for i in range(len(os.listdir(rst_path))):
         file_name = os.path.join(rst_path, "Pix2Pix_data_bs" + str(config.batch_size) + '_' + str(i) + '_0.bin')
         output = np.fromfile(file_name, np.float32).reshape(3, object_imageSize, object_imageSize)
         print(output.shape)
-        save_image(output, './310_infer_img' + str(i + 1))
+        save_image(output, os.path.join(out_dir, f"{i + 1}"))
         print("=======image", i + 1, "saved success=======")
     print("Generate images success!")

research/cv/Pix2Pix/preprocess.py

@@ -16,12 +16,10 @@
     preprocess
 """
 import os
-import numpy as np
 from src.dataset.pix2pix_dataset import pix2pixDataset_val, create_val_dataset
 from src.utils.config import config
 
 if __name__ == '__main__':
-    args = get_args()
     result_path = "./preprocess_Result/"
     dataset_val = pix2pixDataset_val(root_dir=config.val_data_dir)
     ds_val = create_val_dataset(dataset_val)
@@ -32,7 +30,5 @@ if __name__ == '__main__':
         file_name = "Pix2Pix_data_bs" + str(config.batch_size) + "_" + str(i) + ".bin"
         file_path = img_path + "/" + file_name
         data['input_images'].tofile(file_path)
-        target_images_list.append(data['target_images'])
 
-    np.save(result_path + "target_images_ids.npy", target_images_list)
     print("=" * 20, "export bin files finished", "=" * 20)

research/cv/Pix2Pix/scripts/run_distribute_train_ascend.sh

@@ -15,7 +15,7 @@
 
 if [ $# != 2 ]
 then
-    echo "Usage: sh run_distribute_train_ascend.sh [RANK_TABLE_FILE] [DATASET_PATH]"
+    echo "Usage: bash scripts/run_distribute_train_gpu.sh [DATASET_PATH] [DATASET_NAME]"
     exit 1
 fi
 
@@ -53,7 +53,7 @@ do
         echo "start training for rank $i, device $DEVICE_ID"
         env > env.log
 
-        python train.py --run_distribute 1 --device_target Ascend \
-                        --device_id=$DEVICE_ID --train_data_dir $DATASET_PATH &> log &
+        python train.py --run_distribute=1 --device_target=Ascend \
+                        --device_id=$DEVICE_ID --train_data_dir=$DATASET_PATH &> log &
         cd ..
 done

research/cv/Pix2Pix/scripts/run_distribute_train_gpu.sh

@@ -16,7 +16,7 @@
 
 if [ $# != 2 ]
 then
-    echo "Usage: bash run_distribute_train_gpu.sh [DATASET_PATH] [DATASET_NAME]"
+    echo "Usage: bash scripts/run_distribute_train_ascend.sh [RANK_TABLE_FILE] [DATASET_PATH]"
     exit 1
 fi
 
@@ -55,11 +55,18 @@ cd ./train_parallel || exit
 
 if [ $2 == 'facades' ];
 then
-    mpirun -n $DEVICE_NUM --output-filename log_output --merge-stderr-to-stdout --allow-run-as-root python train.py --device_target GPU \
-    --run_distribute 1 --dataset_size 400 --train_data_dir $PATH1 --pad_mode REFLECT &> log &
+    mpirun -n $DEVICE_NUM --output-filename log_output --merge-stderr-to-stdout --allow-run-as-root \
+    python train.py --device_target=GPU \
+                    --run_distribute=1 \
+                    --dataset_size=400 \
+                    --train_data_dir=$PATH1 \
+                    --pad_mode=REFLECT &> log &
 elif [ $2 == 'maps' ];
 then
     mpirun --allow-run-as-root -n $DEVICE_NUM --output-filename log_output --merge-stderr-to-stdout \
-    python train.py --device_target GPU --dataset_size 1096 \
-    --run_distribute 1 --train_data_dir $PATH1 --pad_mode REFLECT &> log &
+    python train.py --device_target=GPU \
+                    --dataset_size=1096 \
+                    --run_distribute=1 \
+                    --train_data_dir=$PATH1 \
+                    --pad_mode=REFLECT &> log &
 fi

research/cv/Pix2Pix/scripts/run_eval_gpu.sh → research/cv/Pix2Pix/scripts/run_eval.sh

@@ -21,7 +21,7 @@ echo "==========================================================================
 
 if [ $# != 4 ]
 then
-    echo "Usage: bash run_eval_gpu.sh [DEVICE_TARGET] [DEVICE_ID] [VAL_DATA_DIR] [CKPT_PATH]"
+    echo "Usage: bash scripts/run_eval.sh [DEVICE_TARGET] [DEVICE_ID] [VAL_DATA_DIR] [CKPT_PATH]"
     exit 1
 fi
 
@@ -41,5 +41,5 @@ then
     exit 1
 fi
 
-python eval.py --device_target GPU --device_id 0 --val_data_dir $PATH1 --ckpt $CKPT_PATH
+python eval.py --device_target=$1 --device_id=$2 --val_data_dir=$PATH1 --ckpt=$CKPT_PATH
 

research/cv/Pix2Pix/scripts/run_eval_ascend.sh

-#!/bin/bash
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
-#
-# Licensed 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.
-
-echo "======================================================================================================================================="
-echo "Please run the eval as: "
-echo "python eval.py device_target device_id val_data_dir ckpt"
-echo "for example: python eval.py --device_target Ascend --device_id 0 --val_data_dir ./facades/test --ckpt ./results/ckpt/Generator_200.ckpt"
-echo "======================================================================================================================================="
-
-if [ $# != 4 ]
-then
-    echo "Usage: bash run_eval_gpu.sh [DEVICE_TARGET] [DEVICE_ID] [VAL_DATA_DIR] [CKPT_PATH]"
-    exit 1
-fi
-
-get_real_path(){
-  if [ "${1:0:1}" == "/" ]; then
-    echo "$1"
-  else
-    echo "$(realpath -m $PWD/$3)"
-  fi
-}
-
-PATH1=$(get_real_path $3)
-CKPT_PATH=$(get_real_path $4)
-if [ ! -d $PATH1 ]
-then
-    echo "error: DATASET_PATH=$PATH1 is not a directory"
-    exit 1
-fi
-
-python eval.py --device_target Ascend --device_id 0 --val_data_dir $PATH1 --ckpt $CKPT_PATH
-
-

research/cv/Pix2Pix/scripts/run_infer_onnx.sh

@@ -35,4 +35,4 @@ then
     exit 1
 fi
 
-python infer_onnx.py --device_target GPU --device_id 0 --onnx_infer_data_dir $PATH1 --onnx_path $ONNX_PATH &> infer_onnx.log 2>&1 &
+python infer_onnx.py --device_target=$1 --device_id=$2 --onnx_infer_data_dir=$PATH1 --onnx_path=$ONNX_PATH &> infer_onnx.log 2>&1 &

research/cv/Pix2Pix/scripts/run_train.sh

@@ -38,4 +38,4 @@ cp -r ../src ./train
 cp -r ../*.yaml ./train
 cd ./train || exit
 
-python train.py --device_target $1 --device_id $2 &> log &
+python train.py --device_target=$1 --device_id=$2 &> log &