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

paddlex/paddleseg/utils/progbar.py

@@ -1,212 +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 os
-import sys
-import time
-
-import numpy as np
-
-
-class Progbar(object):
-    """
-    Displays a progress bar.
-        It refers to https://github.com/keras-team/keras/blob/keras-2/keras/utils/generic_utils.py
-
-    Args:
-        target (int): Total number of steps expected, None if unknown.
-        width (int): Progress bar width on screen.
-        verbose (int): Verbosity mode, 0 (silent), 1 (verbose), 2 (semi-verbose)
-        stateful_metrics (list|tuple): Iterable of string names of metrics that should *not* be
-            averaged over time. Metrics in this list will be displayed as-is. All
-            others will be averaged by the progbar before display.
-        interval (float): Minimum visual progress update interval (in seconds).
-        unit_name (str): Display name for step counts (usually "step" or "sample").
-    """
-
-    def __init__(self,
-                 target,
-                 width=30,
-                 verbose=1,
-                 interval=0.05,
-                 stateful_metrics=None,
-                 unit_name='step'):
-        self.target = target
-        self.width = width
-        self.verbose = verbose
-        self.interval = interval
-        self.unit_name = unit_name
-        if stateful_metrics:
-            self.stateful_metrics = set(stateful_metrics)
-        else:
-            self.stateful_metrics = set()
-
-        self._dynamic_display = (
-            (hasattr(sys.stderr, 'isatty') and
-             sys.stderr.isatty()) or 'ipykernel' in sys.modules or
-            'posix' in sys.modules or 'PYCHARM_HOSTED' in os.environ)
-        self._total_width = 0
-        self._seen_so_far = 0
-        # We use a dict + list to avoid garbage collection
-        # issues found in OrderedDict
-        self._values = {}
-        self._values_order = []
-        self._start = time.time()
-        self._last_update = 0
-
-    def update(self, current, values=None, finalize=None):
-        """
-        Updates the progress bar.
-
-        Args:
-            current (int): Index of current step.
-            values (list): List of tuples: `(name, value_for_last_step)`. If `name` is in
-                `stateful_metrics`, `value_for_last_step` will be displayed as-is.
-                Else, an average of the metric over time will be displayed.
-            finalize (bool): Whether this is the last update for the progress bar. If
-                `None`, defaults to `current >= self.target`.
-        """
-
-        if finalize is None:
-            if self.target is None:
-                finalize = False
-            else:
-                finalize = current >= self.target
-
-        values = values or []
-        for k, v in values:
-            if k not in self._values_order:
-                self._values_order.append(k)
-            if k not in self.stateful_metrics:
-                # In the case that progress bar doesn't have a target value in the first
-                # epoch, both on_batch_end and on_epoch_end will be called, which will
-                # cause 'current' and 'self._seen_so_far' to have the same value. Force
-                # the minimal value to 1 here, otherwise stateful_metric will be 0s.
-                value_base = max(current - self._seen_so_far, 1)
-                if k not in self._values:
-                    self._values[k] = [v * value_base, value_base]
-                else:
-                    self._values[k][0] += v * value_base
-                    self._values[k][1] += value_base
-            else:
-                # Stateful metrics output a numeric value. This representation
-                # means "take an average from a single value" but keeps the
-                # numeric formatting.
-                self._values[k] = [v, 1]
-        self._seen_so_far = current
-
-        now = time.time()
-        info = ' - %.0fs' % (now - self._start)
-        if self.verbose == 1:
-            if now - self._last_update < self.interval and not finalize:
-                return
-
-            prev_total_width = self._total_width
-            if self._dynamic_display:
-                sys.stderr.write('\b' * prev_total_width)
-                sys.stderr.write('\r')
-            else:
-                sys.stderr.write('\n')
-
-            if self.target is not None:
-                numdigits = int(np.log10(self.target)) + 1
-                bar = ('%' + str(numdigits) + 'd/%d [') % (current,
-                                                           self.target)
-                prog = float(current) / self.target
-                prog_width = int(self.width * prog)
-                if prog_width > 0:
-                    bar += ('=' * (prog_width - 1))
-                    if current < self.target:
-                        bar += '>'
-                    else:
-                        bar += '='
-                bar += ('.' * (self.width - prog_width))
-                bar += ']'
-            else:
-                bar = '%7d/Unknown' % current
-
-            self._total_width = len(bar)
-            sys.stderr.write(bar)
-
-            if current:
-                time_per_unit = (now - self._start) / current
-            else:
-                time_per_unit = 0
-
-            if self.target is None or finalize:
-                if time_per_unit >= 1 or time_per_unit == 0:
-                    info += ' %.0fs/%s' % (time_per_unit, self.unit_name)
-                elif time_per_unit >= 1e-3:
-                    info += ' %.0fms/%s' % (time_per_unit * 1e3,
-                                            self.unit_name)
-                else:
-                    info += ' %.0fus/%s' % (time_per_unit * 1e6,
-                                            self.unit_name)
-            else:
-                eta = time_per_unit * (self.target - current)
-                if eta > 3600:
-                    eta_format = '%d:%02d:%02d' % (eta // 3600, (eta % 3600) //
-                                                   60, eta % 60)
-                elif eta > 60:
-                    eta_format = '%d:%02d' % (eta // 60, eta % 60)
-                else:
-                    eta_format = '%ds' % eta
-
-                info = ' - ETA: %s' % eta_format
-
-            for k in self._values_order:
-                info += ' - %s:' % k
-                if isinstance(self._values[k], list):
-                    avg = np.mean(self._values[k][0] /
-                                  max(1, self._values[k][1]))
-                    if abs(avg) > 1e-3:
-                        info += ' %.4f' % avg
-                    else:
-                        info += ' %.4e' % avg
-                else:
-                    info += ' %s' % self._values[k]
-
-            self._total_width += len(info)
-            if prev_total_width > self._total_width:
-                info += (' ' * (prev_total_width - self._total_width))
-
-            if finalize:
-                info += '\n'
-
-            sys.stderr.write(info)
-            sys.stderr.flush()
-
-        elif self.verbose == 2:
-            if finalize:
-                numdigits = int(np.log10(self.target)) + 1
-                count = ('%' + str(numdigits) + 'd/%d') % (current,
-                                                           self.target)
-                info = count + info
-                for k in self._values_order:
-                    info += ' - %s:' % k
-                    avg = np.mean(self._values[k][0] /
-                                  max(1, self._values[k][1]))
-                    if avg > 1e-3:
-                        info += ' %.4f' % avg
-                    else:
-                        info += ' %.4e' % avg
-                info += '\n'
-
-                sys.stderr.write(info)
-                sys.stderr.flush()
-
-        self._last_update = now
-
-    def add(self, n, values=None):
-        self.update(self._seen_so_far + n, values)

paddlex/paddleseg/utils/timer.py

@@ -1,53 +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 time
-
-
-class TimeAverager(object):
-    def __init__(self):
-        self.reset()
-
-    def reset(self):
-        self._cnt = 0
-        self._total_time = 0
-        self._total_samples = 0
-
-    def record(self, usetime, num_samples=None):
-        self._cnt += 1
-        self._total_time += usetime
-        if num_samples:
-            self._total_samples += num_samples
-
-    def get_average(self):
-        if self._cnt == 0:
-            return 0
-        return self._total_time / float(self._cnt)
-
-    def get_ips_average(self):
-        if not self._total_samples or self._cnt == 0:
-            return 0
-        return float(self._total_samples) / self._total_time
-
-
-def calculate_eta(remaining_step, speed):
-    if remaining_step < 0:
-        remaining_step = 0
-    remaining_time = int(remaining_step * speed)
-    result = "{:0>2}:{:0>2}:{:0>2}"
-    arr = []
-    for i in range(2, -1, -1):
-        arr.append(int(remaining_time / 60**i))
-        remaining_time %= 60**i
-    return result.format(*arr)

paddlex/paddleseg/utils/utils.py

@@ -1,120 +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 contextlib
-import filelock
-import math
-import os
-import tempfile
-from urllib.parse import urlparse, unquote
-
-import paddle
-
-from paddlex.paddleseg.utils import logger, seg_env
-from paddlex.paddleseg.utils.download import download_file_and_uncompress
-
-
-@contextlib.contextmanager
-def generate_tempdir(directory: str=None, **kwargs):
-    '''Generate a temporary directory'''
-    directory = seg_env.TMP_HOME if not directory else directory
-    with tempfile.TemporaryDirectory(dir=directory, **kwargs) as _dir:
-        yield _dir
-
-
-def load_entire_model(model, pretrained):
-    if pretrained is not None:
-        load_pretrained_model(model, pretrained)
-    else:
-        logger.warning('Not all pretrained params of {} are loaded, ' \
-                       'training from scratch or a pretrained backbone.'.format(model.__class__.__name__))
-
-
-def load_pretrained_model(model, pretrained_model):
-    if pretrained_model is not None:
-        logger.info('Loading pretrained model from {}'.format(
-            pretrained_model))
-        # download pretrained model from url
-        if urlparse(pretrained_model).netloc:
-            pretrained_model = unquote(pretrained_model)
-            savename = pretrained_model.split('/')[-1]
-            if not savename.endswith(('tgz', 'tar.gz', 'tar', 'zip')):
-                savename = pretrained_model.split('/')[-2]
-            else:
-                savename = savename.split('.')[0]
-            with generate_tempdir() as _dir:
-                with filelock.FileLock(
-                        os.path.join(seg_env.TMP_HOME, savename)):
-                    pretrained_model = download_file_and_uncompress(
-                        pretrained_model,
-                        savepath=_dir,
-                        extrapath=seg_env.PRETRAINED_MODEL_HOME,
-                        extraname=savename)
-
-                    pretrained_model = os.path.join(pretrained_model,
-                                                    'model.pdparams')
-
-        if os.path.exists(pretrained_model):
-            para_state_dict = paddle.load(pretrained_model)
-
-            model_state_dict = model.state_dict()
-            keys = model_state_dict.keys()
-            num_params_loaded = 0
-            for k in keys:
-                if k not in para_state_dict:
-                    logger.warning("{} is not in pretrained model".format(k))
-                elif list(para_state_dict[k].shape) != list(model_state_dict[k]
-                                                            .shape):
-                    logger.warning(
-                        "[SKIP] Shape of pretrained params {} doesn't match.(Pretrained: {}, Actual: {})"
-                        .format(k, para_state_dict[k].shape, model_state_dict[
-                            k].shape))
-                else:
-                    model_state_dict[k] = para_state_dict[k]
-                    num_params_loaded += 1
-            model.set_dict(model_state_dict)
-            logger.info("There are {}/{} variables loaded into {}.".format(
-                num_params_loaded,
-                len(model_state_dict), model.__class__.__name__))
-
-        else:
-            raise ValueError('The pretrained model directory is not Found: {}'.
-                             format(pretrained_model))
-    else:
-        logger.info(
-            'No pretrained model to load, {} will be trained from scratch.'.
-            format(model.__class__.__name__))
-
-
-def resume(model, optimizer, resume_model):
-    if resume_model is not None:
-        logger.info('Resume model from {}'.format(resume_model))
-        if os.path.exists(resume_model):
-            resume_model = os.path.normpath(resume_model)
-            ckpt_path = os.path.join(resume_model, 'model.pdparams')
-            para_state_dict = paddle.load(ckpt_path)
-            ckpt_path = os.path.join(resume_model, 'model.pdopt')
-            opti_state_dict = paddle.load(ckpt_path)
-            model.set_state_dict(para_state_dict)
-            optimizer.set_state_dict(opti_state_dict)
-
-            iter = resume_model.split('_')[-1]
-            iter = int(iter)
-            return iter
-        else:
-            raise ValueError(
-                'Directory of the model needed to resume is not Found: {}'.
-                format(resume_model))
-    else:
-        logger.info('No model needed to resume.')

paddlex/paddleseg/utils/visualize.py

@@ -1,90 +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 os
-
-import cv2
-import numpy as np
-from PIL import Image as PILImage
-
-
-def visualize(image, result, save_dir=None, weight=0.6):
-    """
-    Convert predict result to color image, and save added image.
-
-    Args:
-        image (str): The path of origin image.
-        result (np.ndarray): The predict result of image.
-        save_dir (str): The directory for saving visual image. Default: None.
-        weight (float): The image weight of visual image, and the result weight is (1 - weight). Default: 0.6
-
-    Returns:
-        vis_result (np.ndarray): If `save_dir` is None, return the visualized result.
-    """
-
-    color_map = get_color_map_list(256)
-    color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
-    color_map = np.array(color_map).astype("uint8")
-    # Use OpenCV LUT for color mapping
-    c1 = cv2.LUT(result, color_map[:, 0])
-    c2 = cv2.LUT(result, color_map[:, 1])
-    c3 = cv2.LUT(result, color_map[:, 2])
-    pseudo_img = np.dstack((c1, c2, c3))
-
-    im = cv2.imread(image)
-    vis_result = cv2.addWeighted(im, weight, pseudo_img, 1 - weight, 0)
-
-    if save_dir is not None:
-        if not os.path.exists(save_dir):
-            os.makedirs(save_dir)
-        image_name = os.path.split(image)[-1]
-        out_path = os.path.join(save_dir, image_name)
-        cv2.imwrite(out_path, vis_result)
-    else:
-        return vis_result
-
-
-def get_pseudo_color_map(pred):
-    pred_mask = PILImage.fromarray(pred.astype(np.uint8), mode='P')
-    color_map = get_color_map_list(256)
-    pred_mask.putpalette(color_map)
-    return pred_mask
-
-
-def get_color_map_list(num_classes):
-    """
-    Returns the color map for visualizing the segmentation mask,
-    which can support arbitrary number of classes.
-
-    Args:
-        num_classes (int): Number of classes.
-
-    Returns:
-        (list). The color map.
-    """
-
-    num_classes += 1
-    color_map = num_classes * [0, 0, 0]
-    for i in range(0, num_classes):
-        j = 0
-        lab = i
-        while lab:
-            color_map[i * 3] |= (((lab >> 0) & 1) << (7 - j))
-            color_map[i * 3 + 1] |= (((lab >> 1) & 1) << (7 - j))
-            color_map[i * 3 + 2] |= (((lab >> 2) & 1) << (7 - j))
-            j += 1
-            lab >>= 3
-    # color_map = [color_map[i:i + 3] for i in range(0, len(color_map), 3)]
-    color_map = color_map[3:]
-    return color_map

paddlex/ppcls/__init__.py

@@ -1,20 +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 optimizer
-
-from .modeling import *
-from .optimizer import *
-from .data import *
-from .utils import *

paddlex/ppcls/data/__init__.py

@@ -1,15 +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 .reader import Reader

paddlex/ppcls/data/imaug/__init__.py

@@ -1,94 +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 .autoaugment import ImageNetPolicy as RawImageNetPolicy
-from .randaugment import RandAugment as RawRandAugment
-from .cutout import Cutout
-
-from .hide_and_seek import HideAndSeek
-from .random_erasing import RandomErasing
-from .grid import GridMask
-
-from .operators import DecodeImage
-from .operators import ResizeImage
-from .operators import CropImage
-from .operators import RandCropImage
-from .operators import RandFlipImage
-from .operators import NormalizeImage
-from .operators import ToCHWImage
-
-from .batch_operators import MixupOperator
-from .batch_operators import CutmixOperator
-from .batch_operators import FmixOperator
-
-import six
-import numpy as np
-from PIL import Image
-
-
-def transform(data, ops=[]):
-    """ transform """
-    for op in ops:
-        data = op(data)
-    return data
-
-
-class AutoAugment(RawImageNetPolicy):
-    """ ImageNetPolicy wrapper to auto fit different img types """
-
-    def __init__(self, *args, **kwargs):
-        if six.PY2:
-            super(AutoAugment, self).__init__(*args, **kwargs)
-        else:
-            super().__init__(*args, **kwargs)
-
-    def __call__(self, img):
-        if not isinstance(img, Image.Image):
-            img = np.ascontiguousarray(img)
-            img = Image.fromarray(img)
-
-        if six.PY2:
-            img = super(AutoAugment, self).__call__(img)
-        else:
-            img = super().__call__(img)
-
-        if isinstance(img, Image.Image):
-            img = np.asarray(img)
-
-        return img
-
-
-class RandAugment(RawRandAugment):
-    """ RandAugment wrapper to auto fit different img types """
-
-    def __init__(self, *args, **kwargs):
-        if six.PY2:
-            super(RandAugment, self).__init__(*args, **kwargs)
-        else:
-            super().__init__(*args, **kwargs)
-
-    def __call__(self, img):
-        if not isinstance(img, Image.Image):
-            img = np.ascontiguousarray(img)
-            img = Image.fromarray(img)
-
-        if six.PY2:
-            img = super(RandAugment, self).__call__(img)
-        else:
-            img = super().__call__(img)
-
-        if isinstance(img, Image.Image):
-            img = np.asarray(img)
-
-        return img