paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/paddleseg/utils/__init__.py

@@ -1,22 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-from . import logger
-from . import download
-from . import metrics
-from .env import seg_env, get_sys_env
-from .utils import *
-from .timer import TimeAverager, calculate_eta
-from . import visualize
-from .config_check import config_check

paddlex/paddleseg/utils/config_check.py

@@ -1,60 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import numpy as np
-
-
-def config_check(cfg, train_dataset=None, val_dataset=None):
-    """
-    To check config。
-
-    Args:
-        cfg (paddleseg.cvlibs.Config): An object of paddleseg.cvlibs.Config.
-        train_dataset (paddle.io.Dataset): Used to read and process training datasets.
-        val_dataset (paddle.io.Dataset, optional): Used to read and process validation datasets.
-    """
-
-    num_classes_check(cfg, train_dataset, val_dataset)
-
-
-def num_classes_check(cfg, train_dataset, val_dataset):
-    """"
-    Check that the num_classes in model, train_dataset and val_dataset is consistent.
-    """
-    num_classes_set = set()
-    if train_dataset and hasattr(train_dataset, 'num_classes'):
-        num_classes_set.add(train_dataset.num_classes)
-    if val_dataset and hasattr(val_dataset, 'num_classes'):
-        num_classes_set.add(val_dataset.num_classes)
-    if cfg.dic.get('model', None) and cfg.dic['model'].get('num_classes',
-                                                           None):
-        num_classes_set.add(cfg.dic['model'].get('num_classes'))
-    if (not cfg.train_dataset) and (not cfg.val_dataset):
-        raise ValueError(
-            'One of `train_dataset` or `val_dataset should be given, but there are none.'
-        )
-    if len(num_classes_set) == 0:
-        raise ValueError(
-            '`num_classes` is not found. Please set it in model, train_dataset or val_dataset'
-        )
-    elif len(num_classes_set) > 1:
-        raise ValueError(
-            '`num_classes` is not consistent: {}. Please set it consistently in model or train_dataset or val_dataset'
-            .format(num_classes_set))
-    else:
-        num_classes = num_classes_set.pop()
-        if train_dataset:
-            train_dataset.num_classes = num_classes
-        if val_dataset:
-            val_dataset.num_classes = num_classes

paddlex/paddleseg/utils/download.py

@@ -1,163 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import functools
-import os
-import shutil
-import sys
-import tarfile
-import time
-import zipfile
-
-import requests
-
-lasttime = time.time()
-FLUSH_INTERVAL = 0.1
-
-
-def progress(str, end=False):
-    global lasttime
-    if end:
-        str += "\n"
-        lasttime = 0
-    if time.time() - lasttime >= FLUSH_INTERVAL:
-        sys.stdout.write("\r%s" % str)
-        lasttime = time.time()
-        sys.stdout.flush()
-
-
-def _download_file(url, savepath, print_progress):
-    if print_progress:
-        print("Connecting to {}".format(url))
-    r = requests.get(url, stream=True, timeout=15)
-    total_length = r.headers.get('content-length')
-
-    if total_length is None:
-        with open(savepath, 'wb') as f:
-            shutil.copyfileobj(r.raw, f)
-    else:
-        with open(savepath, 'wb') as f:
-            dl = 0
-            total_length = int(total_length)
-            starttime = time.time()
-            if print_progress:
-                print("Downloading %s" % os.path.basename(savepath))
-            for data in r.iter_content(chunk_size=4096):
-                dl += len(data)
-                f.write(data)
-                if print_progress:
-                    done = int(50 * dl / total_length)
-                    progress("[%-50s] %.2f%%" %
-                             ('=' * done, float(100 * dl) / total_length))
-        if print_progress:
-            progress("[%-50s] %.2f%%" % ('=' * 50, 100), end=True)
-
-
-def _uncompress_file_zip(filepath, extrapath):
-    files = zipfile.ZipFile(filepath, 'r')
-    filelist = files.namelist()
-    rootpath = filelist[0]
-    total_num = len(filelist)
-    for index, file in enumerate(filelist):
-        files.extract(file, extrapath)
-        yield total_num, index, rootpath
-    files.close()
-    yield total_num, index, rootpath
-
-
-def _uncompress_file_tar(filepath, extrapath, mode="r:gz"):
-    files = tarfile.open(filepath, mode)
-    filelist = files.getnames()
-    total_num = len(filelist)
-    rootpath = filelist[0]
-    for index, file in enumerate(filelist):
-        files.extract(file, extrapath)
-        yield total_num, index, rootpath
-    files.close()
-    yield total_num, index, rootpath
-
-
-def _uncompress_file(filepath, extrapath, delete_file, print_progress):
-    if print_progress:
-        print("Uncompress %s" % os.path.basename(filepath))
-
-    if filepath.endswith("zip"):
-        handler = _uncompress_file_zip
-    elif filepath.endswith("tgz"):
-        handler = functools.partial(_uncompress_file_tar, mode="r:*")
-    else:
-        handler = functools.partial(_uncompress_file_tar, mode="r")
-
-    for total_num, index, rootpath in handler(filepath, extrapath):
-        if print_progress:
-            done = int(50 * float(index) / total_num)
-            progress("[%-50s] %.2f%%" %
-                     ('=' * done, float(100 * index) / total_num))
-    if print_progress:
-        progress("[%-50s] %.2f%%" % ('=' * 50, 100), end=True)
-
-    if delete_file:
-        os.remove(filepath)
-
-    return rootpath
-
-
-def download_file_and_uncompress(url,
-                                 savepath=None,
-                                 extrapath=None,
-                                 extraname=None,
-                                 print_progress=True,
-                                 cover=False,
-                                 delete_file=True):
-    if savepath is None:
-        savepath = "."
-
-    if extrapath is None:
-        extrapath = "."
-
-    savename = url.split("/")[-1]
-    if not os.path.exists(savepath):
-        os.makedirs(savepath)
-
-    savepath = os.path.join(savepath, savename)
-    savename = ".".join(savename.split(".")[:-1])
-    savename = os.path.join(extrapath, savename)
-    extraname = savename if extraname is None else os.path.join(extrapath,
-                                                                extraname)
-
-    if cover:
-        if os.path.exists(savepath):
-            shutil.rmtree(savepath)
-        if os.path.exists(savename):
-            shutil.rmtree(savename)
-        if os.path.exists(extraname):
-            shutil.rmtree(extraname)
-
-    if not os.path.exists(extraname):
-        if not os.path.exists(savename):
-            if not os.path.exists(savepath):
-                _download_file(url, savepath, print_progress)
-
-            if (not tarfile.is_tarfile(savepath)) and (
-                    not zipfile.is_zipfile(savepath)):
-                if not os.path.exists(extraname):
-                    os.makedirs(extraname)
-                shutil.move(savepath, extraname)
-                return extraname
-
-            savename = _uncompress_file(savepath, extrapath, delete_file,
-                                        print_progress)
-            savename = os.path.join(extrapath, savename)
-        shutil.move(savename, extraname)
-    return extraname

paddlex/paddleseg/utils/env/__init__.py

@@ -1,16 +0,0 @@
-# Copyright (c) 2020  PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-from . import seg_env
-from .sys_env import get_sys_env

paddlex/paddleseg/utils/env/seg_env.py

@@ -1,56 +0,0 @@
-# Copyright (c) 2020  PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-"""
-This module is used to store environmental parameters in PaddleSeg.
-
-SEG_HOME : Root directory for storing PaddleSeg related data. Default to ~/.paddleseg.
-           Users can change the default value through the SEG_HOME environment variable.
-DATA_HOME : The directory to store the automatically downloaded dataset, e.g ADE20K.
-PRETRAINED_MODEL_HOME : The directory to store the automatically downloaded pretrained model.
-"""
-
-import os
-
-from paddlex.paddleseg.utils import logger
-
-
-def _get_user_home():
-    return os.path.expanduser('~')
-
-
-def _get_seg_home():
-    if 'SEG_HOME' in os.environ:
-        home_path = os.environ['SEG_HOME']
-        if os.path.exists(home_path):
-            if os.path.isdir(home_path):
-                return home_path
-            else:
-                logger.warning('SEG_HOME {} is a file!'.format(home_path))
-        else:
-            return home_path
-    return os.path.join(_get_user_home(), '.paddleseg')
-
-
-def _get_sub_home(directory):
-    home = os.path.join(_get_seg_home(), directory)
-    if not os.path.exists(home):
-        os.makedirs(home, exist_ok=True)
-    return home
-
-
-USER_HOME = _get_user_home()
-SEG_HOME = _get_seg_home()
-DATA_HOME = _get_sub_home('dataset')
-TMP_HOME = _get_sub_home('tmp')
-PRETRAINED_MODEL_HOME = _get_sub_home('pretrained_model')

paddlex/paddleseg/utils/env/sys_env.py

@@ -1,122 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import glob
-import os
-import platform
-import subprocess
-import sys
-
-import cv2
-import paddle
-
-IS_WINDOWS = sys.platform == 'win32'
-
-
-def _find_cuda_home():
-    '''Finds the CUDA install path. It refers to the implementation of
-    pytorch <https://github.com/pytorch/pytorch/blob/master/torch/utils/cpp_extension.py>.
-    '''
-    # Guess #1
-    cuda_home = os.environ.get('CUDA_HOME') or os.environ.get('CUDA_PATH')
-    if cuda_home is None:
-        # Guess #2
-        try:
-            which = 'where' if IS_WINDOWS else 'which'
-            nvcc = subprocess.check_output([which,
-                                            'nvcc']).decode().rstrip('\r\n')
-            cuda_home = os.path.dirname(os.path.dirname(nvcc))
-        except Exception:
-            # Guess #3
-            if IS_WINDOWS:
-                cuda_homes = glob.glob(
-                    'C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v*.*')
-                if len(cuda_homes) == 0:
-                    cuda_home = ''
-                else:
-                    cuda_home = cuda_homes[0]
-            else:
-                cuda_home = '/usr/local/cuda'
-            if not os.path.exists(cuda_home):
-                cuda_home = None
-    return cuda_home
-
-
-def _get_nvcc_info(cuda_home):
-    if cuda_home is not None and os.path.isdir(cuda_home):
-        try:
-            nvcc = os.path.join(cuda_home, 'bin/nvcc')
-            nvcc = subprocess.check_output(
-                "{} -V".format(nvcc), shell=True).decode()
-            nvcc = nvcc.strip().split('\n')[-1]
-        except subprocess.SubprocessError:
-            nvcc = "Not Available"
-    else:
-        nvcc = "Not Available"
-    return nvcc
-
-
-def _get_gpu_info():
-    try:
-        gpu_info = subprocess.check_output(['nvidia-smi',
-                                            '-L']).decode().strip()
-        gpu_info = gpu_info.split('\n')
-        for i in range(len(gpu_info)):
-            gpu_info[i] = ' '.join(gpu_info[i].split(' ')[:4])
-    except:
-        gpu_info = ' Can not get GPU information. Please make sure CUDA have been installed successfully.'
-    return gpu_info
-
-
-def get_sys_env():
-    """collect environment information"""
-    env_info = {}
-    env_info['platform'] = platform.platform()
-
-    env_info['Python'] = sys.version.replace('\n', '')
-
-    # TODO is_compiled_with_cuda() has not been moved
-    compiled_with_cuda = paddle.is_compiled_with_cuda()
-    env_info['Paddle compiled with cuda'] = compiled_with_cuda
-
-    if compiled_with_cuda:
-        cuda_home = _find_cuda_home()
-        env_info['NVCC'] = _get_nvcc_info(cuda_home)
-        # refer to https://github.com/PaddlePaddle/Paddle/blob/release/2.0-rc/paddle/fluid/platform/device_context.cc#L327
-        v = paddle.get_cudnn_version()
-        v = str(v // 1000) + '.' + str(v % 1000 // 100)
-        env_info['cudnn'] = v
-        if 'gpu' in paddle.get_device():
-            gpu_nums = paddle.distributed.ParallelEnv().nranks
-        else:
-            gpu_nums = 0
-        env_info['GPUs used'] = gpu_nums
-
-        env_info['CUDA_VISIBLE_DEVICES'] = os.environ.get(
-            'CUDA_VISIBLE_DEVICES')
-        if gpu_nums == 0:
-            os.environ['CUDA_VISIBLE_DEVICES'] = ''
-        env_info['GPU'] = _get_gpu_info()
-
-    try:
-        gcc = subprocess.check_output(['gcc', '--version']).decode()
-        gcc = gcc.strip().split('\n')[0]
-        env_info['GCC'] = gcc
-    except:
-        pass
-
-    env_info['PaddlePaddle'] = paddle.__version__
-    env_info['OpenCV'] = cv2.__version__
-
-    return env_info

paddlex/paddleseg/utils/logger.py

@@ -1,48 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import sys
-import time
-
-import paddle
-
-levels = {0: 'ERROR', 1: 'WARNING', 2: 'INFO', 3: 'DEBUG'}
-log_level = 2
-
-
-def log(level=2, message=""):
-    if paddle.distributed.ParallelEnv().local_rank == 0:
-        current_time = time.time()
-        time_array = time.localtime(current_time)
-        current_time = time.strftime("%Y-%m-%d %H:%M:%S", time_array)
-        if log_level >= level:
-            print("{} [{}]\t{}".format(current_time, levels[level], message)
-                  .encode("utf-8").decode("latin1"))
-            sys.stdout.flush()
-
-
-def debug(message=""):
-    log(level=3, message=message)
-
-
-def info(message=""):
-    log(level=2, message=message)
-
-
-def warning(message=""):
-    log(level=1, message=message)
-
-
-def error(message=""):
-    log(level=0, message=message)

paddlex/paddleseg/utils/metrics.py

@@ -1,146 +0,0 @@
-# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-import numpy as np
-import paddle
-import paddle.nn.functional as F
-
-
-def calculate_area(pred, label, num_classes, ignore_index=255):
-    """
-    Calculate intersect, prediction and label area
-
-    Args:
-        pred (Tensor): The prediction by model.
-        label (Tensor): The ground truth of image.
-        num_classes (int): The unique number of target classes.
-        ignore_index (int): Specifies a target value that is ignored. Default: 255.
-
-    Returns:
-        Tensor: The intersection area of prediction and the ground on all class.
-        Tensor: The prediction area on all class.
-        Tensor: The ground truth area on all class
-    """
-    if len(pred.shape) == 4:
-        pred = paddle.squeeze(pred, axis=1)
-    if len(label.shape) == 4:
-        label = paddle.squeeze(label, axis=1)
-    if not pred.shape == label.shape:
-        raise ValueError('Shape of `pred` and `label should be equal, '
-                         'but there are {} and {}.'.format(pred.shape,
-                                                           label.shape))
-
-    # Delete ignore_index
-    mask = label != ignore_index
-    pred = pred + 1
-    label = label + 1
-    pred = pred * mask
-    label = label * mask
-    pred = F.one_hot(pred, num_classes + 1)
-    label = F.one_hot(label, num_classes + 1)
-    pred = pred[:, :, :, 1:]
-    label = label[:, :, :, 1:]
-
-    pred_area = []
-    label_area = []
-    intersect_area = []
-
-    for i in range(num_classes):
-        pred_i = pred[:, :, :, i]
-        label_i = label[:, :, :, i]
-        pred_area_i = paddle.sum(pred_i)
-        label_area_i = paddle.sum(label_i)
-        intersect_area_i = paddle.sum(pred_i * label_i)
-        pred_area.append(pred_area_i)
-        label_area.append(label_area_i)
-        intersect_area.append(intersect_area_i)
-    pred_area = paddle.concat(pred_area)
-    label_area = paddle.concat(label_area)
-    intersect_area = paddle.concat(intersect_area)
-    return intersect_area, pred_area, label_area
-
-
-def mean_iou(intersect_area, pred_area, label_area):
-    """
-    Calculate iou.
-
-    Args:
-        intersect_area (Tensor): The intersection area of prediction and ground truth on all classes.
-        pred_area (Tensor): The prediction area on all classes.
-        label_area (Tensor): The ground truth area on all classes.
-
-    Returns:
-        np.ndarray: iou on all classes.
-        float: mean iou of all classes.
-    """
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    label_area = label_area.numpy()
-    union = pred_area + label_area - intersect_area
-    class_iou = []
-    for i in range(len(intersect_area)):
-        if union[i] == 0:
-            iou = 0
-        else:
-            iou = intersect_area[i] / union[i]
-        class_iou.append(iou)
-    miou = np.mean(class_iou)
-    return np.array(class_iou), miou
-
-
-def accuracy(intersect_area, pred_area):
-    """
-    Calculate accuracy
-
-    Args:
-        intersect_area (Tensor): The intersection area of prediction and ground truth on all classes..
-        pred_area (Tensor): The prediction area on all classes.
-
-    Returns:
-        np.ndarray: accuracy on all classes.
-        float: mean accuracy.
-    """
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    class_acc = []
-    for i in range(len(intersect_area)):
-        if pred_area[i] == 0:
-            acc = 0
-        else:
-            acc = intersect_area[i] / pred_area[i]
-        class_acc.append(acc)
-    macc = np.sum(intersect_area) / np.sum(pred_area)
-    return np.array(class_acc), macc
-
-
-def kappa(intersect_area, pred_area, label_area):
-    """
-    Calculate kappa coefficient
-
-    Args:
-        intersect_area (Tensor): The intersection area of prediction and ground truth on all classes..
-        pred_area (Tensor): The prediction area on all classes.
-        label_area (Tensor): The ground truth area on all classes.
-
-    Returns:
-        float: kappa coefficient.
-    """
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    label_area = label_area.numpy()
-    total_area = np.sum(label_area)
-    po = np.sum(intersect_area) / total_area
-    pe = np.sum(pred_area * label_area) / (total_area * total_area)
-    kappa = (po - pe) / (1 - pe)
-    return kappa