first commit

.gitattributes

@@ -33,3 +33,23 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models-ax637/deeplabv3plus_mobilenet_u16.axmodel filter=lfs diff=lfs merge=lfs -text
+models-ax650/deeplabv3plus_mobilenet_u16.axmodel filter=lfs diff=lfs merge=lfs -text
+samples/114_image.png filter=lfs diff=lfs merge=lfs -text
+samples/1_image.png filter=lfs diff=lfs merge=lfs -text
+samples/1_target.png filter=lfs diff=lfs merge=lfs -text
+samples/23_target.png filter=lfs diff=lfs merge=lfs -text
+samples/city_1_overlay.png filter=lfs diff=lfs merge=lfs -text
+samples/city_1_target.png filter=lfs diff=lfs merge=lfs -text
+samples/114_overlay.png filter=lfs diff=lfs merge=lfs -text
+samples/23_image.png filter=lfs diff=lfs merge=lfs -text
+samples/23_overlay.png filter=lfs diff=lfs merge=lfs -text
+samples/23_pred.png filter=lfs diff=lfs merge=lfs -text
+samples/city_6_overlay.png filter=lfs diff=lfs merge=lfs -text
+samples/city_6_target.png filter=lfs diff=lfs merge=lfs -text
+samples/1_overlay.png filter=lfs diff=lfs merge=lfs -text
+samples/1_pred.png filter=lfs diff=lfs merge=lfs -text
+samples/114_pred.png filter=lfs diff=lfs merge=lfs -text
+samples/114_target.png filter=lfs diff=lfs merge=lfs -text
+samples/visdom-screenshoot.png filter=lfs diff=lfs merge=lfs -text
+output-ax.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+__pycache__

README.md

@@ -1,3 +1,73 @@
 ---
-license: mit
+license: bsd-3-clause
+language:
+- en
+base_model:
+- deeplabv3plus_mobilenet
+pipeline_tag: semantic-segmentation
+tags:
+- deeplabv3plus
 ---
+
+# DeepLabv3Plus   
+
+This version of deeplabv3plus_mobilenet has been converted to run on the Axera NPU using **w8a16** quantization.
+
+Compatible with Pulsar2 version: 5.0-patch1
+
+## Convert tools links:
+
+For those who are interested in model conversion, you can try to export axmodel through 
+
+- [The repo of original](https://github.com/VainF/DeepLabV3Plus-Pytorch.git)
+
+- [Pulsar2 Link, How to Convert ONNX to axmodel](https://pulsar2-docs.readthedocs.io/en/latest/pulsar2/introduction.html) 
+
+
+## Support Platform
+
+- AX650
+  - [M4N-Dock(爱芯派Pro)](https://wiki.sipeed.com/hardware/zh/maixIV/m4ndock/m4ndock.html)
+  - [M.2 Accelerator card](https://axcl-docs.readthedocs.io/zh-cn/latest/doc_guide_hardware.html)
+- AX637
+ 
+|Chips|Models |Time|
+|--|--|--|
+|AX650|deeplabv3plus_mobilenet_u16|13.4 ms |
+|AX637|deeplabv3plus_mobilenet_u16|39.4 ms |
+
+
+## How to use
+
+Download all files from this repository to the device
+
+
+### python env requirement
+
+#### pyaxengine
+
+https://github.com/AXERA-TECH/pyaxengine
+
+```
+wget https://github.com/AXERA-TECH/pyaxengine/releases/download/0.1.3.rc2/axengine-0.1.3-py3-none-any.whl
+pip install axengine-0.1.3-py3-none-any.whl
+```
+
+#### others
+
+Maybe None.
+
+#### Inference with AX650 Host, such as M4N-Dock(爱芯派Pro)
+
+Input image:
+
+![](samples/1_image.png)
+
+run 
+```
+python3 infer.py --img samples/1_image.png --model models-ax637/deeplabv3plus_mobilenet_u16.axmodel
+```
+
+Output image:
+
+![](output-ax.png)

datasets/__init__.py

@@ -0,0 +1,2 @@
+from .voc import VOCSegmentation
+from .cityscapes import Cityscapes

datasets/cityscapes.py

@@ -0,0 +1,147 @@
+import json
+import os
+from collections import namedtuple
+
+import torch
+import torch.utils.data as data
+from PIL import Image
+import numpy as np
+
+
+class Cityscapes(data.Dataset):
+    """Cityscapes <http://www.cityscapes-dataset.com/> Dataset.
+    
+    **Parameters:**
+        - **root** (string): Root directory of dataset where directory 'leftImg8bit' and 'gtFine' or 'gtCoarse' are located.
+        - **split** (string, optional): The image split to use, 'train', 'test' or 'val' if mode="gtFine" otherwise 'train', 'train_extra' or 'val'
+        - **mode** (string, optional): The quality mode to use, 'gtFine' or 'gtCoarse' or 'color'. Can also be a list to output a tuple with all specified target types.
+        - **transform** (callable, optional): A function/transform that takes in a PIL image and returns a transformed version. E.g, ``transforms.RandomCrop``
+        - **target_transform** (callable, optional): A function/transform that takes in the target and transforms it.
+    """
+
+    # Based on https://github.com/mcordts/cityscapesScripts
+    CityscapesClass = namedtuple('CityscapesClass', ['name', 'id', 'train_id', 'category', 'category_id',
+                                                     'has_instances', 'ignore_in_eval', 'color'])
+    classes = [
+        CityscapesClass('unlabeled',            0, 255, 'void', 0, False, True, (0, 0, 0)),
+        CityscapesClass('ego vehicle',          1, 255, 'void', 0, False, True, (0, 0, 0)),
+        CityscapesClass('rectification border', 2, 255, 'void', 0, False, True, (0, 0, 0)),
+        CityscapesClass('out of roi',           3, 255, 'void', 0, False, True, (0, 0, 0)),
+        CityscapesClass('static',               4, 255, 'void', 0, False, True, (0, 0, 0)),
+        CityscapesClass('dynamic',              5, 255, 'void', 0, False, True, (111, 74, 0)),
+        CityscapesClass('ground',               6, 255, 'void', 0, False, True, (81, 0, 81)),
+        CityscapesClass('road',                 7, 0, 'flat', 1, False, False, (128, 64, 128)),
+        CityscapesClass('sidewalk',             8, 1, 'flat', 1, False, False, (244, 35, 232)),
+        CityscapesClass('parking',              9, 255, 'flat', 1, False, True, (250, 170, 160)),
+        CityscapesClass('rail track',           10, 255, 'flat', 1, False, True, (230, 150, 140)),
+        CityscapesClass('building',             11, 2, 'construction', 2, False, False, (70, 70, 70)),
+        CityscapesClass('wall',                 12, 3, 'construction', 2, False, False, (102, 102, 156)),
+        CityscapesClass('fence',                13, 4, 'construction', 2, False, False, (190, 153, 153)),
+        CityscapesClass('guard rail',           14, 255, 'construction', 2, False, True, (180, 165, 180)),
+        CityscapesClass('bridge',               15, 255, 'construction', 2, False, True, (150, 100, 100)),
+        CityscapesClass('tunnel',               16, 255, 'construction', 2, False, True, (150, 120, 90)),
+        CityscapesClass('pole',                 17, 5, 'object', 3, False, False, (153, 153, 153)),
+        CityscapesClass('polegroup',            18, 255, 'object', 3, False, True, (153, 153, 153)),
+        CityscapesClass('traffic light',        19, 6, 'object', 3, False, False, (250, 170, 30)),
+        CityscapesClass('traffic sign',         20, 7, 'object', 3, False, False, (220, 220, 0)),
+        CityscapesClass('vegetation',           21, 8, 'nature', 4, False, False, (107, 142, 35)),
+        CityscapesClass('terrain',              22, 9, 'nature', 4, False, False, (152, 251, 152)),
+        CityscapesClass('sky',                  23, 10, 'sky', 5, False, False, (70, 130, 180)),
+        CityscapesClass('person',               24, 11, 'human', 6, True, False, (220, 20, 60)),
+        CityscapesClass('rider',                25, 12, 'human', 6, True, False, (255, 0, 0)),
+        CityscapesClass('car',                  26, 13, 'vehicle', 7, True, False, (0, 0, 142)),
+        CityscapesClass('truck',                27, 14, 'vehicle', 7, True, False, (0, 0, 70)),
+        CityscapesClass('bus',                  28, 15, 'vehicle', 7, True, False, (0, 60, 100)),
+        CityscapesClass('caravan',              29, 255, 'vehicle', 7, True, True, (0, 0, 90)),
+        CityscapesClass('trailer',              30, 255, 'vehicle', 7, True, True, (0, 0, 110)),
+        CityscapesClass('train',                31, 16, 'vehicle', 7, True, False, (0, 80, 100)),
+        CityscapesClass('motorcycle',           32, 17, 'vehicle', 7, True, False, (0, 0, 230)),
+        CityscapesClass('bicycle',              33, 18, 'vehicle', 7, True, False, (119, 11, 32)),
+        CityscapesClass('license plate',        -1, 255, 'vehicle', 7, False, True, (0, 0, 142)),
+    ]
+
+    train_id_to_color = [c.color for c in classes if (c.train_id != -1 and c.train_id != 255)]
+    train_id_to_color.append([0, 0, 0])
+    train_id_to_color = np.array(train_id_to_color)
+    id_to_train_id = np.array([c.train_id for c in classes])
+    
+    #train_id_to_color = [(0, 0, 0), (128, 64, 128), (70, 70, 70), (153, 153, 153), (107, 142, 35),
+    #                      (70, 130, 180), (220, 20, 60), (0, 0, 142)]
+    #train_id_to_color = np.array(train_id_to_color)
+    #id_to_train_id = np.array([c.category_id for c in classes], dtype='uint8') - 1
+
+    def __init__(self, root, split='train', mode='fine', target_type='semantic', transform=None):
+        self.root = os.path.expanduser(root)
+        self.mode = 'gtFine'
+        self.target_type = target_type
+        self.images_dir = os.path.join(self.root, 'leftImg8bit', split)
+
+        self.targets_dir = os.path.join(self.root, self.mode, split)
+        self.transform = transform
+
+        self.split = split
+        self.images = []
+        self.targets = []
+
+        if split not in ['train', 'test', 'val']:
+            raise ValueError('Invalid split for mode! Please use split="train", split="test"'
+                             ' or split="val"')
+
+        if not os.path.isdir(self.images_dir) or not os.path.isdir(self.targets_dir):
+            raise RuntimeError('Dataset not found or incomplete. Please make sure all required folders for the'
+                               ' specified "split" and "mode" are inside the "root" directory')
+        
+        for city in os.listdir(self.images_dir):
+            img_dir = os.path.join(self.images_dir, city)
+            target_dir = os.path.join(self.targets_dir, city)
+
+            for file_name in os.listdir(img_dir):
+                self.images.append(os.path.join(img_dir, file_name))
+                target_name = '{}_{}'.format(file_name.split('_leftImg8bit')[0],
+                                             self._get_target_suffix(self.mode, self.target_type))
+                self.targets.append(os.path.join(target_dir, target_name))
+
+    @classmethod
+    def encode_target(cls, target):
+        return cls.id_to_train_id[np.array(target)]
+
+    @classmethod
+    def decode_target(cls, target):
+        target[target == 255] = 19
+        #target = target.astype('uint8') + 1
+        return cls.train_id_to_color[target]
+
+    def __getitem__(self, index):
+        """
+        Args:
+            index (int): Index
+        Returns:
+            tuple: (image, target) where target is a tuple of all target types if target_type is a list with more
+            than one item. Otherwise target is a json object if target_type="polygon", else the image segmentation.
+        """
+        image = Image.open(self.images[index]).convert('RGB')
+        target = Image.open(self.targets[index])
+        if self.transform:
+            image, target = self.transform(image, target)
+        target = self.encode_target(target)
+        return image, target
+
+    def __len__(self):
+        return len(self.images)
+
+    def _load_json(self, path):
+        with open(path, 'r') as file:
+            data = json.load(file)
+        return data
+
+    def _get_target_suffix(self, mode, target_type):
+        if target_type == 'instance':
+            return '{}_instanceIds.png'.format(mode)
+        elif target_type == 'semantic':
+            return '{}_labelIds.png'.format(mode)
+        elif target_type == 'color':
+            return '{}_color.png'.format(mode)
+        elif target_type == 'polygon':
+            return '{}_polygons.json'.format(mode)
+        elif target_type == 'depth':
+            return '{}_disparity.png'.format(mode)

datasets/utils.py

@@ -0,0 +1,126 @@
+import os
+import os.path
+import hashlib
+import errno
+from tqdm import tqdm
+
+
+def gen_bar_updater(pbar):
+    def bar_update(count, block_size, total_size):
+        if pbar.total is None and total_size:
+            pbar.total = total_size
+        progress_bytes = count * block_size
+        pbar.update(progress_bytes - pbar.n)
+
+    return bar_update
+
+
+def check_integrity(fpath, md5=None):
+    if md5 is None:
+        return True
+    if not os.path.isfile(fpath):
+        return False
+    md5o = hashlib.md5()
+    with open(fpath, 'rb') as f:
+        # read in 1MB chunks
+        for chunk in iter(lambda: f.read(1024 * 1024), b''):
+            md5o.update(chunk)
+    md5c = md5o.hexdigest()
+    if md5c != md5:
+        return False
+    return True
+
+
+def makedir_exist_ok(dirpath):
+    """
+    Python2 support for os.makedirs(.., exist_ok=True)
+    """
+    try:
+        os.makedirs(dirpath)
+    except OSError as e:
+        if e.errno == errno.EEXIST:
+            pass
+        else:
+            raise
+
+
+def download_url(url, root, filename=None, md5=None):
+    """Download a file from a url and place it in root.
+    Args:
+        url (str): URL to download file from
+        root (str): Directory to place downloaded file in
+        filename (str): Name to save the file under. If None, use the basename of the URL
+        md5 (str): MD5 checksum of the download. If None, do not check
+    """
+    from six.moves import urllib
+
+    root = os.path.expanduser(root)
+    if not filename:
+        filename = os.path.basename(url)
+    fpath = os.path.join(root, filename)
+
+    makedir_exist_ok(root)
+
+    # downloads file
+    if os.path.isfile(fpath) and check_integrity(fpath, md5):
+        print('Using downloaded and verified file: ' + fpath)
+    else:
+        try:
+            print('Downloading ' + url + ' to ' + fpath)
+            urllib.request.urlretrieve(
+                url, fpath,
+                reporthook=gen_bar_updater(tqdm(unit='B', unit_scale=True))
+            )
+        except OSError:
+            if url[:5] == 'https':
+                url = url.replace('https:', 'http:')
+                print('Failed download. Trying https -> http instead.'
+                      ' Downloading ' + url + ' to ' + fpath)
+                urllib.request.urlretrieve(
+                    url, fpath,
+                    reporthook=gen_bar_updater(tqdm(unit='B', unit_scale=True))
+                )
+
+
+def list_dir(root, prefix=False):
+    """List all directories at a given root
+    Args:
+        root (str): Path to directory whose folders need to be listed
+        prefix (bool, optional): If true, prepends the path to each result, otherwise
+            only returns the name of the directories found
+    """
+    root = os.path.expanduser(root)
+    directories = list(
+        filter(
+            lambda p: os.path.isdir(os.path.join(root, p)),
+            os.listdir(root)
+        )
+    )
+
+    if prefix is True:
+        directories = [os.path.join(root, d) for d in directories]
+
+    return directories
+
+
+def list_files(root, suffix, prefix=False):
+    """List all files ending with a suffix at a given root
+    Args:
+        root (str): Path to directory whose folders need to be listed
+        suffix (str or tuple): Suffix of the files to match, e.g. '.png' or ('.jpg', '.png').
+            It uses the Python "str.endswith" method and is passed directly
+        prefix (bool, optional): If true, prepends the path to each result, otherwise
+            only returns the name of the files found
+    """
+    root = os.path.expanduser(root)
+    files = list(
+        filter(
+            lambda p: os.path.isfile(os.path.join(root, p)) and p.endswith(suffix),
+            os.listdir(root)
+        )
+    )
+
+    if prefix is True:
+        files = [os.path.join(root, d) for d in files]
+
+    return files

datasets/voc.py

@@ -0,0 +1,163 @@
+import os
+import sys
+import tarfile
+import collections
+import torch.utils.data as data
+import shutil
+import numpy as np
+
+from PIL import Image
+from torchvision.datasets.utils import download_url, check_integrity
+
+DATASET_YEAR_DICT = {
+    '2012': {
+        'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar',
+        'filename': 'VOCtrainval_11-May-2012.tar',
+        'md5': '6cd6e144f989b92b3379bac3b3de84fd',
+        'base_dir': 'VOCdevkit/VOC2012'
+    },
+    '2011': {
+        'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2011/VOCtrainval_25-May-2011.tar',
+        'filename': 'VOCtrainval_25-May-2011.tar',
+        'md5': '6c3384ef61512963050cb5d687e5bf1e',
+        'base_dir': 'TrainVal/VOCdevkit/VOC2011'
+    },
+    '2010': {
+        'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2010/VOCtrainval_03-May-2010.tar',
+        'filename': 'VOCtrainval_03-May-2010.tar',
+        'md5': 'da459979d0c395079b5c75ee67908abb',
+        'base_dir': 'VOCdevkit/VOC2010'
+    },
+    '2009': {
+        'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2009/VOCtrainval_11-May-2009.tar',
+        'filename': 'VOCtrainval_11-May-2009.tar',
+        'md5': '59065e4b188729180974ef6572f6a212',
+        'base_dir': 'VOCdevkit/VOC2009'
+    },
+    '2008': {
+        'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2008/VOCtrainval_14-Jul-2008.tar',
+        'filename': 'VOCtrainval_11-May-2012.tar',
+        'md5': '2629fa636546599198acfcfbfcf1904a',
+        'base_dir': 'VOCdevkit/VOC2008'
+    },
+    '2007': {
+        'url': 'http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar',
+        'filename': 'VOCtrainval_06-Nov-2007.tar',
+        'md5': 'c52e279531787c972589f7e41ab4ae64',
+        'base_dir': 'VOCdevkit/VOC2007'
+    }
+}
+
+
+def voc_cmap(N=256, normalized=False):
+    def bitget(byteval, idx):
+        return ((byteval & (1 << idx)) != 0)
+
+    dtype = 'float32' if normalized else 'uint8'
+    cmap = np.zeros((N, 3), dtype=dtype)
+    for i in range(N):
+        r = g = b = 0
+        c = i
+        for j in range(8):
+            r = r | (bitget(c, 0) << 7-j)
+            g = g | (bitget(c, 1) << 7-j)
+            b = b | (bitget(c, 2) << 7-j)
+            c = c >> 3
+
+        cmap[i] = np.array([r, g, b])
+
+    cmap = cmap/255 if normalized else cmap
+    return cmap
+
+class VOCSegmentation(data.Dataset):
+    """`Pascal VOC <http://host.robots.ox.ac.uk/pascal/VOC/>`_ Segmentation Dataset.
+    Args:
+        root (string): Root directory of the VOC Dataset.
+        year (string, optional): The dataset year, supports years 2007 to 2012.
+        image_set (string, optional): Select the image_set to use, ``train``, ``trainval`` or ``val``
+        download (bool, optional): If true, downloads the dataset from the internet and
+            puts it in root directory. If dataset is already downloaded, it is not
+            downloaded again.
+        transform (callable, optional): A function/transform that  takes in an PIL image
+            and returns a transformed version. E.g, ``transforms.RandomCrop``
+    """
+    cmap = voc_cmap()
+    def __init__(self,
+                 root,
+                 year='2012',
+                 image_set='train',
+                 download=False,
+                 transform=None):
+
+        is_aug=False
+        if year=='2012_aug':
+            is_aug = True
+            year = '2012'
+        
+        self.root = os.path.expanduser(root)
+        self.year = year
+        self.url = DATASET_YEAR_DICT[year]['url']
+        self.filename = DATASET_YEAR_DICT[year]['filename']
+        self.md5 = DATASET_YEAR_DICT[year]['md5']
+        self.transform = transform
+        
+        self.image_set = image_set
+        base_dir = DATASET_YEAR_DICT[year]['base_dir']
+        voc_root = os.path.join(self.root, base_dir)
+        image_dir = os.path.join(voc_root, 'JPEGImages')
+
+        if download:
+            download_extract(self.url, self.root, self.filename, self.md5)
+
+        if not os.path.isdir(voc_root):
+            raise RuntimeError('Dataset not found or corrupted.' +
+                               ' You can use download=True to download it')
+        
+        if is_aug and image_set=='train':
+            mask_dir = os.path.join(voc_root, 'SegmentationClassAug')
+            assert os.path.exists(mask_dir), "SegmentationClassAug not found, please refer to README.md and prepare it manually"
+            split_f = os.path.join( self.root, 'train_aug.txt')#'./datasets/data/train_aug.txt'
+        else:
+            mask_dir = os.path.join(voc_root, 'SegmentationClass')
+            splits_dir = os.path.join(voc_root, 'ImageSets/Segmentation')
+            split_f = os.path.join(splits_dir, image_set.rstrip('\n') + '.txt')
+
+        if not os.path.exists(split_f):
+            raise ValueError(
+                'Wrong image_set entered! Please use image_set="train" '
+                'or image_set="trainval" or image_set="val"')
+
+        with open(os.path.join(split_f), "r") as f:
+            file_names = [x.strip() for x in f.readlines()]
+        
+        self.images = [os.path.join(image_dir, x + ".jpg") for x in file_names]
+        self.masks = [os.path.join(mask_dir, x + ".png") for x in file_names]
+        assert (len(self.images) == len(self.masks))
+
+    def __getitem__(self, index):
+        """
+        Args:
+            index (int): Index
+        Returns:
+            tuple: (image, target) where target is the image segmentation.
+        """
+        img = Image.open(self.images[index]).convert('RGB')
+        target = Image.open(self.masks[index])
+        if self.transform is not None:
+            img, target = self.transform(img, target)
+
+        return img, target
+
+
+    def __len__(self):
+        return len(self.images)
+
+    @classmethod
+    def decode_target(cls, mask):
+        """decode semantic mask to RGB image"""
+        return cls.cmap[mask]
+
+def download_extract(url, root, filename, md5):
+    download_url(url, root, filename, md5)
+    with tarfile.open(os.path.join(root, filename), "r") as tar:
+        tar.extractall(path=root)

infer.py

@@ -0,0 +1,50 @@
+import argparse
+import cv2
+import os 
+import torch
+from PIL import Image
+import numpy as np
+import axengine as axe
+from datasets import VOCSegmentation, Cityscapes, cityscapes
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--img",
+        type=str,
+        required=True,
+        help="Path to input image.",
+    )
+    parser.add_argument(
+        "--model",
+        type=str,
+        required=True,
+        help="Path to axmodel model.",
+    )
+    
+    return parser.parse_args()
+
+
+def infer(img: str, model: str, viz: bool = False):
+    img_raw = cv2.imread(img)
+    image = cv2.cvtColor(img_raw, cv2.COLOR_BGR2RGB) 
+    image = cv2.resize(image, (513,513))
+    image = image[None]
+
+    session = axe.InferenceSession(model)
+    
+    pred = session.run(None, {"input": image})[0]
+    pred = torch.from_numpy(pred)
+    pred = pred.max(1)[1].cpu().numpy()[0] # HW
+    
+    decode_fn = VOCSegmentation.decode_target
+    colorized_preds = decode_fn(pred).astype('uint8')
+    colorized_preds = Image.fromarray(colorized_preds)
+    colorized_preds.save("output-ax.png")
+
+
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    infer(**vars(args))

models-ax637/deeplabv3plus_mobilenet_u16.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:efe6256681294ee1e498e198dfa047eab5852eb23542b1e8836dbff856fb23af
+size 9202159

models-ax650/deeplabv3plus_mobilenet_u16.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c3e0e24f96ee032f211d3f909c049316678035128dfe16dce5374019a73069a
+size 10083639