source activate base
conda create -n mindocr  --clone base
conda activate mindocr

python -c "import mindspore;mindspore.run_check()"

pip install lanms-neo

cd mindocr
pip install -e .

python tools/dataset_converters/convert.py \
        --dataset_name  totaltext \
        --task det \
        --image_dir ./data/ocr_datasets/totaltext/Images/Train/ \
        --label_dir ./data/ocr_datasets/totaltext/Txts/Train/ \
        --output_path ./data/ocr_datasets/totaltext/train_det_gt.txt

python tools/dataset_converters/convert.py \
        --dataset_name  totaltext \
        --task det \
        --image_dir ./data/ocr_datasets/totaltext/Images/Test \
        --label_dir ./data/ocr_datasets/totaltext/Txts/Test \
        --output_path ./data/ocr_datasets/totaltext/test_det_gt.txt

python tools/dataset_converters/convert.py \
        --dataset_name ctw1500 \
        --task det \
        --image_dir ./data/ocr_datasets/ctw1500/train_images/ \
        --label_dir ./data/ocr_datasets/ctw1500/ctw1500_train_labels/ \
        --output_path ./data/ocr_datasets/ctw1500/train_det_gt.txt

python tools/dataset_converters/convert.py \
        --dataset_name ctw1500 \
        --task det \
        --image_dir ./data/ocr_datasets/ctw1500/test_images/ \
        --label_dir ./data/ocr_datasets/ctw1500/gt_ctw1500/ \
        --output_path ./data/ocr_datasets/ctw1500/test_det_gt.txt

python tools/dataset_converters/convert.py \
        --dataset_name totaltext \
        --task det \
        --image_dir ./data/ocr_datasets/blendertext/images/Train/ \
        --label_dir ./data/ocr_datasets/blendertext/Txts/Train/ \
        --output_path ./data/ocr_datasets/blendertext/train_det_gt.txt

python tools/dataset_converters/convert.py \
        --dataset_name totaltext \
        --task det \
        --image_dir ./data/ocr_datasets/blendertext/images/Test \
        --label_dir ./data/ocr_datasets/blendertext/Txts/Test \
        --output_path ./data/ocr_datasets/blendertext/test_det_gt.txt

# train dbnet on totaltext dataset
python tools/train.py --config configs/det/dbnet/db_r18_totaltext.yaml

resume: True

python tools/train.py --config configs/det/dbnet/db_r18_totaltext.yaml

import matplotlib.pyplot as plt
 
data = [[], [], [], [], [], []]
epochs = 0
with open('result.log', 'r') as file:
    lines = file.readlines()
    epochs = len(lines) - 1
    for line in lines[1:]:
        for i in range(1, len(line.strip().split())):
            data[i-1].append(float(line.strip().split()[i]))
 
fig, axs = plt.subplots(nrows=2, ncols=3)
 
for i, ax in enumerate(axs.flat):
    ax.plot(range(1, epochs + 1), data[i])
    ax.set_xticks([0, epochs * 1 / 3, epochs * 2 / 3, epochs])
    ax.set_title(lines[0][:-1].split('\t')[i + 1])
    ax.set_xlabel('Epoch')
    ax.set_ylabel('')
 
plt.tight_layout()
 
plt.show()

gunzip -c openmpi-4.0.3.tar.gz | tar xf -
cd openmpi-4.0.3
./configure --prefix=/usr/local
<...lots of output...>
make all install

python tools/train.py --config configs/det/dbnet/db_r18_ctw1500.yaml

use_asf: True             # Adaptive Scale Fusion
channel_attention: True   # Use channel attention in ASF

nohup python tools/train.py --config configs/det/test_dbnet/db++_r18_totaltext.yaml > test_db++_r18_totaltext.log 2>&1 &

import matplotlib.pyplot as plt
 
data = [[], [], [], [], [], []]
epochs = 0
with open('result.log', 'r') as file:
    lines = file.readlines()
    epochs = len(lines) - 1
    for line in lines[1:]:
        for i in range(1, len(line.strip().split())):
            data[i-1].append(float(line.strip().split()[i]))
 
fig, axs = plt.subplots(nrows=2, ncols=3)
 
for i, ax in enumerate(axs.flat):
    ax.plot(range(1, epochs + 1), data[i])
    ax.set_xticks([0, epochs * 1 / 3, epochs * 2 / 3, epochs])
    ax.set_title(lines[0][:-1].split('\t')[i + 1])
    ax.set_xlabel('Epoch')
    ax.set_ylabel('')
 
plt.tight_layout()
 
plt.show()

def get_top_10(lst):
    # 使用 enumerate() 函数同时迭代列表中的值和索引
    enumerated_lst = list(enumerate(lst))
    
    # 对列表中的元素按值进行排序
    sorted_lst = sorted(enumerated_lst, key=lambda x: x[1], reverse=True)
    
    # 获取排序后的前10个元素及其序号
    top_10 = sorted_lst[:10]
    
    return top_10
 
# 调用函数获取最大的 10 个值及其序号
result = get_top_10(data[3])
 
# 输出结果
for index, value in result:
    print(f"epoch: {index + 1}, F-score: {value}")

nohup python tools/train.py --config configs/det/test_dbnet/db++_r18_ctw1500.yaml > test_db++_r18_ctw1500.log 2>&1 &

nohup python tools/train.py --config configs/det/dbnet/db_r50_totaltext.yaml > test_db_r50_totaltext.log 2>&1 &

nohup python tools/train.py --config configs/det/test_dbnet/db_r50_ctw1500.yaml > test_db_r50_ctw1500.log 2>&1 &

use_asf: True             # Adaptive Scale Fusion
channel_attention: True   # Use channel attention in ASF

system:
  mode: 0 # 0 for graph mode, 1 for pynative mode in MindSpore
  distribute: False
  amp_level: 'O0'
  seed: 42
  log_interval: 10
  val_while_train: True
  val_start_epoch: 800
  drop_overflow_update: False
 
model:
  type: det
  transform: null
  backbone:
    name: det_resnet50
    pretrained: False
  neck:
    name: DBFPN
    out_channels: 256
    bias: False
    use_asf: True             # Adaptive Scale Fusion
    channel_attention: True   # Use channel attention in ASF
  head:
    name: DBHead
    k: 50
    bias: False
    adaptive: True
  pretrained: https://download.mindspore.cn/toolkits/mindocr/dbnet/dbnet_resnet50_synthtext-40655acb.ckpt
 
postprocess:
  name: DBPostprocess
  box_type: quad   # whether to output a polygon or a box
  binary_thresh: 0.3      # binarization threshold
  box_thresh: 0.7         # box score threshold
  max_candidates: 1000
  expand_ratio: 1.5       # coefficient for expanding predictions
 
...
 
optimizer:
  opt: momentum
  filter_bias_and_bn: false
  momentum: 0.9
  weight_decay: 1.0e-4
 
...
 
train:
  ema: True
  ckpt_save_dir: './tmp_det_db++_r50_totaltext'
  dataset_sink_mode: True
  dataset:
    type: DetDataset
    dataset_root: ./data/ocr_datasets
    data_dir: totaltext/images/Train
    label_file: totaltext/train_det_gt.txt
 
...
 
eval:
  ckpt_load_path: tmp_det_db++_r50_totaltext/best.ckpt
  dataset_sink_mode: False
  dataset:
    type: DetDataset
    dataset_root: ./data/ocr_datasets
    data_dir: totaltext/images/Test
    label_file: totaltext/test_det_gt.txt
    sample_ratio: 1.0
 
...

RuntimeError: Single op compile failed, op: assign_3372008743488672465_0.

use_asf: True             # Adaptive Scale Fusion
channel_attention: True   # Use channel attention in ASF

nohup python tools/train.py --config configs/det/test_dbnet/db++_r50_totaltext.yaml > test_db++_r50_totaltext.log 2>&1 &

nohup python tools/train.py --config configs/det/test_dbnet/db++_r50_ctw1500.yaml > test_db++_r50_ctw1500.log 2>&1 &

python tools/infer/text/predict_det.py --image_dir ./data/ocr_datasets/ctw1500/train_images/0999.png \
                                       --det_algorithm DB  \
                                       --det_model_dir ./dbnet_resnet50_td500-0d12b5e8.ckpt  \
                                       --draw_img_save_dir ./inference_results/

python tools/infer/text/predict_det.py --image_dir ./data/ocr_datasets/ctw1500/train_images/0999.png \
                                       --det_algorithm DB  \
                                       --det_model_dir ./tmp_det_db_r50_totaltext/best.ckpt  \
                                       --draw_img_save_dir ./tmp_det_db_r50_totaltext/inference_results/

def create_parser():
    parser_config = argparse.ArgumentParser(description="Inference Config File", add_help=False)
    parser_config.add_argument(
        "-c", "--config", type=str, default="", help='YAML config file specifying default arguments (default="")'
    )
 
    parser = argparse.ArgumentParser(description="Inference Config Args")
    # params for prediction engine
    parser.add_argument("--mode", type=int, default=0, help="0 for graph mode, 1 for pynative mode ")  # added
    parser.add_argument("--det_model_config", type=str, help="path to det model yaml config")  # added
    parser.add_argument("--rec_model_config", type=str, help="path to rec model yaml config")  # added
 
    # params for text detector
    parser.add_argument("--image_dir", type=str, help="image path or image directory")
    # parser.add_argument("--page_num", type=int, default=0)
    parser.add_argument(
        "--det_algorithm",
        type=str,
        default="DB++",
        choices=["DB", "DB++", "DB_MV3", "PSE"],
        help="detection algorithm.",
    )  # determine the network architecture
    parser.add_argument(
        "--det_amp_level",
        type=str,
        default="O0",
        choices=["O0", "O1", "O2", "O3"],
        help="Auto Mixed Precision level. This setting only works on GPU and Ascend",
    )  # added
    parser.add_argument(
        "--det_model_dir",
        type=str,
        default=None,
        help="directory containing the detection model checkpoint best.ckpt, or path to a specific checkpoint file.",
    )  # determine the network weights
    parser.add_argument(
        "--det_limit_side_len", type=int, default=960, help="side length limitation for image resizing"
    )  # increase if need
    parser.add_argument(
        "--det_limit_type",
        type=str,
        default="max",
        choices=["min", "max"],
        help="limitation type for image resize. If min, images will be resized by limiting the minimum side length "
        "to `limit_side_len` (prior to accuracy). If max, images will be resized by limiting the maximum side "
        "length to `limit_side_len` (prior to speed). Default: max",
    )
    parser.add_argument(
        "--det_box_type",
        type=str,
        default="quad",
        choices=["quad", "poly"],
        help="box type for text region representation",
    )
 
    # DB parmas
    parser.add_argument("--det_db_thresh", type=float, default=0.3)
    parser.add_argument("--det_db_box_thresh", type=float, default=0.6)
    parser.add_argument("--det_db_unclip_ratio", type=float, default=1.5)
    parser.add_argument("--max_batch_size", type=int, default=10)
    parser.add_argument("--use_dilation", type=str2bool, default=False)
    parser.add_argument("--det_db_score_mode", type=str, default="fast")
 
    # params for text recognizer
    parser.add_argument(
        "--rec_algorithm",
        type=str,
        default="CRNN",
        choices=["CRNN", "RARE", "CRNN_CH", "RARE_CH", "SVTR"],
        help="recognition algorithm",
    )
    parser.add_argument(
        "--rec_amp_level",
        type=str,
        default="O0",
        choices=["O0", "O1", "O2", "O3"],
        help="Auto Mixed Precision level. This setting only works on GPU and Ascend",
    )  # added
    parser.add_argument(
        "--rec_model_dir",
        type=str,
        help="directory containing the recognition model checkpoint best.ckpt, or path to a specific checkpoint file.",
    )  # determine the network weights
    # parser.add_argument("--rec_image_inverse", type=str2bool, default=True)
    parser.add_argument(
        "--rec_image_shape",
        type=str,
        default="3, 32, 320",
        help="C, H, W for target image shape. max_wh_ratio=W/H will be used to control the maximum width after "
        '"aspect-ratio-kept" resizing. Set W larger for longer text.',
    )
 
    parser.add_argument(
        "--rec_batch_mode",
        type=str2bool,
        default=True,
        help="Whether to run recognition inference in batch-mode, which is faster but may degrade the accuracy "
        "due to padding or resizing to the same shape.",
    )  # added
    parser.add_argument("--rec_batch_num", type=int, default=8)
    parser.add_argument("--max_text_length", type=int, default=25)
    parser.add_argument(
        "--rec_char_dict_path",
        type=str,
        default=None,
        help="path to character dictionary. If None, will pick according to rec_algorithm and red_model_dir.",
    )
    # uncomment it after model trained supporting space recognition.
    # parser.add_argument("--use_space_char", type=str2bool, default=True)
    parser.add_argument("--vis_font_path", type=str, default="docs/fonts/simfang.ttf")
    parser.add_argument("--drop_score", type=float, default=0.5)
    parser.add_argument(
        "--rec_gt_path", type=str, default=None, help="Path to ground truth labels of the recognition result"
    )  # added
 
    #
    parser.add_argument(
        "--draw_img_save_dir",
        type=str,
        default="./inference_results",
        help="Dir to save visualization and detection/recogintion/system prediction results",
    )
    parser.add_argument(
        "--save_crop_res",
        type=str2bool,
        default=False,
        help="Whether to save images cropped from text detection results.",
    )
    parser.add_argument(
        "--crop_res_save_dir", type=str, default="./output", help="Dir to save the cropped images for text boxes"
    )
    parser.add_argument(
        "--visualize_output",
        type=str2bool,
        default=False,
        help="Whether to visualize results and save the visualized image.",
    )
    parser.add_argument("--warmup", type=str2bool, default=False)
 
    return parser_config, parser

from typing import List, Tuple
 
import numpy as np
from shapely.geometry import Polygon
 
import mindspore as ms
import mindspore.ops as ops
from mindspore import Tensor, ms_function, nn
 
__all__ = ["DetMetric"]

def _get_intersect(pd, pg):
    return pd.intersection(pg).area

def _get_iou(pd, pg):
    return pd.intersection(pg).area / pd.union(pg).area

class DetectionIoUEvaluator:
    """
    Converts ground truth and predicted polygon locations into binary classification labels based on
    the IoU between them. This simplifies metric calculations, such as Recall, Precision, etc.
    根据真实标注和预测多边形之间的交并比（IoU），将它们转换为二元分类标签。这简化了召回率、精确率等度量计算的过程。
 
    Args:
        min_iou: Minimum IoU between the ground truth and prediction to be considered as a correct prediction.
        min_iou: 在考虑为正确预测的情况下，真实标注和预测之间的最小交并比（IoU）。
        min_intersect: Minimum intersection with an ignored ground truth for the prediction to be considered as ignored
                       (and thus to be excluded from further calculations).
        min_intersect: 忽略的真实标注与预测之间的最小交集，以使预测被视为被忽略（从而在后续计算中排除）。
    """
 
    def __init__(self, min_iou: float = 0.5, min_intersect: float = 0.5):
        self._min_iou = min_iou
        self._min_intersect = min_intersect
 
    def __call__(self, gt: List[dict], preds: List[np.ndarray]) -> Tuple[List[int], List[int]]:
        """
        Converts GT and predicted polygons into binary classification labels, where 1 is positive and 0 is negative.
        将真实标注和预测多边形转换为二元分类标签，其中 1 表示正样本，0 表示负样本。
 
        Args:
            gt: list of ground truth dictionaries with keys: "polys" and "ignore".
            gt：包含真实标注字典的列表，每个字典中包含键 "polys" 和 "ignore"。其中，"polys" 表示真实标注的多边形信息，"ignore" 表示是否将该标注忽略。
            preds: list of predicted by a model polygons.
			preds：由模型预测的多边形列表。
        Returns:
            binary labels for the ground truth and predicted polygons.
        """
        # filter invalid groundtruth polygons and split them into useful and ignored
        gt_polys, gt_ignore = [], []
        for sample in gt:
            poly = Polygon(sample["polys"])
            if poly.is_valid and poly.is_simple:
                if not sample["ignore"]:
                    gt_polys.append(poly)
                else:
                    gt_ignore.append(poly)
 
        # repeat the same step for the predicted polygons
        det_polys, det_ignore = [], []
        for pred in preds:
            poly = Polygon(pred)
            if poly.is_valid and poly.is_simple:
                poly_area = poly.area
                if gt_ignore and poly_area > 0:
                    for ignore_poly in gt_ignore:
                        intersect_area = _get_intersect(ignore_poly, poly)
                        precision = intersect_area / poly_area
                        # If precision enough, append as ignored detection
                        if precision > self._min_intersect:
                            det_ignore.append(poly)
                            break
                    else:
                        det_polys.append(poly)
                else:
                    det_polys.append(poly)
 
        det_labels = [0] * len(gt_polys)
        if det_polys:
            iou_mat = np.zeros([len(gt_polys), len(det_polys)])
            det_rect_mat = np.zeros(len(det_polys), np.int8)
 
            for det_idx in range(len(det_polys)):
                if det_rect_mat[det_idx] == 0:  # the match is not found yet
                    for gt_idx in range(len(gt_polys)):
                        iou_mat[gt_idx, det_idx] = _get_iou(det_polys[det_idx], gt_polys[gt_idx])
                        if iou_mat[gt_idx, det_idx] > self._min_iou:
                            # Mark the visit arrays
                            det_rect_mat[det_idx] = 1
                            det_labels[gt_idx] = 1
                            break
                    else:
                        det_labels.append(1)
 
        gt_labels = [1] * len(gt_polys) + [0] * (len(det_labels) - len(gt_polys))
        return gt_labels, det_labels

class DetMetric(nn.Metric):
    """
    Calculate Recall, Precision, and F-score for predicted polygons given ground truth.
    给定真实标注，计算预测多边形的召回率、精确率和 F1 分数。
 
    Args:
        device_num: number of devices used in the metric calculation.
    """
 
    def __init__(self, device_num: int = 1, **kwargs):
        super().__init__()
        self._evaluator = DetectionIoUEvaluator()
        self._gt_labels, self._det_labels = [], []
        self.device_num = device_num
        self.all_reduce = None if device_num == 1 else ops.AllReduce()
        self.metric_names = ["recall", "precision", "f-score"]
 
    def clear(self):
        self._gt_labels, self._det_labels = [], []
 
    def update(self, *inputs):
        """
        Compute the metrics on a single batch of data.
 
        Args:
            inputs (tuple): contain two elements preds, gt
                    preds (dict): text detection prediction as a dictionary with keys:
                        polys: np.ndarray of shape (N, K, 4, 2)
                        score: np.ndarray of shape (N, K), confidence score
                    gts (tuple): ground truth
                        - (polygons, ignore_tags), where polygons are in shape [num_images, num_boxes, 4, 2],
                        ignore_tags are in shape [num_images, num_boxes], which can be defined by output_columns in yaml
        """
        preds, gts = inputs
        preds = preds["polys"]
        polys, ignore = gts[0].asnumpy().astype(np.float32), gts[1].asnumpy()
 
        for sample_id in range(len(polys)):
            gt = [{"polys": poly, "ignore": ig} for poly, ig in zip(polys[sample_id], ignore[sample_id])]
            gt_label, det_label = self._evaluator(gt, preds[sample_id])
            self._gt_labels.append(gt_label)
            self._det_labels.append(det_label)
 
    @ms_function
    def all_reduce_fun(self, x):
        res = self.all_reduce(x)
        return res
 
    def cal_matrix(self, det_lst, gt_lst):
        tp = np.sum((gt_lst == 1) * (det_lst == 1))
        fn = np.sum((gt_lst == 1) * (det_lst == 0))
        fp = np.sum((gt_lst == 0) * (det_lst == 1))
        return tp, fp, fn
 
    def eval(self) -> dict:
        """
        Evaluate by aggregating results from all batches.
 
        Returns:
            average recall, precision, f1-score of all samples.
        """
        # flatten predictions and labels into 1D-array
        self._det_labels = np.array([lbl for label in self._det_labels for lbl in label])
        self._gt_labels = np.array([lbl for label in self._gt_labels for lbl in label])
 
        tp, fp, fn = self.cal_matrix(self._det_labels, self._gt_labels)
        if self.all_reduce:
            tp = float(self.all_reduce_fun(Tensor(tp, ms.float32)).asnumpy())
            fp = float(self.all_reduce_fun(Tensor(fp, ms.float32)).asnumpy())
            fn = float(self.all_reduce_fun(Tensor(fn, ms.float32)).asnumpy())
 
        recall = _safe_divide(tp, (tp + fn))
        precision = _safe_divide(tp, (tp + fp))
        f_score = _safe_divide(2 * recall * precision, (recall + precision))
        return {"recall": recall, "precision": precision, "f-score": f_score}

def _safe_divide(numerator, denominator, val_if_zero_divide=0.0):
    if denominator == 0:
        return val_if_zero_divide
    else:
        return numerator / denominator