Upload 15 files

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ELAN MITSUA Project / Abstract Engine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE_FYSignate1009.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 FYSignate1009
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

LICENSE_fractal-pretraining.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Connor Anderson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

params/multi_fractal_ifs_params.json

@@ -0,0 +1,14 @@
+{
+    "num_classes":1000,
+    "num_image_per_class":1000,
+    "num_systems_per_calss":3,
+    "num_systems": 6000,
+    "niter": 100000,
+    "color": true,
+    "background": true,
+    "patch": true,
+    "n_objects": [4, 6],
+    "size_range":[0.4, 0.6],
+    "jitter_params":true,
+    "image_size":256
+}

params/multi_fractal_ifs_params_no_mixup.json

@@ -0,0 +1,14 @@
+{
+    "num_classes":1000,
+    "num_image_per_class":1000,
+    "num_systems_per_calss":3,
+    "num_systems": 3000,
+    "niter": 100000,
+    "color": true,
+    "background": true,
+    "patch": true,
+    "n_objects": [3, 6],
+    "size_range":[0.5, 0.8],
+    "jitter_params":true,
+    "image_size":256
+}

params/settings.json

@@ -0,0 +1,19 @@
+{
+    "numof_thread": 10,
+    "numof_classes": 1000,
+    "numof_instances": 1000,
+    "vertex_num_min": 200,
+    "vertex_num_max": 1000,
+    "perlin_min": 0,
+    "line_num_min": 1,
+    "line_num_max": 200,
+    "line_width": 0.1,
+    "radius_min": 10,
+    "oval_rate": 2,
+    "image_size": 256,
+    "start_pos": 256,
+    "nami_1_min": 0,
+    "nami_2_min": 0,
+    "nami_1_max": 20,
+    "nami_2_max": 20
+}

requirements.txt

@@ -0,0 +1 @@
+numba

src/generator.py

@@ -0,0 +1,240 @@
+import os
+import shutil
+import gc
+import json
+import pickle
+import cv2
+import numpy as np
+from tqdm import tqdm
+import threading
+from concurrent.futures import ProcessPoolExecutor
+
+from multi_fractal_db import ifs
+from multi_fractal_db import serach_ifs_systems
+from multi_fractal_db.multi_fractal_dataset import MultiFractalDataset
+from multi_fractal_db.multi_fractal_generator import MultiGenerator
+
+from PIL import Image
+
+class Generator():
+    @classmethod
+    def get_params(cls, params_path):
+        # デバッグ表示
+        cls.debug = True
+
+        # Conner's FractalDBのパラメータ
+        with open(os.path.join(params_path, 'multi_fractal_ifs_params.json')) as f:
+            cls.ifs_params = json.load(f)
+
+        # IFSシステムの探索パラメータ
+        kwargs = dict(
+          # IFSシステム数 
+          num_systems=cls.ifs_params["num_systems"],
+          # 連立方程式の数
+          n=(2, 4),
+          bval=1,
+          beta=None,
+          sample_fn=None,
+        )
+        # 全IFSシステムのパラメータ作成
+        sys = serach_ifs_systems.random_systems(**kwargs)
+        cls.ifs_systems = {'params': sys, 'hparams': kwargs}
+        print(f"ifs_systems length {len(cls.ifs_systems['params'])}")
+
+        # デバッグモード
+        cls.debug = True
+
+        return True
+
+    @classmethod
+    def generate(cls, out_path, start_index : int = None, end_index : int = None, jpeg_quality : int = 95):
+        if cls.debug:
+            print(out_path)
+
+        # MixUp元フォルダ作成
+        base_path = out_path.replace("pretrain", "base")
+
+        # クラス数
+        num_classes = cls.ifs_params['num_classes']
+        # 1クラスあたりの画像枚数
+        num_image_per_class = cls.ifs_params['num_image_per_class']
+
+        if start_index is None:
+            start_index = 0
+        if end_index is None:
+            end_index = num_classes
+        
+        # 全クラス分の画像作成
+        for iclass in range(start_index, end_index):
+            print(f"iclass = {iclass:05}")
+            class_dir = os.path.join(out_path, f"{iclass:05}")
+            if os.path.exists(class_dir):
+                files = os.listdir(class_dir)
+                files = [f for f in files if f.endswith(".jpg")]
+                if len(files) == num_image_per_class:
+                    print(f"this iclass already processed = {iclass:05}")
+                    once_load_failed = False
+                    for f in files:
+                        path = os.path.join(class_dir, f)
+                        try:
+                            img = Image.open(path)
+                        except:
+                            once_load_failed = True
+                            break
+                    if not once_load_failed:
+                        continue
+                    else:
+                        print(f"[RE] this iclass already processed = {iclass:05}, but file corrupted. ")
+                        for f in files:
+                            os.remove(os.path.join(class_dir, f))
+                else:
+                    for f in files:
+                        os.remove(os.path.join(class_dir, f))
+
+            base_images = []
+            # MixUp元ベースクラス作成
+            for ib, ibase in enumerate([iclass*2, iclass*2+1]):
+                # クラスフォルダ
+                
+                # 1クラスあたりのIFSシステム数
+                num_systems_per_calss = cls.ifs_params['num_systems_per_calss']
+                # 使用するIFSシステムパラメータ
+                st = ibase * num_systems_per_calss
+                en = (ibase+1)*num_systems_per_calss
+                # print(f"ib={ib}, ibase={ibase}, st={st}, en={en}")
+                ifs_syss =  {'params':cls.ifs_systems['params'][st:en], 
+                                'hparams': cls.ifs_systems['hparams']}
+                
+                # chaceサイズ
+                #cache_size = num_systems_per_calss * num_image_per_class
+                cache_size = min(500, num_image_per_class*num_systems_per_calss)
+
+                # 別スレッドで実行
+                future =  make_multi_fractal_images( 
+                            ifs_syss, cls.ifs_params, num_systems_per_calss, 
+                            num_image_per_class, cache_size, cls.debug, out_path, ibase)
+                base_images.append(future)
+        
+            # MixUp画像作成
+            # クラスフォルダ
+            class_dir = os.path.join(out_path, f"{iclass:05}")
+            if os.path.exists(class_dir)==False:
+                os.makedirs(class_dir, exist_ok=True)
+            
+            # 全画像作成
+            for idx in tqdm(range(num_image_per_class)):
+                # MixUp元画像の読み込み
+                image_base1 = base_images[0][idx]
+                image_base2 = base_images[1][idx]               
+                # MixUp
+                alpha = 1.0
+                lam = np.clip(np.random.beta(alpha, alpha), 0.4, 0.6)
+                image_mixup = lam * image_base1 + (1 - lam) * image_base2
+                image_mixup = image_mixup.astype(np.uint8)
+                # 画像書き出し
+                image_file = os.path.join(class_dir, f"{idx:05}.jpg")
+                cv2.imwrite(image_file, image_mixup, [cv2.IMWRITE_JPEG_QUALITY, jpeg_quality])
+                        
+            # MixUp元フォルダの削除
+            base_images = None
+            del base_images
+            futures = None
+            del futures
+            gc.collect()
+
+
+def make_multi_fractal_images(ifs_systems, ifs_params,
+                            num_systems_per_calss, num_image_per_class, cache_size,
+                            debug, out_path, ibase):
+    # Conner's Multi-FractalDB
+    multi_fractal_dataset = MultiFractalDataset(
+    ifs_params=ifs_systems,
+    num_systems=num_systems_per_calss,
+    num_class=1,
+    per_class=num_image_per_class,
+    generator=MultiGenerator(
+        color=ifs_params["color"],
+        background=ifs_params["background"],
+        niter=ifs_params["niter"],
+        patch=ifs_params["patch"],
+        n_objects=ifs_params["n_objects"],
+        size_range=ifs_params["size_range"],
+        jitter_params=ifs_params["jitter_params"],
+        cache_size=cache_size,
+        size=ifs_params["image_size"]
+        ),
+    period=2)
+
+    if debug:
+        # 確認用フォルダ
+        check_dir = out_path.replace("pretrain", "check")
+        if os.path.exists(check_dir)==False:
+            os.makedirs(check_dir, exist_ok=True)
+        # 使用するIFSフラクタルを描画          
+        for i, sys in enumerate(ifs_systems['params']):
+            image_gray = multi_fractal_dataset.generator.render(sys['system'])
+            image_gray = (image_gray * 255).astype(np.uint8)
+            #image_gray = cv2.applyColorMap(image_gray, cv2.COLORMAP_BONE)
+            image_file = os.path.join(check_dir, f"{ibase:05}_{i:02}.jpg")
+            cv2.imwrite(image_file, image_gray)
+
+    # 全画像数
+    base_images = []
+    num_fractal_images = len(multi_fractal_dataset)
+    class_dir = os.path.join(check_dir, f"{ibase:05}")
+    os.makedirs(class_dir, exist_ok=True)
+    for idx in range(num_fractal_images):
+        # 画像とラベルの取得
+        image, labels = multi_fractal_dataset[idx]
+        # 画像書き出し
+        image_file = os.path.join(class_dir, f"{idx:05}.png")
+        cv2.imwrite(image_file, image)
+        base_images.append(image)
+    
+    # メモリ解放
+    multi_fractal_dataset = None
+    del multi_fractal_dataset
+    gc.collect()
+
+    return base_images
+
+def multifractal_main(outputdir, start_index, end_index, jpeg_quality):
+    Generator.get_params('../params')
+    Generator.generate(outputdir, start_index, end_index, jpeg_quality)
+
+if __name__ == "__main__":
+    import argparse
+    from tqdm import tqdm
+    from copy import deepcopy
+    import concurrent.futures
+    import time
+    from typing import List
+    import multiprocessing
+    worker_num=multiprocessing.cpu_count()
+    print("workers : ", worker_num)
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--fpath', type=str, default="../output/pretrain")
+    parser.add_argument('--total', type=int, default=1000)
+    parser.add_argument('--step', type=int, default=1000//worker_num+1)
+    parser.add_argument('--offset', type=int, default=0)
+    parser.add_argument('--jpeg_quality', type=int, default=95)
+
+    args = parser.parse_args()
+
+    os.makedirs(args.fpath, exist_ok=True)
+
+    executor = concurrent.futures.ProcessPoolExecutor(max_workers=worker_num)
+    futures : List[concurrent.futures.Future] = []
+
+    for i in range(args.offset, args.total, args.step):
+        start_index = i
+        end_index = i + args.step
+        futures.append(executor.submit(multifractal_main, args.fpath, start_index, end_index, args.jpeg_quality))
+    
+    for future in tqdm(concurrent.futures.as_completed(futures)):
+        try:
+            rr = future.result()
+        except Exception as exc:
+            print('generated an exception: %s' % (exc))
+
+    print("All done!")

src/generator_no_mixup.py

@@ -0,0 +1,195 @@
+import os
+import shutil
+import gc
+import json
+import pickle
+import cv2
+import numpy as np
+from tqdm import tqdm
+import threading
+from concurrent.futures import ProcessPoolExecutor
+
+from multi_fractal_db import ifs
+from multi_fractal_db import serach_ifs_systems
+from multi_fractal_db.multi_fractal_dataset import MultiFractalDataset
+from multi_fractal_db.multi_fractal_generator import MultiGenerator
+
+from PIL import Image
+
+class Generator():
+    @classmethod
+    def get_params(cls, params_path):
+        # デバッグ表示
+        cls.debug = True
+
+        # Conner's FractalDBのパラメータ
+        with open(os.path.join(params_path, 'multi_fractal_ifs_params_no_mixup.json')) as f:
+            cls.ifs_params = json.load(f)
+
+        # IFSシステムの探索パラメータ
+        kwargs = dict(
+          # IFSシステム数 
+          num_systems=cls.ifs_params["num_systems"],
+          # 連立方程式の数
+          n=(2, 4),
+          bval=1,
+          beta=None,
+          sample_fn=None,
+        )
+        # 全IFSシステムのパラメータ作成
+        sys = serach_ifs_systems.random_systems(**kwargs)
+        cls.ifs_systems = {'params': sys, 'hparams': kwargs}
+        # print(f"ifs_systems length {len(cls.ifs_systems['params'])}")
+
+        # デバッグモード
+        cls.debug = True
+
+        return True
+
+    @classmethod
+    def generate(cls, out_path, start_index : int = None, end_index : int = None, jpeg_quality : int = 95):
+        # if cls.debug:
+        #     print(out_path)
+
+        try:
+
+            # クラス数
+            num_classes = cls.ifs_params['num_classes']
+            # 1クラスあたりの画像枚数
+            num_image_per_class = cls.ifs_params['num_image_per_class']
+
+            if start_index is None:
+                start_index = 0
+            if end_index is None:
+                end_index = num_classes
+            
+            # 全クラス分の画像作成
+            for iclass in tqdm(range(start_index, end_index), total=end_index-start_index):                    
+                # 1クラスあたりのIFSシステム数
+                num_systems_per_calss = cls.ifs_params['num_systems_per_calss']
+                # 使用するIFSシステムパラメータ
+                st = iclass * num_systems_per_calss
+                en = (iclass+1)*num_systems_per_calss
+                # print(f"ib={ib}, ibase={ibase}, st={st}, en={en}")
+                ifs_syss =  {'params':cls.ifs_systems['params'][st:en], 
+                                'hparams': cls.ifs_systems['hparams']}
+                
+                # chaceサイズ
+                # cache_size = num_systems_per_calss * num_image_per_class
+                cache_size = min(500, num_image_per_class)
+
+                make_multi_fractal_images( 
+                            ifs_syss, cls.ifs_params, num_systems_per_calss, 
+                            num_image_per_class, cache_size, cls.debug, out_path, iclass, jpeg_quality)
+                gc.collect()
+        except Exception as e:
+            print(e)
+            import traceback
+            print(traceback.format_exc())
+
+
+        return True
+
+
+def make_multi_fractal_images(ifs_systems, ifs_params,
+                            num_systems_per_calss, num_image_per_class, cache_size,
+                            debug, out_path, ibase, jpeg_quality):
+    # Conner's Multi-FractalDB
+    multi_fractal_dataset = MultiFractalDataset(
+    ifs_params=ifs_systems,
+    num_systems=num_systems_per_calss,
+    num_class=1,
+    per_class=num_image_per_class,
+    generator=MultiGenerator(
+        color=ifs_params["color"],
+        background=ifs_params["background"],
+        niter=ifs_params["niter"],
+        patch=ifs_params["patch"],
+        n_objects=ifs_params["n_objects"],
+        size_range=ifs_params["size_range"],
+        jitter_params=ifs_params["jitter_params"],
+        cache_size=cache_size,
+        size=ifs_params["image_size"], 
+        seed=ibase,
+        n_instance_types=num_systems_per_calss,
+        ),
+    period=2)
+
+    print(f"jitter success {multi_fractal_dataset.generator.jitter_success}")
+    print(f"jitter failed {multi_fractal_dataset.generator.jitter_failed}")
+
+    if debug:
+        # 確認用フォルダ
+        check_dir = out_path.replace("pretrain", "check")
+        if os.path.exists(check_dir)==False:
+            os.makedirs(check_dir, exist_ok=True)
+        # 使用するIFSフラクタルを描画          
+        for i, sys in enumerate(ifs_systems['params']):
+            image_gray = multi_fractal_dataset.generator.render(sys['system'])
+            image_gray = (image_gray * 255).astype(np.uint8)
+            #image_gray = cv2.applyColorMap(image_gray, cv2.COLORMAP_BONE)
+            image_file = os.path.join(check_dir, f"{ibase:05}_{i:02}.jpg")
+            cv2.imwrite(image_file, image_gray)
+
+    # 全画像数
+    base_images = []
+    num_fractal_images = len(multi_fractal_dataset)
+    class_dir = os.path.join(out_path, f"{ibase:05}")
+    os.makedirs(class_dir, exist_ok=True)
+    for idx in range(num_fractal_images):
+        # 画像とラベルの取得
+        image, labels = multi_fractal_dataset[idx]
+        # 画像書き出し
+        image_file = os.path.join(class_dir, f"fractal_{ibase:05}_instance_{idx:04}.jpg")
+        cv2.imwrite(image_file, image,  [cv2.IMWRITE_JPEG_QUALITY, jpeg_quality])
+        base_images.append(image)
+    
+    # メモリ解放
+    multi_fractal_dataset = None
+    del multi_fractal_dataset
+    gc.collect()
+
+    return base_images
+
+def multifractal_main(outputdir, start_index, end_index, jpeg_quality):
+    Generator.get_params('../params')
+    Generator.generate(outputdir, start_index, end_index, jpeg_quality)
+
+if __name__ == "__main__":
+    import argparse
+    from tqdm import tqdm
+    from copy import deepcopy
+    import concurrent.futures
+    import time
+    from typing import List
+    import multiprocessing
+    worker_num=multiprocessing.cpu_count()
+    print("workers : ", worker_num)
+    parser = argparse.ArgumentParser()
+    total_default = 1000
+    parser.add_argument('--fpath', type=str, default="../output/pretrain")
+    parser.add_argument('--total', type=int, default=total_default)
+    parser.add_argument('--step', type=int, default=total_default//worker_num+1)
+    parser.add_argument('--offset', type=int, default=0)
+    parser.add_argument('--jpeg_quality', type=int, default=85)
+
+    args = parser.parse_args()
+
+    os.makedirs(args.fpath, exist_ok=True)
+
+    executor = concurrent.futures.ProcessPoolExecutor(max_workers=worker_num)
+    futures : List[concurrent.futures.Future] = []
+
+    for i in range(args.offset, args.total, args.step):
+        start_index = i
+        end_index = min(args.total, i + args.step)
+        futures.append(executor.submit(multifractal_main, args.fpath, start_index, end_index, args.jpeg_quality))
+    
+    for future in tqdm(concurrent.futures.as_completed(futures)):
+        try:
+            rr = future.result()
+        except Exception as exc:
+            print('generated an exception: %s' % (exc))
+
+    executor.shutdown()
+    print("All done!")

src/multi_fractal_db/diamondsquare.py

@@ -0,0 +1,89 @@
+from cv2 import cvtColor, COLOR_HSV2RGB
+import numba
+import numpy as np
+
+
+@numba.njit(cache=True)
+def diamond_square(n, decay=0.5, fixed_corners=True):
+    s = 2**n + 1
+    a = np.zeros((s, s))
+    if fixed_corners:
+        a[0, 0] = a[0, s-1] = a[s-1, 0] = a[s-1, s-1] = 0.5
+    else:
+        a[0, 0] = np.random.rand()
+        a[0, s-1] = np.random.rand()
+        a[s-1, 0] = np.random.rand()
+        a[s-1, s-1] = np.random.rand()
+    
+    for k in range(1, n+1):
+        m = 0.5 * np.exp(decay * (1-k))
+        ss = s // (2**k)
+        
+        # diamond
+        ni = 2**k
+        for i in range(0, ni, 2):
+            # s / 2**k
+            ru = i * ss
+            r = ru + ss
+            rd = r + ss
+            for j in range(0, ni, 2):
+                cl = j * ss
+                c = cl + ss
+                cr = c + ss
+                a[r, c] = 0.25 * (a[ru, cl] + a[ru, cr] + a[rd, cl] + a[rd, cr])
+                a[r, c] += np.random.uniform(-m, m)
+        
+        # square
+        ni = 2**k + 1
+        for i in range(ni):
+            r = i * ss
+            if r > 0: ru = r - ss
+            else: ru = s - ss - 1
+            if r < s-1: rd = r + ss
+            else: rd = ss
+            sj = 1 if i % 2 == 0 else 0
+            for j in range(sj, ni, 2):
+                c = j * ss
+                if c > 0: cl = c - ss
+                else: cl = s - ss - 1
+                if c < s-1: cr = c + ss
+                else: cr = ss
+                a[r, c] = 0.25 * (a[ru, c] + a[r, cl] + a[r, cr] + a[rd, c])
+                a[r, c] += np.random.uniform(-m, m)
+    return a
+
+
+@numba.njit(cache=True)
+def _colorize(ds):
+    img = np.empty((ds.shape[0], ds.shape[1], 3), dtype=np.uint8)
+
+    hue_scale = np.random.uniform(0.15, 1) * 179
+    hue_shift = np.random.rand() * 179
+
+    sat_scale = np.random.uniform(0.1, 0.3) * 255
+    sat_shift = np.random.uniform(0.0, 0.3) * 255
+
+    val_scale = np.random.uniform(0.1, 0.3) * 255
+    val_shift = np.random.uniform(0.1, 0.3) * 255
+
+    for i in range(ds.shape[0]):
+        for j in range(ds.shape[1]):
+            x = ds[i, j]
+            img[i, j, 0] = np.uint8(min((x * hue_scale + hue_shift) % 179, 179))
+            img[i, j, 1] = np.uint8(min(x * sat_scale + sat_shift, 255))
+            img[i, j, 2] = np.uint8(min(x * val_scale + val_shift, 255))
+
+    return img
+
+
+def colorized_ds(size=256):
+    # 画像サイズ256=2の8乗
+    n = int(np.ceil(np.log2(size)))
+    # 乱数生成器
+    rng = np.random.default_rng()
+    # 背景作成
+    r = diamond_square(n, rng.uniform(0.4, 0.8), fixed_corners=False)[:size, :size]
+    # HSVで色付け、HSV->RGB変換
+    img = _colorize(r)
+    img = cvtColor(img, COLOR_HSV2RGB, dst=img)
+    return img

src/multi_fractal_db/ifs.py

@@ -0,0 +1,373 @@
+from functools import partial
+
+from cv2 import cvtColor, COLOR_HSV2RGB
+import numba
+import numpy as np
+
+
+# IFSフラクタル座標計算
+@numba.njit(cache=True)
+def iterate(sys, n_iter, ps=None):
+    '''Compute points in the fractal defined by the system `sys` by random iteration. `n_iter` iterations
+    are performed, and a transform is sampled at each iteration according to the probabilites defined by
+    `ps`.
+    
+    Args:
+        sys (np.ndarray): array of shape (n, 2, 3), containing the affine transform parameters.
+        n_iter (int): number of iterations/points to calculate.
+        ps (Optional[array-like]): length-n array of probabilites. If None (default), the probabilites are
+            calculated to be proportional to the determinants of the affine transformation matrices.
+    
+    Returns:
+        ndarray of shape (n_iter, 2) containing the (x, y) coordinates of the generated points.
+    '''
+    det = sys[:, 0, 0] * sys[:, 1, 1] - sys[:, 0, 1] * sys[:, 1, 0]
+    # 確率が指定されていない場合、detから計算
+    if ps is None:
+        # パラメータセット毎の確率
+        ps = np.abs(det)
+        # 全体で1になるように正規化
+        ps = ps / ps.sum()
+    # 累積確率、0-1の乱数でどのパラメータセットを使うか決めるため
+    ps = np.cumsum(ps)
+    
+    # 全フラクタル点の座標
+    coords = np.empty((n_iter, 2))
+
+    # starting point is $v = (I-A_1)^(-1) b$ since this point is gaurenteed to be in the set
+    # (assuming that A_1 is contractive) (A_1 = sys[0])
+    s = 1 / (1 + det[0] - sys[0, 0, 0] - sys[0, 1, 1])
+    x = s * ((1 - sys[0, 1, 1]) * sys[0, 0, 2] + sys[0, 0, 1] * sys[0, 1, 2])
+    y = s * ((1 - sys[0, 0, 0]) * sys[0, 1, 2] + sys[0, 1, 0] * sys[0, 0, 2])
+
+    for i in range(n_iter):
+        # 0-1の一様乱数の生成
+        r = np.random.rand()
+        # 使用するパラメータセットの特定
+        for k in range(len(ps)):
+            if r < ps[k]: break
+        # パラメータセット
+        a, b, e, c, d, f = sys[k].ravel()
+        # 次座標の計算
+        xt = x
+        x = a * xt + b * y + e
+        y = c * xt + d * y + f
+        coords[i] = x, y
+
+        # 発散した場合はブレイク
+        if not np.isfinite(x) or not np.isfinite(y): break  # if contractivity is satisfied, can remove this check
+    return coords
+
+
+@numba.njit(cache=True)
+def minmax(coords):
+    '''Returns both the minimum and maximum values along the 0 axis of an array with shape (n, 2). This only
+    requires a single pass through the array, and is faster than calling np.min and np.max seperately.
+    
+    Args:
+        coords (np.ndarray): an array of shape (n, 2)
+        
+    Returns:
+        Two ndarrays of shape (2,), the first containing the minimum values and the second containing the maximums
+    '''
+    # x,y座標の最大、最小値
+    mins = np.full(2, np.inf)
+    maxs = np.full(2, -np.inf)
+    for i in range(len(coords)):
+        x, y = coords[i]
+        if x < mins[0]: mins[0] = x
+        if y < mins[1]: mins[1] = y
+        if x > maxs[0]: maxs[0] = x
+        if y > maxs[1]: maxs[1] = y
+    return mins, maxs
+
+
+@numba.njit(cache=True)
+def _extent(region):
+    x1, y1, x2, y2 = region
+    xspan = x2 - x1
+    xspan = xspan if xspan > 0 else 1
+    yspan = y2 - y1
+    yspan = yspan if yspan > 0 else 1
+    return xspan, yspan
+
+
+
+@numba.njit(cache=True)
+def _render_binary(coords, s, region):
+    '''Renders a square, binary image from coordinate points and a given region.
+    
+    Args:
+        coords (np.ndarray): coordinate array of shape (n, 2).
+        s (int): side length of the rendered image. The image will have width = height = s.
+        region (np.ndarray): array of shape (4,), containing [minx, miny, maxx, maxy]. These four values
+            define the region in coordinate space that will be rendered to the image. Coordinate points
+            that fall outside the bounds of the region will be ignored.
+    
+    Returns:
+        A binary image as an ndarray of shape (s, s).
+    '''
+    imgb = np.zeros((s, s), dtype=np.uint8)
+    xspan, yspan = _extent(region)
+    xscale = (s-1) / xspan
+    yscale = (s-1) / yspan
+    xmin, ymin = region[0], region[1]
+    for i in range(len(coords)):
+        r = int((coords[i,0] - xmin) * xscale)
+        c = int((coords[i,1] - ymin) * yscale)
+        if r >= 0 and r < s and c >= 0 and c < s:
+            imgb[r, c] = 1
+    return imgb
+
+
+
+@numba.njit(cache=True)
+def _render_binary_patch(coords, s, region, patch):
+    '''Renders a square, binary image from coordinate points and a given region. Instead of rendering a
+    single point for each coordinate, a 3x3 patch is rendered, centered on the coordinate.
+
+    Args:
+        coords (np.ndarray): coordinate array of shape (n, 2).
+        s (int): side length of the rendered image. The image will have width = height = s.
+        region (np.ndarray): array of shape (4,), containing [minx, miny, maxx, maxy]. These four values
+            define the region in coordinate space that will be rendered to the image. Coordinate points
+            that fall outside the bounds of the region will be ignored.
+        patch (np.ndarray): array of shape (3, 3), where each value is either 0 or 1 (binary).
+
+    Returns:
+        A grayscale image as an ndarray of shape (s, s).
+    '''
+    # ブランク画像作成
+    imgb = np.zeros((s, s), dtype=np.uint8)
+    # x幅、y幅
+    xspan, yspan = _extent(region)
+    # xy軸方向の拡大係数
+    xscale = (s-1) / xspan
+    yscale = (s-1) / yspan
+    # xy軸最小値
+    xmin, ymin = region[0], region[1]
+    for i in range(len(coords)):
+        # ピクセル座標の計算
+        rr = int((coords[i,0] - xmin) * xscale)
+        cc = int((coords[i,1] - ymin) * yscale)
+        # patch処理
+        for j in range(len(patch)):
+            # マスクが1ならそのまま、0or2なら左右に書き込みでそのピクセルはブランク
+            r = rr + patch[j, 0] - 1
+            c = cc + patch[j, 1] - 1
+            if r >= 0 and r < s and c >= 0 and c < s:
+                imgb[r, c] = 1
+    return imgb
+    
+
+@numba.njit(cache=True)
+def _render_graded(coords, s, region):
+    '''Renders a square, grayscale image from coordinate points and a given region. The grayscale values for
+    a given pixel is proportional to the number of coordinate points that land on that pixel.
+    
+    See _render_binary for an explanation of the arguments.
+    '''
+    # ブランク画像、0-1の小数点になるので、floatで
+    imgf = np.zeros((s, s), dtype=np.float64)
+    # x,yの幅
+    xspan, yspan = _extent(region)
+    # ピクセル位置スケーリング
+    xscale = (s-1) / xspan
+    yscale = (s-1) / yspan
+    xmin, ymin = region[0], region[1]
+    for i in range(len(coords)):
+        # ピクセル座標計算
+        r = int((coords[i,0] - xmin) * xscale)
+        c = int((coords[i,1] - ymin) * yscale)
+        if r >= 0 and r < s and c >= 0 and c < s:
+            # 明暗つけるため加算する
+            imgf[r, c] += 1
+    # 正規化
+    mval = imgf.max()
+    if mval > 0:
+        imgf /= mval
+    return imgf
+
+
+@numba.njit(cache=True)
+def _render_graded_patch(coords, s, region, patch):
+    '''Renders a square, grayscale image from coordinate points and a given region. The grayscale values for
+    a given pixel is proportional to the number of coordinate points that land on that pixel. Instead of rendering
+    a single point for each coordinate, a 3x3 patch is rendered, centered on the coordinate.
+    
+    See _render_binary_patch for an explanation of the arguments.
+    '''
+    imgf = np.zeros((s, s), dtype=np.float64)
+    xspan, yspan = _extent(region)
+    xscale = (s-1) / xspan
+    yscale = (s-1) / yspan
+    xmin, ymin = region[0], region[1]
+    for i in range(len(coords)):
+        rr = int((coords[i,0] - xmin) * xscale)
+        cc = int((coords[i,1] - ymin) * yscale)
+        for j in range(len(patch)):
+            r = rr + patch[j, 0] - 1
+            c = cc + patch[j, 1] - 1
+            if r >= 0 and r < s and c >= 0 and c < s:
+                imgf[r, c] += 1
+    mval = imgf.max()
+    if mval > 0:
+        imgf /= mval
+    return imgf
+
+
+# フラクタル描画
+def render(coords, s=256, binary=True, region=None, patch=False):
+    '''Render an image from a set of coordinates and an optionally specified region.
+    
+    Args:
+        coords (np.ndarray): coordinate array of shape (n, 2).
+        s (int): side length of the rendered image. The image will have width = height = s.
+        binary (bool): if True, render a binary image; otherwise, render a grayscale image, where the grayscale
+            value is proportional to the number of coordinates that map to the pixel.
+        region (Optional[np.ndarray]): array of shape (4,), containing [minx, miny, maxx, maxy]. These four
+            values define the region in coordinate space that will be rendered to the image. Coordinate points
+            that fall outside the bounds of the region will be ignored. If None (default), the minimum and
+            maximum coordinate values are used.
+        patch (bool): if False, render each coordinate as a single point. If True, renders a 3x3 patch centered
+            at each coordinate. The patch is randomly sampled (each value is chosen uniformly from [0, 1]).
+
+    Returns:
+        An image (either grayscale or binary, depending) as an ndarray of shape (s, s).
+    '''
+
+    # 範囲指定がない場合
+    if region is None:
+        # フラクタル点座標の最大、最小範囲で切り出し
+        region = np.concatenate(minmax(coords))
+    else:
+        region = np.asarray(region)
+    
+    # パッチ処理有りの場��
+    if patch:
+        # 3x3のマスク、だがどうも2もあるような
+        p = np.stack(np.divmod(np.arange(9)[np.random.randint(0, 2, (9,), dtype=bool)], 3), 1)
+
+    if binary:
+        if patch:
+            # patch処理ありの白黒画像
+            return _render_binary_patch(coords, s, region, p)
+        else:
+            # patch処理なし白黒画像
+            return _render_binary(coords, s, region)
+    else:
+        # カラー指定の場合、とりあえず輝度値のみ計算
+        if patch:
+            # patc処理ありカラー画像
+            return _render_graded_patch(coords, s, region, p)
+        else:
+            # patc処理なしカラー画像
+            return _render_graded(coords, s, region)
+
+
+# HSV空間で色付け関数
+@numba.njit(cache=True)
+def _hsv_colorize(rendered, min_sat=0.3, min_val=0.5):
+    '''Creates a 3-channel HSV image from a 1-channel gray image.
+    '''
+    h, w = rendered.shape[:2]
+    img = np.empty((h, w, 3), dtype=np.uint8)
+
+    # 基準Hue
+    hue_shift = np.random.rand() * 179
+    # 彩度
+    sat = np.uint8(np.random.uniform(min_sat, 1) * 255)
+    # 明度
+    val = np.uint8(np.random.uniform(min_val, 1) * 255)
+
+    for i in range(h):
+        for j in range(w):
+            x = rendered[i, j]
+            if x > 0:
+                img[i, j, 0] = np.uint8(min((x * 179 + hue_shift) % 179, 179))  # implicit MOD(256)
+                img[i, j, 1] = sat
+                img[i, j, 2] = val
+            else:
+                img[i, j, 0] = 0
+                img[i, j, 1] = 0
+                img[i, j, 2] = 0
+    return img
+
+
+@numba.njit(cache=True)
+def _hsv_colorize2(rendered, min_sat=0.3, min_val=0.5, hue_base=0, hue_range=179, max_sat=1.0):
+    h, w = rendered.shape[:2]
+    img = np.empty((h, w, 3), dtype=np.uint8)
+
+    # 基準Hue
+    hue_shift = np.random.rand() * hue_range + hue_base
+    hue_scale = np.random.uniform(-0.5, 0.5) * hue_range
+    # 彩度
+    sat = np.uint8(np.random.uniform(min_sat, max_sat) * 255)
+    # 明度
+    val = np.uint8(np.random.uniform(min_val, 1) * 255)
+
+    for i in range(h):
+        for j in range(w):
+            x = rendered[i, j]
+            if x > 0:
+                img[i, j, 0] = np.uint8(min((x * hue_scale + hue_shift) % 179, 179))  # implicit MOD(256)
+                img[i, j, 1] = sat
+                img[i, j, 2] = min(max(x * 1024, val), 255)
+            else:
+                img[i, j, 0] = 0
+                img[i, j, 1] = 0
+                img[i, j, 2] = 0
+    return img
+
+
+# 前景画像埋め込み
+@numba.njit(cache=True)
+def composite(fg, bg):
+    '''Copy nonzero pixels from fg into bg. Modifies bg in-place.'''
+    for i in range(fg.shape[0]):
+        for j in range(fg.shape[1]):
+            if fg[i, j, 0] != 0 or fg[i, j, 1] != 0 or fg[i, j, 2] != 0:
+                bg[i, j] = fg[i, j]
+    return bg
+
+# 前景画像埋め込み
+@numba.njit(cache=True)
+def composite_v2(fg, bg, fg_mask):
+    '''Copy nonzero pixels from fg into bg. Modifies bg in-place.'''
+    for i in range(fg.shape[0]):
+        for j in range(fg.shape[1]):
+            if fg[i, j, 0] != 0 or fg[i, j, 1] != 0 or fg[i, j, 2] != 0:
+                factor = np.power(fg_mask[i, j], 0.3)
+                for k in range(3):
+                    bg[i, j, k] = np.uint8(min(fg[i, j, k] * factor + 
+                                                bg[i, j, k] * (1.0 - factor), 255))
+                    # bg[i, j, k] = np.uint8(fg_mask[i, j] * 255)
+                # bg[i, j] = (fg[i, j] * fg_mask[i, j] + bg[i, j] * (255 - fg_mask[i, j]))  / 255
+    return bg
+
+
+# カラー画像化
+def colorize(rendered, min_sat=0.3, min_val=0.5, hue_base=0, hue_range=179, max_sat=1.0):
+    '''Turns a grayscale image into a color image, where the colors are randomly chosen as explained below.
+    
+    First, the grayscale values are converted to the range [0, 255]. A reference hue value h is chosen
+    uniformly from [0, 255], and the hue for each pixel p becomes (p + h) mod 256. Then global saturation
+    and value scales are chosen uniformly from the ranges [min_sat, 1] and [min_val, 1]. Finally, the image
+    is converted to RGB.
+    
+    Args:
+        rendered (np.ndarray): grayscale image of shape (w, h), with values in the range [0, 1].
+        min_sat (float): minimum "saturation" value, defining the range of possible saturation values to draw from.
+        min_val (float): minimum "value" value, defining the range of possible "value" (as in light/dark) values to
+            draw from.
+
+    Returns:
+        A color image as an ndarray of shape (w, h, 3).
+    '''
+    # HSV空間で色付け
+    # img = _hsv_colorize(rendered, min_sat, min_val)
+    img = _hsv_colorize2(rendered, min_sat, min_val, hue_base, hue_range, max_sat)
+    # HSV->RGB変換
+    cvtColor(img, COLOR_HSV2RGB, dst=img)
+    return img

src/multi_fractal_db/multi_fractal_dataset.py

@@ -0,0 +1,72 @@
+from functools import partial
+import pickle
+from typing import Callable, Optional, Tuple, Union
+import warnings
+
+from cv2 import GaussianBlur
+import numpy as np
+import torch
+import torchvision
+
+from multi_fractal_db import diamondsquare, ifs
+from multi_fractal_db.multi_fractal_generator import MultiGenerator
+
+
+class MultiFractalDataset(object):
+    def __init__(
+        self,
+        ifs_params: object,
+        num_systems: int = 100,
+        num_class: int = 100,
+        per_class: int = 100,
+        generator: Optional[MultiGenerator] = None,
+        period: int = 2,
+    ):
+        # IFSシステム数
+        self.num_systems = num_systems
+        # クラス数
+        self.num_class = num_class
+        # クラスあたりの画像枚数
+        self.per_class = per_class
+        # クラスあたりのIFSシステム数
+        self.per_system = num_class * per_class / num_systems
+        # IFSシステムパラメータ
+        self.params = ifs_params['params'][:num_systems]
+
+        # なぜかここMultiGeneratorが生成されてしまうのでコメントアウト
+        self.generator : MultiGenerator = generator #or MultiGenerator()
+
+        # キャッシュ画像をすべて作成
+        while len(self.generator.cache['fg']) < self.generator.cache_size:
+            for isys in range(num_systems):
+                # 代表クラス番号
+                # k = np.random.default_rng().integers(0, num_class)
+                self.generator.add_sample(self.params[isys]['system'], label=isys) # change to instance label
+
+        self.steps = 0
+        self.period = period
+
+    def __len__(self):
+        return self.num_class * self.per_class
+
+    def get_label(self, idx):
+        return int(idx // self.num_class)
+
+    def get_system(self, idx):
+        return int(idx // self.per_system)
+
+    def __getitem__(self, idx):
+        # whether it's time to render a new fractal or not
+        self.steps = (self.steps + 1) % self.period
+        sample = self.steps == 0
+        # IFSシステム番号
+        sysidx = self.get_system(idx)
+        # ラベル取得
+        label = self.get_label(idx)
+        # IFSパラメータ取得
+        params = self.params[sysidx]['system']
+        # 混合画像と混合ラベル
+        img, labels = self.generator(params, label=label, new_sample=sample)
+        #img = torch.from_numpy(img).float().mul_(1/255.).permute(2,0,1)
+
+        return img, labels

src/multi_fractal_db/multi_fractal_generator.py

@@ -0,0 +1,492 @@
+from functools import partial
+from typing import Callable, Optional, Tuple, Union
+
+from cv2 import GaussianBlur, resize, INTER_LINEAR, INTER_CUBIC, getRotationMatrix2D, warpAffine
+import numpy as np
+
+from multi_fractal_db import diamondsquare, ifs
+
+
+class _GeneratorBase(object):
+    def __init__(
+        self,
+        # 画像サイズ
+        size: int = 224,
+        # jit方法、Trueもしくは文字列を受け入れる
+        jitter_params: Union[bool, str] = True,
+        flips: bool = True,
+        # ボケの標準偏差
+        sigma: Optional[Tuple[float, float]] = (0.5, 1.0),
+        blur_p: Optional[float] = 0.5,
+        # フラクタル座標点数
+        niter = 100000,
+        # patch処理有無
+        patch = True,
+    ):
+        self.size = size
+        self.jitter_params = jitter_params
+        self.flips = flips
+        self.sigma = sigma
+        self.blur_p = blur_p
+        self.niter = niter
+        self.patch = patch
+
+        self.jitter_success = 0
+        self.jitter_failed = 0
+
+        self.hue_base = np.random.default_rng().integers(0, 179)
+        self.min_sat = np.random.default_rng().uniform(0.0, 0.75)
+        self.hue_range = max(0, 179 * (0.7 - self.min_sat))
+        
+        self.rng = np.random.default_rng()
+        self.cache = {'fg': [], 'bg': []}
+        # jit関数定義
+        self._set_jitter()
+
+    # jit関数
+    def _set_jitter(self):
+        # jit指定が文字列の場合
+        if isinstance(self.jitter_params, str):
+            if self.jitter_params.startswith('fractaldb'):
+                k = int(self.jitter_params.split('-')[1]) / 10
+                choices = np.linspace(1-2*k, 1+2*k, 5, endpoint=True)
+                self.jitter_fnc = partial(self._fractaldb_jitter, choices=choices)
+            if self.jitter_params.startswith('svd'):
+                self.jitter_fnc = self._svd_jitter
+            if self.jitter_params.startswith('sval'):
+                self.jitter_fnc = self._sval_jitter
+        elif self.jitter_params:
+            # defualt
+            self.jitter_fnc = self._basic_jitter
+        else:
+            # そのまま返す
+            self.jitter_fnc = lambda x: x
+
+    def _fractaldb_jitter(self, sys, prange=(0.5, 2.0), choices=[]):
+        n = len(sys)
+        y, x = np.divmod(self.rng.integers(0, 6, (n,)), 3)
+        scaling_factors = self.rng.uniform(*prange, n)
+        sys[range(n), y, x] *= scaling_factors
+        return sys
+
+    # def _fractaldb_jitter(self, sys, choices=(.8,.9,1,1.1,1.2)):
+    #     n = len(sys)
+    #     y, x = np.divmod(self.rng.integers(0, 6, (n,)), 3)
+    #     sys[range(n), y, x] *= self.rng.choice(choices)
+    #     return sys
+
+
+    # デフォルトのJitter関数
+    def _basic_jitter(self, sys, prange=(0.8, 1.1)):
+        # tweak system parameters--randomly choose one transform and scale it
+        # this actually amounts to scaling the singular values by a random factor
+        # IFSパラメータの全要素数
+        n = len(sys)
+        # どれか1要素を係数かけて微笑変動させる
+        sys[self.rng.integers(0, n)] *= self.rng.uniform(*prange)
+        return sys
+
+
+    def _svd_jitter(self, sys):
+        '''Jitter the parameters of one of the systems functions, in SVD space.'''
+        k = self.rng.integers(0, len(sys) * 3)
+        sidx, pidx = divmod(k, 3)
+        if pidx < 2:
+            q = self.rng.uniform(-0.5, 0.5)
+            u, s, v = np.linalg.svd(sys[sidx, :, :2])
+            cq, sq = np.cos(q), np.sin(q)
+            r = np.array([[cq, -sq], [sq, cq]])
+            if pidx == 0:
+                u = r @ u
+            else:
+                v = r @ v
+            sys[sidx, :, :2] = (u * s[None,:]) @ v
+        else:
+            x, y = self.rng.uniform(-0.5, 0.5, (2,))
+            sys[sidx, :, 2] += [x, y]
+        return sys
+
+
+    def _sval_jitter(self, sys):
+        k = self.rng.integers(0, sys.shape[0])
+        svs = np.linalg.svd(sys[...,:2], compute_uv=False)
+        fac = (svs * [1, 2]).sum()
+        minf = 0.5 * (5 + sys.shape[0])
+        maxf = minf + 0.5
+        ss = svs[k, 0] + 2 * svs[k, 1]
+        smin = (minf - fac + ss) / ss
+        smax = (maxf - fac + ss) / ss
+        m = self.rng.uniform(smin, smax)
+        u, s, v = np.linalg.svd(sys[k, :, :2])
+        s = s * m
+        sys[k, :, :2] = (u * s[None]) @ v
+        return sys
+
+
+    # IFSパラメータ微小変動
+    def jitter(self, sys):
+        # 4回、微小変動を起こす
+        attempts = 4 if self.jitter_params else 0
+        for i in range(attempts):
+            # jitter system parameters
+            sysc = sys.copy()
+            sysc = self.jitter_fnc(sysc)
+            # 特異値分解、対角行列の特異値のみ計算
+            # occasionally the modified parameters cause the system to explode
+            svd = np.linalg.svd(sysc[:,:,:2], compute_uv=False)
+            # 1を超えている場合発散するので再度jitする
+            if svd.max() > 1: continue
+
+            self.jitter_success += 1
+            break
+        else:
+            # fall back on not jittering the parameters
+            self.jitter_failed += 1
+            sysc = sys
+        return sysc
+    
+    
+    # IFSフラクタル座標と範囲の計算
+    def _iterate(self, sys):
+        rng = self.rng
+
+        # 全フラクタル点の座標を計算
+        coords = ifs.iterate(sys, self.niter)
+        
+        # フラクタル点の座標範囲、[xmin, ymin, xmax, ymax]
+        region = np.concatenate(ifs.minmax(coords))
+
+        return coords, region
+
+
+    def render(self, sys):
+        raise NotImplementedError()
+
+
+    # データ拡張(RandomFlip)
+    def random_flips(self, img):
+        # random flips/rotations
+        if self.rng.random() > 0.5:
+            # 縦横転置
+            img = img.transpose(1, 0)
+        if self.rng.random() > 0.5:
+            # 上下反転
+            img = img[::-1]
+        if self.rng.random() > 0.5:
+            # 左右反転
+            img = img[:, ::-1]
+        # 配列のメモリ連続性を確保するため
+        img = np.ascontiguousarray(img)
+        return img
+
+
+    # フラクタル画像のカラー化
+    def to_color(self, img):
+        # カラー画像化
+        return ifs.colorize(img, min_sat=self.min_sat, hue_base=self.hue_base, hue_range=self.hue_range)
+
+
+    # 白黒画像
+    def to_gray(self, img):
+        # バイナリ画像なので中間の127の灰色画像で、3チャンネルにしておく
+        return (img * 1024).clip(0, 255).astype(np.uint8)[..., None].repeat(3, axis=2)
+
+
+    # 背景画像を作成
+    def render_background(self):
+        # 幾何模様のカラー背景作成
+        bg = diamondsquare.colorized_ds(self.size)
+        # 背景を暗くする
+        #bg = bg * 0.5
+        return bg
+
+
+    # 背景に前景を埋め込み
+    def composite(self, foreground, base, idx=None):
+        return ifs.composite(foreground, base)
+
+    # 背景に前景を埋め込み
+    def composite_v2(self, foreground, base, mask, idx=None):
+        return ifs.composite_v2(foreground, base, mask)
+
+    # データ拡張(ボカし)
+    def random_blur(self, img):
+        # 標準偏差取得
+        sigma = self.rng.uniform(*self.sigma)
+        # 画像平坦化
+        img = GaussianBlur(img, (3, 3), sigma, dst=img)
+        return img
+    
+
+    def generate(self, sys):
+        raise NotImplementedError()
+
+
+    def __call__(self, sys, *args, **kwargs):
+        return self.generate(sys, *args, **kwargs)
+
+
+
+class MultiGenerator(_GeneratorBase):
+    def __init__(
+        self,
+        # 画像サイズ
+        size: int = 224,
+        # キャッシュサイズ
+        cache_size: int = 100,
+        # 混合数
+        n_objects: Tuple[int, int] = (1, 5),
+        # 埋め込み画像サイズ
+        size_range: Tuple[float, float] = (0.2, 0.6),
+        # jitパラメータ、デフォルトではなし
+        jitter_params: Union[bool, str] = False,
+        # データ拡張(縦横、左右、上下反転)フラグ
+        flips: bool = True,
+        # ボカしの標準偏差
+        sigma: Optional[Tuple[float, float]] = (0.5, 1.0),
+        # データ拡張(ボケ実施確率)
+        blur_p: Optional[float] = 0.5,
+        # カラー画像フラグ
+        color = True,
+        # 背景画像の付与の有無
+        background = True,
+        # フラクタル点数
+        niter = 100000,
+        # patch処理実施有無
+        patch = True,
+        # 混合画像の採用確率?
+        nobj_p = None,
+
+        seed = 0,
+        n_instance_types = 1,
+    ):
+        self.size = size
+        self.n_objects = n_objects
+        self.size_range = size_range
+        self.jitter_params = jitter_params
+        self.flips = flips
+        self.sigma = sigma
+        self.blur_p = blur_p
+        self.color = color
+        self.background = background
+        self.niter = niter
+        self.patch = patch
+
+        self.bg_sel_cache_idx = 0
+        self.sel_cache_idx = 0
+
+        self.jitter_success = 0
+        self.jitter_failed = 0
+
+        np.random.seed(seed)
+        self.hue_bases = [np.random.uniform(0, 179) for _ in range(n_instance_types)]
+        self.min_sats = [np.random.uniform(0.0, 0.50) for _ in range(n_instance_types)]
+        self.max_sats = [min(1, self.min_sats[i] * 2 + 0.2) for i in range(n_instance_types)]
+        self.hue_ranges = [max(0, 179 * (0.8 - self.min_sats[i]) / 0.8) for i in range(n_instance_types)]
+
+        # 乱数生成器
+        self.rng = np.random.default_rng(seed=0)
+
+        
+        
+        # キャッシュサイズ
+        self.cache_size = cache_size
+        # 前景と背景のキャッシュ
+        self.cache = {'fg': [], 'bg': [], 'label': []}
+        self.idx = 0
+
+        # 混合確率
+        if nobj_p is None:
+            # 等確率
+            self.nobj_p = np.ones(n_objects[1] - n_objects[0] + 1)
+        else:
+            self.nobj_p = np.array(nobj_p, dtype=np.float64)
+        self.nobj_p /= self.nobj_p.sum()
+
+        # jit関数設定
+        self._set_jitter()
+
+
+    # フラクタル画像のカラー化
+    def to_color(self, img, instance_label):
+        # カラー画像化
+        return ifs.colorize(img, 
+                            min_sat=self.min_sats[instance_label], 
+                            hue_base=self.hue_bases[instance_label], 
+                            hue_range=self.hue_ranges[instance_label],
+                            max_sat=self.max_sats[instance_label])
+
+
+    def __len__(self):
+        # 前景キャッシュ数を返す
+        return len(self.cache['fg'])
+
+
+    def _update_cache(self, fg, bg, label):
+        if len(self) < self.cache_size:
+            # キャッシュサイズ以下であれば追記
+            self.cache['fg'].append(fg)
+            self.cache['bg'].append(bg)
+            self.cache['label'].append(label)
+        else:
+            # idx番目に追加
+            self.cache['fg'][self.idx] = fg
+            self.cache['bg'][self.idx] = bg
+            self.cache['label'][self.idx] = label
+        # キャッシュ番号
+        self.idx = (self.idx + 1) % self.cache_size
+
+
+    # 前景のフラクタル画像作成
+    def render(self, sys):
+        # 乱数生成器コピー
+        rng = self.rng
+        # フラクタル座標と範囲
+        coords, region = self._iterate(sys)
+        # render the fractal at half resolution--it will be resized during generation phase
+        img = ifs.render(coords, self.size, binary=False, region=region, patch=self.patch)
+        return img
+
+
+    # キャッシュに前景と背景画像を追加
+    def add_sample(self, sys, label=-1):
+        # IFSパラメータの微少変動
+        sysc = self.jitter(sys)
+        # フラクタル画像生成
+        frac = self.render(sysc)
+        # 背景画像の生成
+        bg = self.render_background()
+        # MixUPとかできないのでラベルは使わない
+        # キャッシュに追加
+        self._update_cache(frac, bg, label)
+
+
+    # Multi-Fractal画像を作成
+    def generate(self, sys, label=-1, new_sample=True):
+        # 乱数生成器コピー
+        rng = self.rng
+
+        # 新規追加しない、
+        # インスタンス時に全キャッシュ作成済みでそこからとってくる
+        #if new_sample:
+        #    self.add_sample(sys, label)
+
+        # 背景画像をキャッシュ内からランダムに選択
+        idx = self.bg_sel_cache_idx % len(self)#rng.integers(0, len(self))
+        self.bg_sel_cache_idx += 1
+        img = self.cache['bg'][idx].copy()
+        # 背景なしの場合はブランク画像
+        if self.background==False:
+            img = np.zeros(img.shape, np.uint8)
+        
+        # ラベルは使わない
+        labels = []
+
+        # 混合数を乱数選択
+        n = rng.choice(range(self.n_objects[0], self.n_objects[1]+1), p=self.nobj_p)
+        # キャッシュサイズでキャップ
+        n = min(n, len(self))
+
+        # 混合数回分繰り返し
+        for i in range(n):
+            # キャッシュ番号選択
+            idx = self.sel_cache_idx % len(self) # rng.integers(0, len(self))#
+            self.sel_cache_idx += 1
+
+            # ラベルリストに追加
+            labels.append(self.cache['label'][idx])
+
+            # 前景画像取得
+            fg = self.cache['fg'][idx]
+            label = self.cache['label'][idx]
+
+            if True:
+                # データ拡張(転置、水平、上下反転)
+                # random flips
+                if self.flips:
+                    fg = self.random_flips(fg)
+
+                # colorize
+                if self.color:
+                    # カラー画像化
+                    fg = self.to_color(fg, label)
+                else:
+                    # 白黒画像化
+                    fg = self.to_gray(fg)
+
+                # 0.2-0.6倍でリサイズ
+                # リサイズ倍率
+                f = rng.uniform(*self.size_range)
+                # リサイズ
+                s = int(f * self.size)
+                fg = resize(fg, (s, s), interpolation=INTER_CUBIC)
+
+                # データ拡張(回転)
+                if self.blur_p and rng.random() > self.blur_p:
+                    # 回転角度
+                    angle = rng.integers(-45, 45, 1)[0]
+                    # 回転中心
+                    height, width, channel = fg.shape                                    
+                    center = (int(width/2), int(height/2))
+                    # 等倍
+                    scale = 1.0
+                    #getRotationMatrix2D関数を使用
+                    trans = getRotationMatrix2D(center, angle , scale)
+                    #アフィン変換
+                    fg = warpAffine(fg, trans, (width,height))
+
+                # ランダム埋め込み位置
+                # random location
+                x, y = rng.integers(-(s//3), self.size-s+(s//3), 2)
+                x1 = 0 if x >= 0 else -x
+                x2 = s if x < self.size - s else self.size - x
+                y1 = 0 if y >= 0 else -y
+                y2 = s if y < self.size - s else self.size - y
+                fg = fg[y1:y2, x1:x2]
+                # add object to image
+                y = max(y, 0)
+                x = max(x, 0)
+                self.composite(fg, img[y:y+fg.shape[0], x:x+fg.shape[1]])
+            else:
+                fg_gray = fg.copy()
+                fg = self.to_color(fg)
+                f = 0.8#rng.uniform(*self.size_range)
+                # リサイズ
+                s = int(f * self.size)
+                fg = resize(fg, (s, s), interpolation=INTER_CUBIC)
+                fg_gray = resize(fg_gray, (s, s), interpolation=INTER_CUBIC)
+
+                x, y = 0, 0
+                x1 = 0 if x >= 0 else -x
+                x2 = s if x < self.size - s else self.size - x
+                y1 = 0 if y >= 0 else -y
+                y2 = s if y < self.size - s else self.size - y
+                fg = fg[y1:y2, x1:x2]
+                fg_gray = fg_gray[y1:y2, x1:x2]
+                y = max(y, 0)
+                x = max(x, 0)
+                self.composite(fg, img[y:y+fg.shape[0], x:x+fg.shape[1]])
+                # self.composite_v2(fg, img[y:y+fg.shape[0], x:x+fg.shape[1]], fg_gray)
+
+
+            #x, y = rng.integers(-(s//2), self.size-(s//2), 2)
+            # # 見切れ防止
+            # x, y = rng.integers(0, self.size-s, 2)
+            # # 見切れ範囲除外
+            # x1 = 0 if x >= 0 else -x
+            # x2 = s if x < self.size - s else self.size - x
+            # y1 = 0 if y >= 0 else -y
+            # y2 = s if y < self.size - s else self.size - y
+            # fg = fg[y1:y2, x1:x2]
+            # # add object to image
+            # y = max(y, 0)
+            # x = max(x, 0)
+            # # 埋め込み範囲のみ重畳描画する、背景画像に重畳していく
+            # self.composite(fg, img[y:y+fg.shape[0], x:x+fg.shape[1]])
+
+        # ボカし実施
+        # randomly apply gaussian blur
+        # if self.blur_p and rng.random() > self.blur_p:
+        #     img = self.random_blur(img)
+
+        return img, labels

src/multi_fractal_db/serach_ifs_systems.py

@@ -0,0 +1,179 @@
+import tqdm
+import numpy as np
+
+# IFSシステムのパラメータ探索
+def random_systems(num_systems, n=(2,5), bval=None, beta=None, sample_fn=None):
+    '''Sample random systems.
+
+    Args:
+        num_systems (int): the number of systems to sample.
+        n (int or Tuple[int, int]): the size or range of sizes allowable for the systems.
+        bval (float): allowable magnitude of translation parameters.
+        beta (float or Tuple[float,float]): singular values constraint. See sample_systems.
+
+    Returns:
+        A list of dicts {'system': np.array} containing the system parameters.
+    '''
+    # 乱数生成器
+    rng = np.random.default_rng(seed=0)
+    systems = []
+    for i in tqdm.trange(num_systems):
+        # IFSシステムパラメータ取得
+        s = sample_system(n, bval=bval, beta=beta, rng=rng, sample_fn=sample_fn)
+        systems.append({'system': s})
+    return systems
+
+
+def sample_system(n=None, constrain=True, bval=1, rng=None, beta=None, sample_fn=None):
+    '''Return n random affine transforms. If constrain=True, enforce the transforms
+    to be strictly contractive (by forcing singular values to be less than 1).
+    
+    Args:
+        n (Union[range,Tuple[int,int],List[int,int],None]): range of values to sample from for the number of
+            transforms to sample. If None (default), then sample from range(2, 8).
+        constrain (bool): if True, enforce contractivity of transformations. Technically, an IFS must be
+            contractive; however, FractalDB does not enforce it during search, so it is left as an option here.
+            Default: True.
+        bval (Union[int,float]): maximum magnitude of the translation parameters sampled for each transform.
+            The translation parameters don't effect contractivity, and so can be chosen arbitrarily. Ignored and set
+            to 1 when constrain is False. Default: 1.
+        rng (Optional[numpy.random._generator.Generator]): random number generator. If None (default), it defaults
+            to np.random.default_rng().
+        beta (float or Tuple[float, float]): range for weighted sum of singular values when constrain==True. Let 
+            q ~ U(beta[0], beta[1]), then we enforce $\sum_{i=0}^{n-1} (s^i_1 + 2*s^i_2) = q$.
+        sample_fn (callable): function used for sampling singular values. Should accept three arguments: n, for
+            the size of the system; a, for the sigma-factor; and rng, the random generator. When None (default),
+            uses sample_svs.
+    
+    Returns:
+        Numpy array of shape (n, 2, 3), containing n sets of 2x3 affine transformation matrices.
+        '''
+    # Numpy乱数生成
+    if rng is None:
+        rng = np.random.default_rng(seed=0)
+
+    # 重ね合わせ方程式の数
+    if n is None:
+        n = rng.integers(2, 8)
+    elif isinstance(n, range):
+        n = rng.integers(n.start, n.stop)
+    elif isinstance(n, (tuple, list)):
+        n = rng.integers(*n)
+
+    # まともなフラクタル生成範囲
+    if beta is None:
+        beta = ((5 + n) / 2, (6 + n) / 2)
+
+    # 何かの関数
+    if sample_fn is None:
+        sample_fn = sample_svs
+    
+    # まともな範囲のパラメータに制限
+    if constrain:
+        # sample a matrix with singular values < 1 (a contraction)
+        # 1. sample the singular vectors--random orthonormal matrices--by randomly rotating the standard basis
+        base = np.sign(rng.random((2*n, 2, 1)) - 0.5) * np.eye(2)
+        # 回転角度
+        angle = rng.uniform(-np.pi, np.pi, 2*n)
+        # 回転行列
+        ss = np.sin(angle)
+        cc = np.cos(angle)
+        rmat = np.empty((2 * n, 2, 2))
+        rmat[:, 0, 0] = cc
+        rmat[:, 0, 1] = -ss
+        rmat[:, 1, 0] = ss
+        rmat[:, 1, 1] = cc
+        uv = rmat @ base
+        u, v = uv[:n], uv[n:]
+        # 2. sample the singular values
+        a = rng.uniform(*beta)
+        s = sample_fn(n, a, rng)
+        # 3. sample the translation parameters from Uniform(-bval, bval) and create the transformation matrix
+        m = np.empty((n, 2, 3))
+        # 回転行列
+        m[:, :, :2] = u * s[:, None, :] @ v
+        # 並進行列
+        m[:, :, 2] = rng.uniform(-bval, bval, (n, 2))
+    else:
+        m = rng.uniform(-1, 1, (n, 2, 3))
+
+    return m
+
+
+
+def sample_svs(n, a, rng=None):
+    '''Sample singular values. 2*`n` singular values are sampled such that the following conditions
+    are satisfied, for singular values sv_{i} and i = 0, ..., 2n-1:
+    
+    1. 0 <= sv_{i} <= 1
+    2. sv_{2i} >= sv_{2i+1}
+    3. w.T @ S = `a`, for S = [sv_{0}, ..., sv_{2n-1}] and w = [1, 2, ..., 1, 2]
+    
+    Args:
+        n (int): number of pairs of singular values to sample.
+        a (float): constraint on the weighted sum of all singular values. Note that a must be in the
+            range (0, 3*n).
+        rng (Optional[numpy.random._generator.Generator]): random number generator. If None (default), it defaults
+            to np.random.default_rng().
+            
+    Returns:
+        Numpy array of shape (n, 2) containing the singular values.
+    '''
+    if rng is None: rng = np.random.default_rng()
+    if a < 0: a == 0
+    elif a > 3*n: a == 3*n
+    s = np.empty((n, 2))
+    p = a
+    q = a - 3*n + 3
+    # sample the first 2*(n-1) singular values (first n-1 pairs)
+    for i in range(n - 1):
+        s1 = rng.uniform(max(0, q/3), min(1, p))
+        q -= s1
+        p -= s1
+        s2 = rng.uniform(max(0, q/2), min(s1, p/2))
+        q = q - 2 * s2 + 3
+        p -= 2 * s2
+        s[i, :] = s1, s2
+    # sample the last pair of singular values
+    s2 = rng.uniform(max(0, (p-1)/2), p/3)
+    s1 = p - 2*s2
+    s[-1, :] = s1, s2
+    
+    return s
+
+def sample_svs_rej(n, a, rng=None):
+    '''Sample singular values uniformly from the joint distribution over the n-dimensional surface
+    defined by the constraints (see sample_svs). Uniform sampling is achieved by means of rejection
+    sampling.
+
+    Args:
+        n (int): number of pairs of singular values to sample.
+        a (float): constraint on the weighted sum of all singular values. Note that a must be in the
+            range (0, 3*n).
+        rng (Optional[numpy.random._generator.Generator]): random number generator. If None (default), it defaults
+            to np.random.default_rng().
+            
+    Returns:
+        Numpy array of shape (n, 2) containing the singular values.
+    '''
+    if rng is None:
+        rng = np.random.default_rng()
+    if a < 0: a = 0
+    elif a > 3 * n: a = 3 * n
+
+    w = np.ones(2 * n - 1)
+    w[1::2] = 2
+    s = np.zeros((n, 2))
+    for i in range(1000):
+        s.ravel()[:-1] = rng.random(2 * n - 1)
+        # restrict to below the y=x line
+        r = s[:, 1] > s[:, 0]
+        s[r, :] = s[r][:, ::-1]
+        # check if valid or reject
+        b = (a - w @ s.ravel()[:-1]) / 2
+        if b <= s[-1, 0] and b >= 0:
+            s[-1, 1] = b
+            break
+    else:
+        print('Rejection sampling failed')
+    return s

src/validator.py

@@ -0,0 +1,158 @@
+import os
+from PIL import Image
+from tqdm import tqdm
+
+class Validator():
+    def __init__(self, data_format: dict, verbose=False) -> None:
+        assert isinstance(data_format, dict)
+        self.data_format = data_format
+        if verbose:
+            print('\nValidation details:')
+            for k, v in self.data_format.items():
+                print('  {}: {}'.format(k, v))
+        self.data = None
+        print('\nValidation:')
+
+
+    def check_data(self, result) -> None:
+        raise NotImplementedError
+
+
+    def check_samples(self, result) -> None:
+        raise NotImplementedError
+
+
+    def check_dtype(self, result) -> None:
+        raise NotImplementedError
+
+
+    def check_keys(self, result) -> None:
+        raise NotImplementedError
+
+
+    def check_details(self, result) -> None:
+        raise NotImplementedError
+
+
+    def validate(self, result) -> None:
+        self.check_data(result)
+        self.check_samples(result)
+        self.check_dtype(result)
+        self.check_keys(result)
+        self.check_details(result)
+
+
+    def get_data(self) -> None:
+        return self.data
+
+
+class ImageFolderValidator(Validator):
+    def check_data(self, result) -> None:
+        msg = '  Checking data...'
+        print(msg, end='\r')
+        for category in tqdm(os.listdir(result)):
+            if not os.path.isdir(os.path.join(result, category)):
+                raise NotADirectoryError('Not a directory.')
+            if len(os.listdir(os.path.join(result, category))) == 0:
+                raise NullError('No data in {}'.format(category))
+        print(msg+' Done')
+
+
+    def check_samples(self, result) -> None:
+        msg = '  Checking samples...'
+        print(msg, end='\r')
+        for category in tqdm(os.listdir(result)):
+            for image_path in os.listdir(os.path.join(result, category)):
+                try:
+                    img = Image.open(os.path.join(result, category, image_path))
+                except:
+                    raise SampleError('Missing samples or invalid samples found.')
+        print(msg+' Done')
+
+
+    def check_dtype(self, result) -> None:
+        msg = '  Checking dtype...'
+        print(msg, end='\r')
+        num_channels = None
+        size = None
+        count = 0
+        for category in tqdm(os.listdir(result)):
+            for image_path in os.listdir(os.path.join(result, category)):
+                img = Image.open(os.path.join(result, category, image_path))
+                c = len(img.getbands())
+                if num_channels != c or size != img.size:
+                    count += 1
+                num_channels = c
+                size = img.size
+                if count >= 2:
+                    raise DimError('Dim mismatch found.')
+        print(msg+' Done')
+
+
+    def check_keys(self, result) -> None:
+        pass
+
+
+    def check_details(self, result) -> None:
+        msg = '  Checking details...'
+        num_categories = self.data_format['num_categories']
+        num_images = self.data_format['num_images']
+        if len(os.listdir(result))!=num_categories:
+            raise NumCategoryError('Number of categories is not {}'.format(num_categories))
+        for category in tqdm(os.listdir(result)):
+            image_paths = os.listdir(os.path.join(result, category))
+            if len(image_paths)!=num_images:
+                raise NumImageError('Number of images is not {} in {}'.format(num_images, category))
+        print(msg+' Done')
+
+
+class NotADirectoryError(Exception):
+    pass
+
+
+class SampleError(Exception):
+    pass
+
+
+class DimError(Exception):
+    pass
+
+
+class DtypeError(Exception):
+    pass
+
+
+class ExtentionError(Exception):
+    pass
+
+
+class DelimiterError(Exception):
+    pass
+
+
+class NumColumnsError(Exception):
+    pass
+
+
+class NullError(Exception):
+    pass
+
+
+class DiscreteDataError(Exception):
+    pass
+
+
+class MaximumExceedError(Exception):
+    pass
+
+
+class InstanceError(Exception):
+    pass
+
+
+class NumCategoryError(Exception):
+    pass
+
+
+class NumImageError(Exception):
+    pass