paddlex 2.1.0__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

paddlex/ppdet/utils/profiler.py

@@ -1,111 +0,0 @@
-# Copyright (c) 2021 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 paddle
-
-# A global variable to record the number of calling times for profiler
-# functions. It is used to specify the tracing range of training steps.
-_profiler_step_id = 0
-
-# A global variable to avoid parsing from string every time.
-_profiler_options = None
-
-
-class ProfilerOptions(object):
-    '''
-    Use a string to initialize a ProfilerOptions.
-    The string should be in the format: "key1=value1;key2=value;key3=value3".
-    For example:
-      "profile_path=model.profile"
-      "batch_range=[50, 60]; profile_path=model.profile"
-      "batch_range=[50, 60]; tracer_option=OpDetail; profile_path=model.profile"
-
-    ProfilerOptions supports following key-value pair:
-      batch_range      - a integer list, e.g. [100, 110].
-      state            - a string, the optional values are 'CPU', 'GPU' or 'All'.
-      sorted_key       - a string, the optional values are 'calls', 'total',
-                         'max', 'min' or 'ave.
-      tracer_option    - a string, the optional values are 'Default', 'OpDetail',
-                         'AllOpDetail'.
-      profile_path     - a string, the path to save the serialized profile data,
-                         which can be used to generate a timeline.
-      exit_on_finished - a boolean.
-    '''
-
-    def __init__(self, options_str):
-        assert isinstance(options_str, str)
-
-        self._options = {
-            'batch_range': [10, 20],
-            'state': 'All',
-            'sorted_key': 'total',
-            'tracer_option': 'Default',
-            'profile_path': '/tmp/profile',
-            'exit_on_finished': True
-        }
-        self._parse_from_string(options_str)
-
-    def _parse_from_string(self, options_str):
-        for kv in options_str.replace(' ', '').split(';'):
-            key, value = kv.split('=')
-            if key == 'batch_range':
-                value_list = value.replace('[', '').replace(']', '').split(',')
-                value_list = list(map(int, value_list))
-                if len(value_list) >= 2 and value_list[0] >= 0 and value_list[
-                        1] > value_list[0]:
-                    self._options[key] = value_list
-            elif key == 'exit_on_finished':
-                self._options[key] = value.lower() in ("yes", "true", "t", "1")
-            elif key in [
-                    'state', 'sorted_key', 'tracer_option', 'profile_path'
-            ]:
-                self._options[key] = value
-
-    def __getitem__(self, name):
-        if self._options.get(name, None) is None:
-            raise ValueError(
-                "ProfilerOptions does not have an option named %s." % name)
-        return self._options[name]
-
-
-def add_profiler_step(options_str=None):
-    '''
-    Enable the operator-level timing using PaddlePaddle's profiler.
-    The profiler uses a independent variable to count the profiler steps.
-    One call of this function is treated as a profiler step.
-
-    Args:
-      profiler_options - a string to initialize the ProfilerOptions.
-                         Default is None, and the profiler is disabled.
-    '''
-    if options_str is None:
-        return
-
-    global _profiler_step_id
-    global _profiler_options
-
-    if _profiler_options is None:
-        _profiler_options = ProfilerOptions(options_str)
-
-    if _profiler_step_id == _profiler_options['batch_range'][0]:
-        paddle.utils.profiler.start_profiler(
-            _profiler_options['state'], _profiler_options['tracer_option'])
-    elif _profiler_step_id == _profiler_options['batch_range'][1]:
-        paddle.utils.profiler.stop_profiler(_profiler_options['sorted_key'],
-                                            _profiler_options['profile_path'])
-        if _profiler_options['exit_on_finished']:
-            sys.exit(0)
-
-    _profiler_step_id += 1

paddlex/ppdet/utils/stats.py

@@ -1,94 +0,0 @@
-# Copyright (c) 2019 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 collections
-import numpy as np
-
-__all__ = ['SmoothedValue', 'TrainingStats']
-
-
-class SmoothedValue(object):
-    """Track a series of values and provide access to smoothed values over a
-    window or the global series average.
-    """
-
-    def __init__(self, window_size=20, fmt=None):
-        if fmt is None:
-            fmt = "{median:.4f} ({avg:.4f})"
-        self.deque = collections.deque(maxlen=window_size)
-        self.fmt = fmt
-        self.total = 0.
-        self.count = 0
-
-    def update(self, value, n=1):
-        self.deque.append(value)
-        self.count += n
-        self.total += value * n
-
-    @property
-    def median(self):
-        return np.median(self.deque)
-
-    @property
-    def avg(self):
-        return np.mean(self.deque)
-
-    @property
-    def max(self):
-        return np.max(self.deque)
-
-    @property
-    def value(self):
-        return self.deque[-1]
-
-    @property
-    def global_avg(self):
-        return self.total / self.count
-
-    def __str__(self):
-        return self.fmt.format(
-            median=self.median, avg=self.avg, max=self.max, value=self.value)
-
-
-class TrainingStats(object):
-    def __init__(self, window_size, delimiter=' '):
-        self.meters = None
-        self.window_size = window_size
-        self.delimiter = delimiter
-
-    def update(self, stats):
-        if self.meters is None:
-            self.meters = {
-                k: SmoothedValue(self.window_size)
-                for k in stats.keys()
-            }
-        for k, v in self.meters.items():
-            v.update(stats[k].numpy())
-
-    def get(self, extras=None):
-        stats = collections.OrderedDict()
-        if extras:
-            for k, v in extras.items():
-                stats[k] = v
-        for k, v in self.meters.items():
-            stats[k] = format(v.median, '.6f')
-
-        return stats
-
-    def log(self, extras=None):
-        d = self.get(extras)
-        strs = []
-        for k, v in d.items():
-            strs.append("{}: {}".format(k, str(v)))
-        return self.delimiter.join(strs)

paddlex/ppdet/utils/visualizer.py

@@ -1,321 +0,0 @@
-# Copyright (c) 2019 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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
-import numpy as np
-from PIL import Image, ImageDraw
-import cv2
-import math
-
-from .colormap import colormap
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-__all__ = ['visualize_results']
-
-
-def visualize_results(image,
-                      bbox_res,
-                      mask_res,
-                      segm_res,
-                      keypoint_res,
-                      im_id,
-                      catid2name,
-                      threshold=0.5):
-    """
-    Visualize bbox and mask results
-    """
-    if bbox_res is not None:
-        image = draw_bbox(image, im_id, catid2name, bbox_res, threshold)
-    if mask_res is not None:
-        image = draw_mask(image, im_id, mask_res, threshold)
-    if segm_res is not None:
-        image = draw_segm(image, im_id, catid2name, segm_res, threshold)
-    if keypoint_res is not None:
-        image = draw_pose(image, keypoint_res, threshold)
-    return image
-
-
-def draw_mask(image, im_id, segms, threshold, alpha=0.7):
-    """
-    Draw mask on image
-    """
-    mask_color_id = 0
-    w_ratio = .4
-    color_list = colormap(rgb=True)
-    img_array = np.array(image).astype('float32')
-    for dt in np.array(segms):
-        if im_id != dt['image_id']:
-            continue
-        segm, score = dt['segmentation'], dt['score']
-        if score < threshold:
-            continue
-        import pycocotools.mask as mask_util
-        mask = mask_util.decode(segm) * 255
-        color_mask = color_list[mask_color_id % len(color_list), 0:3]
-        mask_color_id += 1
-        for c in range(3):
-            color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio * 255
-        idx = np.nonzero(mask)
-        img_array[idx[0], idx[1], :] *= 1.0 - alpha
-        img_array[idx[0], idx[1], :] += alpha * color_mask
-    return Image.fromarray(img_array.astype('uint8'))
-
-
-def draw_bbox(image, im_id, catid2name, bboxes, threshold):
-    """
-    Draw bbox on image
-    """
-    draw = ImageDraw.Draw(image)
-
-    catid2color = {}
-    color_list = colormap(rgb=True)[:40]
-    for dt in np.array(bboxes):
-        if im_id != dt['image_id']:
-            continue
-        catid, bbox, score = dt['category_id'], dt['bbox'], dt['score']
-        if score < threshold:
-            continue
-
-        if catid not in catid2color:
-            idx = np.random.randint(len(color_list))
-            catid2color[catid] = color_list[idx]
-        color = tuple(catid2color[catid])
-
-        # draw bbox
-        if len(bbox) == 4:
-            # draw bbox
-            xmin, ymin, w, h = bbox
-            xmax = xmin + w
-            ymax = ymin + h
-            draw.line(
-                [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin),
-                 (xmin, ymin)],
-                width=2,
-                fill=color)
-        elif len(bbox) == 8:
-            x1, y1, x2, y2, x3, y3, x4, y4 = bbox
-            draw.line(
-                [(x1, y1), (x2, y2), (x3, y3), (x4, y4), (x1, y1)],
-                width=2,
-                fill=color)
-            xmin = min(x1, x2, x3, x4)
-            ymin = min(y1, y2, y3, y4)
-        else:
-            logger.error('the shape of bbox must be [M, 4] or [M, 8]!')
-
-        # draw label
-        text = "{} {:.2f}".format(catid2name[catid], score)
-        tw, th = draw.textsize(text)
-        draw.rectangle(
-            [(xmin + 1, ymin - th), (xmin + tw + 1, ymin)], fill=color)
-        draw.text((xmin + 1, ymin - th), text, fill=(255, 255, 255))
-
-    return image
-
-
-def save_result(save_path, results, catid2name, threshold):
-    """
-    save result as txt
-    """
-    img_id = int(results["im_id"])
-    with open(save_path, 'w') as f:
-        if "bbox_res" in results:
-            for dt in results["bbox_res"]:
-                catid, bbox, score = dt['category_id'], dt['bbox'], dt['score']
-                if score < threshold:
-                    continue
-                # each bbox result as a line
-                # for rbox: classname score x1 y1 x2 y2 x3 y3 x4 y4
-                # for bbox: classname score x1 y1 w h
-                bbox_pred = '{} {} '.format(catid2name[catid],
-                                            score) + ' '.join(
-                                                [str(e) for e in bbox])
-                f.write(bbox_pred + '\n')
-        elif "keypoint_res" in results:
-            for dt in results["keypoint_res"]:
-                kpts = dt['keypoints']
-                scores = dt['score']
-                keypoint_pred = [img_id, scores, kpts]
-                print(keypoint_pred, file=f)
-        else:
-            print("No valid results found, skip txt save")
-
-
-def draw_segm(image,
-              im_id,
-              catid2name,
-              segms,
-              threshold,
-              alpha=0.7,
-              draw_box=True):
-    """
-    Draw segmentation on image
-    """
-    mask_color_id = 0
-    w_ratio = .4
-    color_list = colormap(rgb=True)
-    img_array = np.array(image).astype('float32')
-    for dt in np.array(segms):
-        if im_id != dt['image_id']:
-            continue
-        segm, score, catid = dt['segmentation'], dt['score'], dt['category_id']
-        if score < threshold:
-            continue
-        import pycocotools.mask as mask_util
-        mask = mask_util.decode(segm) * 255
-        color_mask = color_list[mask_color_id % len(color_list), 0:3]
-        mask_color_id += 1
-        for c in range(3):
-            color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio * 255
-        idx = np.nonzero(mask)
-        img_array[idx[0], idx[1], :] *= 1.0 - alpha
-        img_array[idx[0], idx[1], :] += alpha * color_mask
-
-        if not draw_box:
-            center_y, center_x = ndimage.measurements.center_of_mass(mask)
-            label_text = "{}".format(catid2name[catid])
-            vis_pos = (max(int(center_x) - 10, 0), int(center_y))
-            cv2.putText(img_array, label_text, vis_pos,
-                        cv2.FONT_HERSHEY_COMPLEX, 0.3, (255, 255, 255))
-        else:
-            mask = mask_util.decode(segm) * 255
-            sum_x = np.sum(mask, axis=0)
-            x = np.where(sum_x > 0.5)[0]
-            sum_y = np.sum(mask, axis=1)
-            y = np.where(sum_y > 0.5)[0]
-            x0, x1, y0, y1 = x[0], x[-1], y[0], y[-1]
-            cv2.rectangle(img_array, (x0, y0), (x1, y1),
-                          tuple(color_mask.astype('int32').tolist()), 1)
-            bbox_text = '%s %.2f' % (catid2name[catid], score)
-            t_size = cv2.getTextSize(bbox_text, 0, 0.3, thickness=1)[0]
-            cv2.rectangle(img_array, (x0, y0), (x0 + t_size[0],
-                                                y0 - t_size[1] - 3),
-                          tuple(color_mask.astype('int32').tolist()), -1)
-            cv2.putText(
-                img_array,
-                bbox_text, (x0, y0 - 2),
-                cv2.FONT_HERSHEY_SIMPLEX,
-                0.3, (0, 0, 0),
-                1,
-                lineType=cv2.LINE_AA)
-
-    return Image.fromarray(img_array.astype('uint8'))
-
-
-def draw_pose(image,
-              results,
-              visual_thread=0.6,
-              save_name='pose.jpg',
-              save_dir='output',
-              returnimg=False,
-              ids=None):
-    try:
-        import matplotlib.pyplot as plt
-        import matplotlib
-        plt.switch_backend('agg')
-    except Exception as e:
-        logger.error('Matplotlib not found, please install matplotlib.'
-                     'for example: `pip install matplotlib`.')
-        raise e
-
-    skeletons = np.array([item['keypoints'] for item in results])
-    kpt_nums = 17
-    if len(skeletons) > 0:
-        kpt_nums = int(skeletons.shape[1] / 3)
-    skeletons = skeletons.reshape(-1, kpt_nums, 3)
-    if kpt_nums == 17:  #plot coco keypoint
-        EDGES = [(0, 1), (0, 2), (1, 3), (2, 4), (3, 5), (4, 6), (5, 7),
-                 (6, 8), (7, 9), (8, 10), (5, 11), (6, 12), (11, 13), (12, 14),
-                 (13, 15), (14, 16), (11, 12)]
-    else:  #plot mpii keypoint
-        EDGES = [(0, 1), (1, 2), (3, 4), (4, 5), (2, 6), (3, 6), (6, 7),
-                 (7, 8), (8, 9), (10, 11), (11, 12), (13, 14), (14, 15),
-                 (8, 12), (8, 13)]
-    NUM_EDGES = len(EDGES)
-
-    colors = [[255, 0, 0], [255, 85, 0], [255, 170, 0], [255, 255, 0], [170, 255, 0], [85, 255, 0], [0, 255, 0], \
-            [0, 255, 85], [0, 255, 170], [0, 255, 255], [0, 170, 255], [0, 85, 255], [0, 0, 255], [85, 0, 255], \
-            [170, 0, 255], [255, 0, 255], [255, 0, 170], [255, 0, 85]]
-    cmap = matplotlib.cm.get_cmap('hsv')
-    plt.figure()
-
-    img = np.array(image).astype('float32')
-
-    color_set = results['colors'] if 'colors' in results else None
-
-    if 'bbox' in results and ids is None:
-        bboxs = results['bbox']
-        for j, rect in enumerate(bboxs):
-            xmin, ymin, xmax, ymax = rect
-            color = colors[0] if color_set is None else colors[color_set[j] %
-                                                               len(colors)]
-            cv2.rectangle(img, (xmin, ymin), (xmax, ymax), color, 1)
-
-    canvas = img.copy()
-    for i in range(kpt_nums):
-        for j in range(len(skeletons)):
-            if skeletons[j][i, 2] < visual_thread:
-                continue
-            if ids is None:
-                color = colors[i] if color_set is None else colors[color_set[j]
-                                                                   %
-                                                                   len(colors)]
-            else:
-                color = get_color(ids[j])
-
-            cv2.circle(
-                canvas,
-                tuple(skeletons[j][i, 0:2].astype('int32')),
-                2,
-                color,
-                thickness=-1)
-
-    to_plot = cv2.addWeighted(img, 0.3, canvas, 0.7, 0)
-    fig = matplotlib.pyplot.gcf()
-
-    stickwidth = 2
-
-    for i in range(NUM_EDGES):
-        for j in range(len(skeletons)):
-            edge = EDGES[i]
-            if skeletons[j][edge[0], 2] < visual_thread or skeletons[j][edge[
-                    1], 2] < visual_thread:
-                continue
-
-            cur_canvas = canvas.copy()
-            X = [skeletons[j][edge[0], 1], skeletons[j][edge[1], 1]]
-            Y = [skeletons[j][edge[0], 0], skeletons[j][edge[1], 0]]
-            mX = np.mean(X)
-            mY = np.mean(Y)
-            length = ((X[0] - X[1])**2 + (Y[0] - Y[1])**2)**0.5
-            angle = math.degrees(math.atan2(X[0] - X[1], Y[0] - Y[1]))
-            polygon = cv2.ellipse2Poly((int(mY), int(mX)),
-                                       (int(length / 2), stickwidth),
-                                       int(angle), 0, 360, 1)
-            if ids is None:
-                color = colors[i] if color_set is None else colors[color_set[j]
-                                                                   %
-                                                                   len(colors)]
-            else:
-                color = get_color(ids[j])
-            cv2.fillConvexPoly(cur_canvas, polygon, color)
-            canvas = cv2.addWeighted(canvas, 0.4, cur_canvas, 0.6, 0)
-    image = Image.fromarray(canvas.astype('uint8'))
-    plt.close()
-    return image

paddlex/ppdet/utils/voc_utils.py

@@ -1,86 +0,0 @@
-# Copyright (c) 2019 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 __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-
-import os
-import os.path as osp
-import re
-import random
-
-__all__ = ['create_list']
-
-
-def create_list(devkit_dir, years, output_dir):
-    """
-    create following list:
-        1. trainval.txt
-        2. test.txt
-    """
-    trainval_list = []
-    test_list = []
-    for year in years:
-        trainval, test = _walk_voc_dir(devkit_dir, year, output_dir)
-        trainval_list.extend(trainval)
-        test_list.extend(test)
-
-    random.shuffle(trainval_list)
-    with open(osp.join(output_dir, 'trainval.txt'), 'w') as ftrainval:
-        for item in trainval_list:
-            ftrainval.write(item[0] + ' ' + item[1] + '\n')
-
-    with open(osp.join(output_dir, 'test.txt'), 'w') as fval:
-        ct = 0
-        for item in test_list:
-            ct += 1
-            fval.write(item[0] + ' ' + item[1] + '\n')
-
-
-def _get_voc_dir(devkit_dir, year, type):
-    return osp.join(devkit_dir, 'VOC' + year, type)
-
-
-def _walk_voc_dir(devkit_dir, year, output_dir):
-    filelist_dir = _get_voc_dir(devkit_dir, year, 'ImageSets/Main')
-    annotation_dir = _get_voc_dir(devkit_dir, year, 'Annotations')
-    img_dir = _get_voc_dir(devkit_dir, year, 'JPEGImages')
-    trainval_list = []
-    test_list = []
-    added = set()
-
-    for _, _, files in os.walk(filelist_dir):
-        for fname in files:
-            img_ann_list = []
-            if re.match(r'[a-z]+_trainval\.txt', fname):
-                img_ann_list = trainval_list
-            elif re.match(r'[a-z]+_test\.txt', fname):
-                img_ann_list = test_list
-            else:
-                continue
-            fpath = osp.join(filelist_dir, fname)
-            for line in open(fpath):
-                name_prefix = line.strip().split()[0]
-                if name_prefix in added:
-                    continue
-                added.add(name_prefix)
-                ann_path = osp.join(
-                    osp.relpath(annotation_dir, output_dir),
-                    name_prefix + '.xml')
-                img_path = osp.join(
-                    osp.relpath(img_dir, output_dir), name_prefix + '.jpg')
-                img_ann_list.append((img_path, ann_path))
-
-    return trainval_list, test_list

paddlex/seg.py

@@ -1,41 +0,0 @@
-# Copyright (c) 2021 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
-from . import cv
-from .cv.models.utils.visualize import visualize_segmentation
-
-
-message = 'Your script can be run normally only under PaddleX<2.0.0 ' + \
-    'but the installed PaddleX version is greater than or equal to 2.0.0, ' + \
-    'the solution is writen in the link {}, please refer to this link ro solve this issue.'.format(
-        'https://github.com/PaddlePaddle/PaddleX/tree/develop/tutorials/train#%E7%89%88%E6%9C%AC%E5%8D%87%E7%BA%A7'
-    )
-
-
-def __getattr__(attr):
-    if attr == 'transforms':
-
-        print("\033[1;31;40m{}\033[0m".format(message).encode("utf-8")
-              .decode("latin1"))
-        sys.exit(-1)
-
-
-visualize = visualize_segmentation
-
-UNet = cv.models.UNet
-DeepLabV3P = cv.models.DeepLabV3P
-FastSCNN = cv.models.FastSCNN
-HRNet = cv.models.HRNet
-BiSeNetV2 = cv.models.BiSeNetV2

paddlex/tools/__init__.py

@@ -1,17 +0,0 @@
-# Copyright (c) 2021 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 .split import dataset_split
-from .convert import dataset_conversion
-from .anchor_clustering import YOLOAnchorCluster

paddlex/tools/anchor_clustering/__init__.py

@@ -1,15 +0,0 @@
-# Copyright (c) 2021 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 .yolo_cluster import YOLOAnchorCluster