cv-tda 0.0.1__tar.gz

cv_tda-0.0.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: cv-tda
+Version: 0.0.1
+Summary: A Library to Solve Various Computer Vision Problems Using Topological Data Analysis
+Author-email: Aleksandr Abramov <ggttpo100ajiex@yandex.ru>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/TTPO100AJIEX/CVTDA
+Keywords: topological data analysis,computer vision,algebraic topology,image analysis,classification,face recognition,topological features
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: ==3.10
+Description-Content-Type: text/markdown
+Requires-Dist: giotto-tda==0.6.2
+Requires-Dist: gudhi>=3.10.1
+Requires-Dist: joblib>=1.4.2
+Requires-Dist: scikit-learn==1.6.1
+Requires-Dist: scikit-image>=0.25.0
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: classification
+Requires-Dist: catboost>=1.2.7; extra == "classification"
+Requires-Dist: xgboost>=3.0.0; extra == "classification"
+Requires-Dist: matplotlib>=3.10.1; extra == "classification"
+Requires-Dist: pandas>=2.2.3; extra == "classification"
+Requires-Dist: torch>=2.5.1; extra == "classification"
+Requires-Dist: torchvision>=0.20.1; extra == "classification"
+Requires-Dist: torchph==0.0.0; extra == "classification"
+Provides-Extra: face-recognition
+Requires-Dist: pytorch-metric-learning==2.8.1; extra == "face-recognition"
+Requires-Dist: matplotlib>=3.10.1; extra == "face-recognition"
+Requires-Dist: torch>=2.5.1; extra == "face-recognition"
+Requires-Dist: torchvision>=0.20.1; extra == "face-recognition"
+Requires-Dist: torchph==0.0.0; extra == "face-recognition"
+
+# Computer Vision With Topological Data Analysis
+
+TO BE DONE

cv_tda-0.0.1/README.md

@@ -0,0 +1,3 @@
+# Computer Vision With Topological Data Analysis
+
+TO BE DONE

cv_tda-0.0.1/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cv-tda"
+version = "0.0.1"
+authors = [
+  { name = "Aleksandr Abramov", email = "ggttpo100ajiex@yandex.ru" },
+]
+description = "A Library to Solve Various Computer Vision Problems Using Topological Data Analysis"
+readme = "README.md"
+requires-python = "==3.10"
+dependencies = [
+  "giotto-tda==0.6.2",
+  "gudhi>=3.10.1",
+  "joblib>=1.4.2",
+  "scikit-learn==1.6.1",
+  "scikit-image>=0.25.0",
+  "tqdm>=4.67.1",
+]
+keywords = [
+  "topological data analysis",
+  "computer vision",
+  "algebraic topology",
+  "image analysis",
+  "classification",
+  "face recognition",
+  "topological features",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3.10",
+  "Topic :: Scientific/Engineering",
+  "Topic :: Scientific/Engineering :: Image Processing",
+]
+license = "MIT"
+license-files = ["LICENCE*"]
+
+[project.optional-dependencies]
+classification = [
+  "catboost>=1.2.7",
+  "xgboost>=3.0.0",
+  "matplotlib>=3.10.1",
+  "pandas>=2.2.3",
+  "torch>=2.5.1",
+  "torchvision>=0.20.1",
+  "torchph==0.0.0"
+]
+face_recognition = [
+  "pytorch-metric-learning==2.8.1",
+  "matplotlib>=3.10.1",
+  "torch>=2.5.1",
+  "torchvision>=0.20.1",
+  "torchph==0.0.0"
+]
+
+[project.urls]
+Repository  = "https://github.com/TTPO100AJIEX/CVTDA"

cv_tda-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cv_tda-0.0.1/src/cv_tda.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: cv-tda
+Version: 0.0.1
+Summary: A Library to Solve Various Computer Vision Problems Using Topological Data Analysis
+Author-email: Aleksandr Abramov <ggttpo100ajiex@yandex.ru>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/TTPO100AJIEX/CVTDA
+Keywords: topological data analysis,computer vision,algebraic topology,image analysis,classification,face recognition,topological features
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: ==3.10
+Description-Content-Type: text/markdown
+Requires-Dist: giotto-tda==0.6.2
+Requires-Dist: gudhi>=3.10.1
+Requires-Dist: joblib>=1.4.2
+Requires-Dist: scikit-learn==1.6.1
+Requires-Dist: scikit-image>=0.25.0
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: classification
+Requires-Dist: catboost>=1.2.7; extra == "classification"
+Requires-Dist: xgboost>=3.0.0; extra == "classification"
+Requires-Dist: matplotlib>=3.10.1; extra == "classification"
+Requires-Dist: pandas>=2.2.3; extra == "classification"
+Requires-Dist: torch>=2.5.1; extra == "classification"
+Requires-Dist: torchvision>=0.20.1; extra == "classification"
+Requires-Dist: torchph==0.0.0; extra == "classification"
+Provides-Extra: face-recognition
+Requires-Dist: pytorch-metric-learning==2.8.1; extra == "face-recognition"
+Requires-Dist: matplotlib>=3.10.1; extra == "face-recognition"
+Requires-Dist: torch>=2.5.1; extra == "face-recognition"
+Requires-Dist: torchvision>=0.20.1; extra == "face-recognition"
+Requires-Dist: torchph==0.0.0; extra == "face-recognition"
+
+# Computer Vision With Topological Data Analysis
+
+TO BE DONE

cv_tda-0.0.1/src/cv_tda.egg-info/SOURCES.txt

@@ -0,0 +1,52 @@
+README.md
+pyproject.toml
+src/cv_tda.egg-info/PKG-INFO
+src/cv_tda.egg-info/SOURCES.txt
+src/cv_tda.egg-info/dependency_links.txt
+src/cv_tda.egg-info/requires.txt
+src/cv_tda.egg-info/top_level.txt
+src/cvtda/classification/NNClassifier.py
+src/cvtda/classification/__init__.py
+src/cvtda/classification/classify.py
+src/cvtda/classification/estimate_quality.py
+src/cvtda/classification/information_value.py
+src/cvtda/dumping/__init__.py
+src/cvtda/dumping/base.py
+src/cvtda/dumping/devnull.py
+src/cvtda/dumping/dump_name_concat.py
+src/cvtda/dumping/numpy.py
+src/cvtda/face_recognition/BaseLearner.py
+src/cvtda/face_recognition/DiagramsLearner.py
+src/cvtda/face_recognition/NNLearner.py
+src/cvtda/face_recognition/SimpleTopologicalLearner.py
+src/cvtda/face_recognition/__init__.py
+src/cvtda/face_recognition/learn.py
+src/cvtda/logging/__init__.py
+src/cvtda/logging/base.py
+src/cvtda/logging/cli.py
+src/cvtda/logging/devnull.py
+src/cvtda/neural_network/Dataset.py
+src/cvtda/neural_network/NNBase.py
+src/cvtda/neural_network/__init__.py
+src/cvtda/topology/DiagramVectorizer.py
+src/cvtda/topology/FeatureExtractor.py
+src/cvtda/topology/FiltrationsExtractor.py
+src/cvtda/topology/GeometryExtractor.py
+src/cvtda/topology/GreyscaleExtractor.py
+src/cvtda/topology/PointCloudsExtractor.py
+src/cvtda/topology/__init__.py
+src/cvtda/topology/interface/Extractor.py
+src/cvtda/topology/interface/TopologicalExtractor.py
+src/cvtda/topology/interface/__init__.py
+src/cvtda/topology/utils/__init__.py
+src/cvtda/topology/utils/hstack.py
+src/cvtda/topology/utils/process_iter.py
+src/cvtda/topology/utils/process_iter_dump.py
+src/cvtda/utils/__init__.py
+src/cvtda/utils/duplicates.py
+src/cvtda/utils/image2pointcloud.py
+src/cvtda/utils/rgb2gray.py
+src/cvtda/utils/rgb2hsv.py
+src/cvtda/utils/sequence2features.py
+src/cvtda/utils/set_random_seed.py
+src/cvtda/utils/spread_points.py

cv_tda-0.0.1/src/cv_tda.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cv_tda-0.0.1/src/cv_tda.egg-info/requires.txt

@@ -0,0 +1,22 @@
+giotto-tda==0.6.2
+gudhi>=3.10.1
+joblib>=1.4.2
+scikit-learn==1.6.1
+scikit-image>=0.25.0
+tqdm>=4.67.1
+
+[classification]
+catboost>=1.2.7
+xgboost>=3.0.0
+matplotlib>=3.10.1
+pandas>=2.2.3
+torch>=2.5.1
+torchvision>=0.20.1
+torchph==0.0.0
+
+[face_recognition]
+pytorch-metric-learning==2.8.1
+matplotlib>=3.10.1
+torch>=2.5.1
+torchvision>=0.20.1
+torchph==0.0.0

cv_tda-0.0.1/src/cv_tda.egg-info/top_level.txt

@@ -0,0 +1 @@
+cvtda

cv_tda-0.0.1/src/cvtda/classification/NNClassifier.py

@@ -0,0 +1,173 @@
+import typing
+
+import numpy
+import torch
+import sklearn.base
+import sklearn.metrics
+import torch.utils.data
+
+import cvtda.utils
+import cvtda.logging
+import cvtda.neural_network
+
+
+class NNClassifier(sklearn.base.ClassifierMixin):
+    def __init__(
+        self,
+
+        n_jobs: int = -1,
+        random_state: int = 42,
+
+        device: torch.device = torch.device("cuda"),
+        batch_size: int = 256,
+        learning_rate: float = 1e-3,
+        n_epochs: int = 100,
+        
+        skip_diagrams: bool = False,
+        skip_images: bool = False,
+        skip_features: bool = False
+    ):
+        self.n_jobs_ = n_jobs
+        self.random_state_ = random_state
+
+        self.device_ = device
+        self.batch_size_ = batch_size
+        self.learning_rate_ = learning_rate
+        self.n_epochs_ = n_epochs
+
+        self.skip_diagrams_ = skip_diagrams
+        self.skip_images_ = skip_images
+        self.skip_features_ = skip_features
+
+
+    def fit(self, train: cvtda.neural_network.Dataset, val: typing.Optional[cvtda.neural_network.Dataset]):
+        cvtda.utils.set_random_seed(self.random_state_)
+        train_dl = torch.utils.data.DataLoader(
+            torch.utils.data.TensorDataset(train.images, train.features, train.labels, torch.arange(len(train))),
+            batch_size = self.batch_size_,
+            shuffle = True
+        )
+        self.init_(len(torch.unique(train.labels)), *next(iter(train_dl)), train)
+
+        for epoch in range(self.n_epochs_):
+            sum_loss = 0
+
+            self.model_list_.train()
+            for images, features, labels, diagram_idxs in cvtda.logging.logger().pbar(train_dl, desc = f"Epoch {epoch}"):
+                self.optimizer_.zero_grad()
+                pred = self.forward_(images, features, diagram_idxs, train)
+                loss = torch.nn.functional.cross_entropy(pred, labels.to(self.device_), reduction = 'mean')
+                loss.backward()
+                self.optimizer_.step()
+                sum_loss += loss.item()
+            postfix = { 'loss': sum_loss, 'lr': self.optimizer_.param_groups[0]['lr'] }
+            self.scheduler_.step()
+
+            if val is not None:
+                val_proba = self.predict_proba_(val)
+                val_pred = numpy.argmax(val_proba, axis = 1)
+                postfix['val_acc'] = sklearn.metrics.accuracy_score(val.labels, val_pred)
+
+            print(f"Epoch {epoch}:", postfix)
+
+        self.fitted_ = True
+        return self
+    
+    def predict_proba(self, dataset: cvtda.neural_network.Dataset) -> numpy.ndarray:
+        assert self.fitted_ is True, 'fit() must be called before predict_proba()'
+        cvtda.utils.set_random_seed(self.random_state_)
+        return self.predict_proba_(dataset)
+
+
+    def init_(
+        self,
+        num_classes: int,
+        images: torch.Tensor,
+        features: torch.Tensor,
+        labels: torch.Tensor,
+        diagram_idxs: torch.Tensor,
+        dataset: cvtda.neural_network.Dataset
+    ):
+        diagrams = [] if self.skip_diagrams_ else dataset.get_diagrams(diagram_idxs)
+
+        is_no_topology = (self.skip_diagrams_ and self.skip_features_ and not self.skip_images_)
+        print('Topology: ', not is_no_topology)
+        print('Images: ', images.shape)
+        print('Features: ', features.shape)
+
+        if is_no_topology:
+            images_output = num_classes
+        else:
+            images_output = 1024
+        
+        self.nn_base_ = cvtda.neural_network.NNBase(
+            num_diagrams = len(diagrams) // 2,
+            skip_diagrams = self.skip_diagrams_,
+            skip_images = self.skip_images_,
+            skip_features = self.skip_features_,
+            images_n_channels = images.shape[1],
+            images_output = images_output
+        ).to(self.device_).train()
+
+        self.model_ = torch.nn.Sequential(
+            torch.nn.Dropout(0.4), torch.nn.LazyLinear(256), torch.nn.BatchNorm1d(256), torch.nn.GELU(),
+            torch.nn.Dropout(0.3), torch.nn.Linear(256, 128), torch.nn.BatchNorm1d(128), torch.nn.GELU(),
+            torch.nn.Dropout(0.2), torch.nn.Linear(128, 64), torch.nn.BatchNorm1d(64), torch.nn.GELU(),
+            torch.nn.Dropout(0.1), torch.nn.Linear(64, 32), torch.nn.BatchNorm1d(32), torch.nn.GELU(),
+            torch.nn.Linear(32, num_classes)
+        ).to(self.device_).train()
+
+        if is_no_topology:
+            self.model_ = torch.nn.Identity()
+
+        self.model_list_ = torch.nn.ModuleList([ self.nn_base_, self.model_ ])
+
+        self.optimizer_ = torch.optim.AdamW(
+            params = self.model_list_.parameters(),
+            lr = self.learning_rate_ * 100
+        )
+        
+        def lr_scheduler_lambda(epoch):
+            if epoch < self.n_epochs_ // 10:
+                return 1
+            if epoch < self.n_epochs_ // 4:
+                return 0.1
+            if epoch < self.n_epochs_ // 2:
+                return 0.01
+            if epoch < 3 * self.n_epochs_ // 4:
+                return 0.001
+            return 0.0001
+        self.scheduler_ = torch.optim.lr_scheduler.LambdaLR(self.optimizer_, lr_scheduler_lambda)
+
+        self.forward_(images, features, diagram_idxs, dataset)
+        if not is_no_topology:
+            cvtda.logging.logger().print(f'Input to LazyLinear: {self.model_[1].in_features}')
+        cvtda.logging.logger().print(f'Parameters: {sum(p.numel() for p in self.model_list_.parameters())}')
+
+    def forward_(
+        self,
+        images: torch.Tensor,
+        features: torch.Tensor,
+        diagram_idxs: torch.Tensor,
+        dataset: cvtda.neural_network.Dataset
+    ) -> torch.Tensor:
+        images = images.to(self.device_)
+        features = features.to(self.device_)
+        if self.skip_diagrams_:
+            return self.model_(self.nn_base_(images, features))
+        return self.model_(self.nn_base_(images, features, *dataset.get_diagrams(diagram_idxs)))
+
+    def predict_proba_(self, dataset: cvtda.neural_network.Dataset) -> numpy.ndarray:
+        dl = torch.utils.data.DataLoader(
+            torch.utils.data.TensorDataset(dataset.images, dataset.features, torch.arange(len(dataset))),
+            batch_size = self.batch_size_,
+            shuffle = False
+        )
+
+        y_pred_proba = [ ]
+        self.model_list_.eval()
+        with torch.no_grad():
+            for images, features, diagram_idxs in dl:
+                y_pred_proba.append(self.forward_(images, features, diagram_idxs, dataset))
+        y_pred_proba = torch.vstack(y_pred_proba)
+        return torch.nn.functional.softmax(y_pred_proba, dim = 1).cpu().numpy()

cv_tda-0.0.1/src/cvtda/classification/__init__.py

@@ -0,0 +1,6 @@
+from .classify import classify
+from .estimate_quality import estimate_quality
+from .information_value import calculate_binary_information_value
+from .information_value import calculate_information_value
+from .information_value import InformationValueFeatureSelector
+from .NNClassifier import NNClassifier

cv_tda-0.0.1/src/cvtda/classification/classify.py

@@ -0,0 +1,209 @@
+import os
+import typing
+
+import numpy
+import torch
+import pandas
+import xgboost
+import catboost
+import sklearn.base
+import sklearn.ensemble
+import sklearn.neighbors
+import matplotlib.pyplot as plt
+
+import cvtda.dumping
+import cvtda.neural_network
+from .NNClassifier import NNClassifier
+from .estimate_quality import estimate_quality
+
+def classify(
+    train_images: numpy.ndarray,
+    train_features: numpy.ndarray,
+    train_labels: numpy.ndarray,
+    train_diagrams: typing.Optional[typing.List[numpy.ndarray]],
+
+    test_images: numpy.ndarray,
+    test_features: numpy.ndarray,
+    test_labels: numpy.ndarray,
+    test_diagrams: typing.Optional[typing.List[numpy.ndarray]],
+
+    label_names: typing.Optional[typing.List[str]] = None,
+    confusion_matrix_include_values: bool = True,
+
+    n_jobs: int = -1,
+    random_state: int = 42,
+    dump_name: typing.Optional[str] = None,
+    only_get_from_dump: bool = False,
+
+    knn_neighbours: int = 50,
+
+    random_forest_estimators: int = 100,
+
+    nn_device: torch.device = torch.device('cuda'),
+    nn_batch_size: int = 256,
+    nn_learning_rate: float = 1e-3,
+    nn_epochs: int = 100,
+
+    grad_boost_max_iter: int = 20,
+    grad_boost_max_depth: int = 4,
+    grad_boost_max_features: float = 0.1,
+
+    xgboost_n_classifiers: int = 25,
+    xgboost_max_depth: int = 4,
+    xgboost_device: str = 'gpu',
+
+    catboost_iterations: int = 600,
+    catboost_depth: int = 4,
+    catboost_device: str = 'GPU',
+
+    without_diagrams: bool = False
+):
+    if (train_images is not None) and (not only_get_from_dump):
+        nn_train = cvtda.neural_network.Dataset(
+            train_images, train_diagrams, train_features, train_labels, n_jobs = n_jobs, device = nn_device
+        )
+        nn_test = cvtda.neural_network.Dataset(
+            test_images, test_diagrams, test_features, test_labels, n_jobs = n_jobs, device = nn_device
+        )
+
+    def classify_one(classifier: sklearn.base.ClassifierMixin, name: str, display_name: str, ax: plt.Axes):
+        if without_diagrams and name == 'NNClassifier_diagrams':
+            print(f'Skipping {name} - {classifier}')
+            return {}
+
+        print(f'Trying {name} - {classifier}')
+
+        dumper = cvtda.dumping.dumper()
+        model_dump_name = cvtda.dumping.dump_name_concat(dump_name, name)
+        if only_get_from_dump or dumper.has_dump(model_dump_name):
+            y_pred_proba = dumper.get_dump(model_dump_name)
+        else:
+            if type(classifier) == NNClassifier:
+                classifier.fit(nn_train, nn_test)
+                y_pred_proba = classifier.predict_proba(nn_test)
+            else:
+                classifier.fit(train_features, train_labels)
+                y_pred_proba = classifier.predict_proba(test_features)
+
+            if model_dump_name is not None:
+                dumper.save_dump(y_pred_proba, model_dump_name)
+                
+        ax.set_title(display_name)
+        result = {
+            'classifier': display_name,
+            **estimate_quality(
+                y_pred_proba, test_labels, ax,
+                label_names = label_names, confusion_matrix_include_values = confusion_matrix_include_values
+            )
+        }
+        print(result)
+        return result
+
+    classifiers = [
+        sklearn.neighbors.KNeighborsClassifier(
+            n_jobs = n_jobs,
+            n_neighbors = knn_neighbours
+        ),
+        sklearn.ensemble.RandomForestClassifier(
+            n_estimators = random_forest_estimators,
+            random_state = random_state,
+            n_jobs = n_jobs
+        ),
+        sklearn.ensemble.HistGradientBoostingClassifier(
+            random_state = random_state,
+            max_iter = grad_boost_max_iter,
+            max_depth = grad_boost_max_depth,
+            max_features = grad_boost_max_features,
+            verbose = 2
+        ),
+        catboost.CatBoostClassifier(
+            iterations = catboost_iterations,
+            depth = catboost_depth,
+            random_seed = random_state,
+            loss_function = 'MultiClass',
+            devices = '0-3',
+            task_type = catboost_device,
+            verbose = True
+        ),
+        xgboost.XGBClassifier(
+            n_jobs = n_jobs,
+            n_estimators = xgboost_n_classifiers,
+            max_depth = xgboost_max_depth,
+            device = xgboost_device
+        ),
+        NNClassifier(
+            random_state = random_state,
+            device = nn_device,
+            batch_size = nn_batch_size,
+            learning_rate = nn_learning_rate,
+            n_epochs = nn_epochs * 2,
+            skip_diagrams = True,
+            skip_images = True,
+            skip_features = False,
+        ),
+        NNClassifier(
+            random_state = random_state,
+            device = nn_device,
+            batch_size = nn_batch_size,
+            learning_rate = nn_learning_rate,
+            n_epochs = nn_epochs // 5,
+            skip_diagrams = False,
+            skip_images = True,
+            skip_features = True,
+        ),
+        NNClassifier(
+            random_state = random_state,
+            device = nn_device,
+            batch_size = nn_batch_size,
+            learning_rate = nn_learning_rate,
+            n_epochs = nn_epochs,
+            skip_diagrams = True,
+            skip_images = False,
+            skip_features = True,
+        ),
+        NNClassifier(
+            random_state = random_state,
+            device = nn_device,
+            batch_size = nn_batch_size,
+            learning_rate = nn_learning_rate,
+            n_epochs = nn_epochs,
+            skip_diagrams = True,
+            skip_images = False,
+            skip_features = False,
+        )
+    ]
+    names = [
+        'KNeighborsClassifier',
+        'RandomForestClassifier',
+        'HistGradientBoostingClassifier',
+        'CatBoostClassifier',
+        'XGBClassifier',
+        'NNClassifier_features',
+        'NNClassifier_diagrams',
+        'NNClassifier_images',
+        'NNClassifier_features_images'
+    ]
+    display_names = [
+        'Метод k ближайших соседей',
+        'Случайный лес',
+        'Град. бустинг на основе гистограмм',
+        'CatBoost',
+        'XGBoost',
+        'Нейронная сеть для тополог. признаков',
+        'Обучаемая векторизация диаграмм',
+        'ResNet50 – базовая модель',
+        'Комбинированная нейронная сеть'
+    ]
+
+    figure, axes = plt.subplots(3, 3, figsize = (15, 15))
+    df = pandas.DataFrame([ classify_one(*args) for args in zip(classifiers, names, display_names, axes.flat) ])
+    figure.tight_layout()
+
+    dumper = cvtda.dumping.dumper()
+    if (dump_name is not None) and isinstance(dumper, cvtda.dumping.NumpyDumper):
+        file = dumper.get_file_name_(cvtda.dumping.dump_name_concat(dump_name, "confusion_matrixes"))
+        os.makedirs(os.path.dirname(file), exist_ok = True)
+        figure.savefig(file[:-4] + ".svg")
+        figure.savefig(file[:-4] + ".png")
+        df.to_csv(dumper.get_file_name_(cvtda.dumping.dump_name_concat(dump_name, "quality_metrics.csv"))[:-4])
+    return df

cv_tda-0.0.1/src/cvtda/classification/estimate_quality.py

@@ -0,0 +1,47 @@
+import typing
+
+import numpy
+import sklearn.metrics
+import matplotlib.pyplot as plt
+
+def estimate_quality(
+    y_pred_proba: numpy.ndarray,
+    y_true: numpy.ndarray,
+    ax: typing.Optional[plt.Axes] = None,
+    label_names: typing.Optional[typing.List[str]] = None,
+    confusion_matrix_include_values: bool = True
+) -> dict:
+    if label_names is None:
+        label_names = list(range(y_pred_proba.shape[1]))
+
+    y_pred = numpy.argmax(y_pred_proba, axis = 1)
+    if ax:
+        sklearn.metrics.ConfusionMatrixDisplay.from_predictions(
+            y_true, y_pred, ax = ax, colorbar = False,
+            display_labels = label_names, include_values = confusion_matrix_include_values
+        )
+        ax.set_xticks(ax.get_xticks(), labels = ax.get_xticklabels(), rotation = 45, ha = "right", rotation_mode = "anchor")
+        ax.set_xlabel(None)
+        ax.set_ylabel(None)
+
+    numeric_labels = list(range(y_pred_proba.shape[1]))
+    auc_roc_input = y_pred_proba
+    multi_class = 'ovo'
+    average = 'macro'
+    
+    if y_pred_proba.shape[1] == 2:
+        auc_roc_input = y_pred_proba[:, 1]
+        multi_class = 'raise'
+        average = 'binary'
+    
+    metrics = {
+        'Accuracy':       sklearn.metrics.accuracy_score      (y_true, y_pred),
+        'AUC-ROC':        sklearn.metrics.roc_auc_score       (y_true, auc_roc_input, multi_class = multi_class, labels = numeric_labels),
+        'Precision':      sklearn.metrics.precision_score     (y_true, y_pred,        average = average,   zero_division = 0),
+        'Recall':         sklearn.metrics.recall_score        (y_true, y_pred,        average = average),
+        'F1-score':       sklearn.metrics.f1_score            (y_true, y_pred,        average = average)
+    }
+    for k in [ 2, 3, 5, 7, 9, 15, 30 ]:
+        if y_pred_proba.shape[1] > k:
+            metrics[f'TOP-{k} Accuracy'] = sklearn.metrics.top_k_accuracy_score(y_true, y_pred_proba, k = k, labels = numeric_labels)
+    return metrics