Upload 3 files

LICENSE (1).txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024 Eden Grad and Moshe Kimhi, Technion IIT.
+
+   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.

README.md

@@ -1,3 +1,52 @@
----
-license: apache-2.0
----
+# Noisy-Labels-Instance-Segmentation
+## This is the official repo for the paper A Benchmark for Learning with Noisy Labels in Instance Segmentation
+
+![paper meme](https://github.com/eden500/Noisy-Labels-Instance-Segmentation/assets/66938362/e786140b-cd28-41d3-8193-2529f1ed37d5)
+
+### ReadMe:
+Important! The original annotations should be in coco format.
+
+To run the benchmark, run the following:
+```
+python noise_annotations.py /path/to/annotations --benchmark {easy, medium, hard} (choose the benchmark level) --seed 1
+```
+
+For example:
+```
+python noise_annotations.py /path/to/annotations --benchmark easy --seed 1
+```
+
+
+To run a custom noise method, run the following:
+```
+python noise_annotations.py /path/to/annotations --method_name method_name --corruption_values [{'rand': [scale_proportion, kernel_size(should be odd number)],'localization': [scale_proportion, std_dev], 'approximation': [scale_proportion, tolerance], 'flip_class': percent_class_noise}]}]
+```
+
+For example:
+```
+ python noise_annotations.py /path/to/annotations --method_name my_noise_method --corruption_values [{'rand': [0.2, 3], 'localization': [0.2, 2], 'approximation': [0.2, 5], 'flip_class': 0.2}]
+```
+
+
+## Citation
+
+
+If you use this benchmark in your research, please cite this project.
+
+
+```
+Bibtex will be avalible shortly
+```
+
+
+## License
+
+This project is released under the [Apache 2.0 license](https://github.com/eden500/Noisy-Labels-Instance-Segmentation/blob/main/LICENSE.txt).
+
+
+Please make sure you use it with proper licenced Datasets.
+
+We use [MS-COCO/LVIS](https://cocodataset.org/#termsofuse) and [Cityscapes](https://www.cityscapes-dataset.com/license/)
+
+
+![image](https://github.com/eden500/Noisy-Labels-Instance-Segmentation/assets/66938362/3e22ad79-3f12-4767-b994-2df57dd265e7)

noise_annotations.py

@@ -0,0 +1,314 @@
+import json
+import os
+import numpy as np
+import cv2
+from pycocotools.coco import COCO
+from pycocotools import mask as maskUtils
+from shapely.geometry import Polygon
+from tqdm import tqdm
+import random
+import argparse
+
+
+def create_single_corruption_folder_copy_file(corruption_str, original_annotations_path, method_name):
+    """
+    Creates new folders and copies the original annotation file to the new folder for later modification.
+    """
+    base_path = f'noisy_data_{method_name}/coco_ann{corruption_str}'
+    os.makedirs(f'{base_path}/train', exist_ok=True)
+    os.makedirs(f'{base_path}/val', exist_ok=True)
+
+    for split in ['train', 'val']:
+        original_annotation_path = f'{original_annotations_path}/instances_{split}2017.json'
+        destination_path = f'{base_path}/{split}'
+        os.system(f'cp {original_annotation_path} {destination_path}')
+
+    print(f'Created folder and copied annotation file for {corruption_str}')
+
+
+def create_new_folders_and_copy_files(original_annotations_path, method_name, corruption_distances):
+    """
+    Creates new folders and copies files for the corrupted dataset.
+    """
+    name_to_add = f'_{method_name}_'
+
+    for corruption_d in corruption_distances:
+        if isinstance(corruption_d, dict):
+            corruption_str = name_to_add + '_'.join(f'{k}_{str(v).replace(" ", "")}' for k, v in corruption_d.items()) + '_'
+        else:
+            corruption_str = name_to_add + str(corruption_d)
+
+        create_single_corruption_folder_copy_file(corruption_str, original_annotations_path, method_name)
+
+def pick_noise(probabilities):
+    # Calculate the remaining probability for no noise.
+    remaining_probability = 1 - sum(p[0] for p in probabilities.values())
+    probabilities['none'] = [remaining_probability, None]
+
+    keys = list(probabilities.keys())
+    probs = [probabilities[key][0] for key in keys]
+    chosen_key = random.choices(keys, weights=probs, k=1)[0]
+    return chosen_key, probabilities[chosen_key][1]
+
+
+def new_boundaries_with_prob(d, coco, ann_id, file, annotation):
+    """
+    Modifies the boundaries of an annotation with a given probability.
+    """
+    current_ann = coco.loadAnns(ann_id)[0]
+    mask = coco.annToMask(current_ann)
+
+    changed_class = False
+    if 'flip_class' in d:
+        boundary_ver = 'flip_class'
+        cat_to_index_dict, index_to_cat_dict = get_index_cat_dicts(file)
+        num_classes = get_num_classes(file)
+        percent_noise = d.pop('flip_class')
+        C = uniform_mix_C(percent_noise, num_classes) if boundary_ver == 'flip_class'\
+            else uniform_assymetric_mix_C(percent_noise, file, cat_to_index_dict, num_classes) # to support assym later
+        change_category_with_confusion_matrix_single(annotation, C, cat_to_index_dict, index_to_cat_dict)
+        changed_class = annotation['category_id'] != current_ann['category_id']
+
+    noise_type, k = pick_noise(d)
+
+    if noise_type == 'rand':
+        kernel = np.ones((k, k), np.uint8)
+        new_mask = cv2.dilate(mask, kernel, iterations=1) if np.random.rand() < 0.5 else cv2.erode(mask, kernel, iterations=1)
+    elif noise_type == 'localization':
+        new_mask = add_localization_noise(mask, k)
+    elif noise_type == 'approximation':
+        new_mask = add_approximation_noise(mask, k)
+    elif noise_type == 'none':
+        new_mask = mask
+    else:
+        raise ValueError(f'Unknown boundary version: {noise_type}')
+
+    # Convert modified mask back to RLE
+    rle_modified = maskUtils.encode(np.asfortranarray(new_mask))
+    rle_modified['counts'] = rle_modified['counts'].decode('utf-8') if isinstance(rle_modified['counts'], bytes) else rle_modified['counts']
+
+    return rle_modified, noise_type, changed_class
+
+
+def change_boundaries_for_file(file, coco, d, seed=1):
+    """
+    Changes the boundaries for all annotations in a given file.
+    """
+    if seed is not None:
+        np.random.seed(seed)
+
+    for annotation in tqdm(file['annotations']):
+        new_mask, chosen_type, class_noise = new_boundaries_with_prob(d.copy(), coco, annotation['id'], file, annotation)
+        if chosen_type != 'none':
+            annotation['boundary_type'] = chosen_type
+            annotation['segmentation'] = new_mask
+        else:
+            annotation['boundary_type'] = 'none'
+        if class_noise:
+            annotation['class_noise'] = True
+        else:
+            annotation['class_noise'] = False
+
+
+def noise_annotations(method_name, corruption_distances, seed=1):
+    """
+    Adds noise to the annotations.
+    """
+    first_dir = f'noisy_data_{method_name}'
+    name_to_add = f'_{method_name}_'
+
+    for corruption_d in corruption_distances:
+        corruption_str = name_to_add + ('_'.join(f'{k}_{str(v).replace(" ", "")}' for k, v in corruption_d.items()) + '_' if isinstance(corruption_d, dict) else str(corruption_d))
+
+        for split in ['train', 'val']:
+            with open(f'{first_dir}/coco_ann{corruption_str}/{split}/instances_{split}2017.json') as f:
+                ann = json.load(f)
+
+            coco = COCO(f'{first_dir}/coco_ann{corruption_str}/{split}/instances_{split}2017.json')
+            change_boundaries_for_file(ann, coco, corruption_d, seed)
+
+            with open(f'{first_dir}/coco_ann{corruption_str}/{split}/instances_{split}2017.json', 'w') as f:
+                json.dump(ann, f)
+
+        print(f'Finished {corruption_str}')
+
+
+def mask_to_polygon(mask):
+    """
+    Converts a mask to a polygon.
+    """
+    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    return [contour[:, 0, :] for contour in contours] if contours else []
+
+
+def polygon_to_mask(polygon, h, w):
+    """
+    Converts a polygon to a mask.
+    """
+    mask = np.zeros((h, w), dtype=np.uint8)
+    cv2.fillPoly(mask, [polygon], 1)
+    return mask
+
+
+def add_gaussian_noise(vertices, mean=0, std_dev=1):
+    """
+    Adds Gaussian noise to each vertex in a polygon.
+    """
+    noise = np.random.normal(mean, std_dev, vertices.shape)
+    return np.round(vertices + noise).astype(int)
+
+
+def add_localization_noise(mask, std_dev=1):
+    """
+    Adds Gaussian noise to the vertices of the polygon.
+    """
+    if np.sum(mask) == 0:
+        return mask
+
+    final_mask_noisy = np.zeros(mask.shape, dtype=np.uint8)
+    for polygon in mask_to_polygon(mask):
+        vertices_noisy = add_gaussian_noise(polygon, std_dev=std_dev)
+        final_mask_noisy = np.maximum(final_mask_noisy, polygon_to_mask(vertices_noisy, mask.shape[0], mask.shape[1]))
+
+    return final_mask_noisy
+
+
+def simplify_polygon(polygon, tolerance):
+    """
+    Simplifies the polygon by removing vertices.
+    """
+    if len(polygon) < 4:
+        return None
+
+    shapely_polygon = Polygon(polygon)
+    return shapely_polygon.simplify(tolerance, preserve_topology=True)
+
+
+def simplified_polygon_to_mask(simplified_polygon, h, w):
+    """
+    Converts a simplified polygon back to a mask.
+    """
+    new_mask = np.zeros((h, w), dtype=np.uint8)
+    simplified_coords = np.array(simplified_polygon.exterior.coords).reshape((-1, 1, 2))
+    cv2.fillPoly(new_mask, [simplified_coords.astype(np.int32)], color=(1))
+    return new_mask
+
+
+def add_approximation_noise(mask, tolerance):
+    """
+    Adds noise to the vertices of the polygon by simplifying it.
+    """
+    if np.sum(mask) == 0:
+        return mask
+
+    final_mask_noisy = np.zeros(mask.shape, dtype=np.uint8)
+    for polygon in mask_to_polygon(mask):
+        simplified_polygon = simplify_polygon(polygon, tolerance)
+        if simplified_polygon is None:
+            continue
+        mask_noisy = simplified_polygon_to_mask(simplified_polygon, mask.shape[0], mask.shape[1])
+        final_mask_noisy = np.maximum(final_mask_noisy, mask_noisy)
+
+    return final_mask_noisy
+
+
+def change_category_with_confusion_matrix_single(annotation, C, cat_to_index_dict, index_to_cat_dict):
+    """
+    Changes the category_id of an annotation based on a confusion matrix.
+    """
+    chosen_index = np.random.choice(np.arange(C.shape[1]), p=C[cat_to_index_dict[annotation['category_id']]])
+    annotation['category_id'] = index_to_cat_dict[chosen_index]
+
+
+def get_index_cat_dicts(ann):
+    """
+    Returns dictionaries mapping category_id to index and vice versa.
+    """
+    cat_to_index_dict = {cat_info['id']: i for i, cat_info in enumerate(ann['categories'])}
+    index_to_cat_dict = {i: cat_info['id'] for i, cat_info in enumerate(ann['categories'])}
+    return cat_to_index_dict, index_to_cat_dict
+
+
+def get_num_classes(ann):
+    """
+    Returns the number of classes in the dataset.
+    """
+    return len(ann['categories'])
+
+
+def uniform_mix_C(mixing_ratio, num_classes):
+    """
+    Returns a linear interpolation of a uniform matrix and an identity matrix.
+    """
+    return mixing_ratio * np.full((num_classes, num_classes), 1 / num_classes) + (1 - mixing_ratio) * np.eye(num_classes)
+
+
+def uniform_assymetric_mix_C(mixing_ratio, ann, cat_to_index_dict, num_classes):
+    """
+    Returns a matrix with (1 - corruption_prob) on the diagonals, and corruption_prob
+    concentrated in only one other entry for each row.
+    """
+    subcat_dict = {cat_info['supercategory']: [] for cat_info in ann['categories']}
+    for cat_info in ann['categories']:
+        subcat_dict[cat_info['supercategory']].append(cat_to_index_dict[cat_info['id']])
+
+    C = np.zeros((num_classes, num_classes))
+    for i in range(num_classes):
+        C[i][subcat_dict[ann['categories'][i]['supercategory']]] = mixing_ratio * 1 / len(subcat_dict[ann['categories'][i]['supercategory']])
+        C[i][i] += 1 - mixing_ratio
+    return C
+
+
+def argument_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('annotations_path', type=str, help='The path to the original annotations')
+    parser.add_argument('--method_name', type=str, default='custom_method', help='The name of the method to be used for the corruption')
+    parser.add_argument('--benchmark', type=str, default='', help='The benchmark to be used for the corruption')
+    parser.add_argument('--corruption_values', type=list, default=[{'rand': [1, 3]}], help='The values to be used for the corruption')
+    parser.add_argument('--seed', type=int, default=1, help='The seed to be used for the random noise')
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    args = argument_parser()
+
+    Benchmarks = {
+        'easy':
+            {'approximation': [0.2, 5], 'localization': [0.2, 2], 'rand': [0.2, 3], 'flip_class': 0.2},
+        'medium':
+            {'approximation': [0.25, 10], 'localization': [0.25, 3], 'rand': [0.25, 5], 'flip_class': 0.3},
+        'hard':
+            {'approximation': [0.3, 15], 'localization': [0.3, 4], 'rand': [0.3, 7], 'flip_class': 0.4}
+    }
+
+    original_annotations_path = args.annotations_path
+    corruption_values = args.corruption_values
+    if args.benchmark:
+        corruption_values = Benchmarks[args.benchmark]
+
+    method_name = args.method_name
+    if args.benchmark:
+        method_name = args.benchmark
+
+    create_new_folders_and_copy_files(original_annotations_path, method_name, corruption_values)
+    noise_annotations(method_name, corruption_values, seed=args.seed)
+
+
+# read me:
+
+#  To run the benchmark, run the following:
+#  python noise_annotations.py /path/to/annotations --benchmark {easy, medium, hard} (choose one of the three) --seed 1
+
+#  To run a custom noise method, run the following:
+#  python noise_annotations.py /path/to/annotations --method_name method_name
+#  --corruption_values [{'rand': [scale_proportion, kernel_size(should be odd number)],
+#  'localization': [scale_proportion, std_dev],
+#  'approximation': [scale_proportion, tolerance], 'flip_class': percent_class_noise}]}]
+#
+#  for example:
+#  python noise_annotations.py /path/to/annotations --method_name my_noise_method
+#  --corruption_values [{'rand': [0.2, 3], 'localization': [0.2, 2], 'approximation': [0.2, 5], 'flip_class': 0.2}]
+#
+#  The script will create new folders and copy the original annotation files to the new folders. (the original annotations should be in coco format)
+#  It will then add noise to the annotations in the new folders based on the specified corruption values.
+#  The seed can be specified to ensure reproducibility.