feat: setup repo

.gitignore

@@ -0,0 +1,134 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# poetry
+poetry.lock
+
+# pdm
+pdm.lock
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Idea project settings
+.idea
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+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.

dataset/test_labels.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff7e84b144c037e7215dfa787d6773550c5db83029d9a4e7bae6e90f605f081d
+size 10128

dataset/test_point_clouds.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30fc5923e8c438bae6b0c467ed1642ac81ca11308c6563bb66a838bdb080a047
+size 11580128

dataset/train_labels.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5dd4d822cab3e20099239bc9d433d587ae3ce00e084d191079dd30b38380b336
+size 60128

dataset/train_point_clouds.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bbfb3577c041af905cb3a3f0910e604df3aa65b5303a1f71bb7ea8f31598dbb8
+size 69480128

requirements.txt

@@ -0,0 +1,6 @@
+matplotlib==3.8.2
+numpy==1.24.3
+pydantic==2.7.1
+PyYAML==6.0.1
+tensorflow==2.13.0
+typing_extensions==4.11.0

src/mnist3d/io_.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+
+
+def import_dataset(
+    dir_path: Path,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Import dataset.
+
+    Parameters
+    ----------
+    dir_path : Path
+
+    Returns
+    -------
+    Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+
+    """
+    return (
+        np.load(Path(rf"{dir_path}\train_point_clouds.npy")),
+        np.load(Path(rf"{dir_path}\train_labels.npy")),
+        np.load(Path(rf"{dir_path}\test_point_clouds.npy")),
+        np.load(Path(rf"{dir_path}\test_labels.npy")),
+    )
+
+
+def export_dataset(
+    train_point_clouds: np.ndarray,
+    train_labels: np.ndarray,
+    test_point_clouds: np.ndarray,
+    test_labels: np.ndarray,
+    dir_path: Path,
+) -> None:
+    """
+    Export dataset as NumPy arrays.
+
+    Parameters
+    ----------
+    train_point_clouds : np.ndarray
+    train_labels : np.ndarray
+    test_point_clouds : np.ndarray
+    test_labels : np.ndarray
+    dir_path : Path
+
+    """
+    np.save(Path(rf"{dir_path}\train_point_clouds"), train_point_clouds)
+    np.save(Path(rf"{dir_path}\train_labels"), train_labels)
+    np.save(Path(rf"{dir_path}\test_point_clouds"), test_point_clouds)
+    np.save(Path(rf"{dir_path}\test_labels"), test_labels)

src/mnist3d/main.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, InitVar, field
+from pathlib import Path
+from typing import Tuple
+
+import numpy as np
+import tensorflow as tf
+
+from io_ import export_dataset
+from parameters import Parameters, import_parameters
+
+np.random.seed(42)
+
+IMAGE_SIZE = 28
+
+
+def main(
+    parameters: Parameters,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Load the original MNIST dataset and convert images to point clouds.
+
+    Parameters
+    ----------
+    parameters : Parameters
+
+    Returns
+    -------
+    Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]
+
+    """
+    mnist = tf.keras.datasets.mnist
+    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
+
+    binary_intensities = compute_binary_intensities(
+        train_images, parameters.pixel_intensity_threshold
+    )
+    point_count = compute_point_count(binary_intensities)
+
+    train_point_clouds = convert_images_to_point_clouds(
+        train_images,
+        point_count,
+        parameters.pixel_intensity_threshold,
+        parameters.noise_standard_deviation,
+    )
+    test_point_clouds = convert_images_to_point_clouds(
+        test_images,
+        point_count,
+        parameters.pixel_intensity_threshold,
+        parameters.noise_standard_deviation,
+    )
+    return train_point_clouds, train_labels, test_point_clouds, test_labels
+
+
+@dataclass
+class ActivePixelStats:
+    """
+    Active pixel (i.e. intensity = 1) statistics.
+
+    Parameters
+    ----------
+    binary_intensities : np.ndarray
+        Binary pixel intensities (i.e. 0 or 1).
+
+    Attributes
+    ----------
+    counts : np.ndarray
+    first_quartile : int
+    third_quartile : int
+    median : int
+    iqr : float
+        Interquartile range.
+    minimum : int
+        Outliers excluded.
+    maximum : int
+        Outliers excluded.
+
+    """
+
+    binary_intensities: InitVar[np.ndarray]
+    counts: np.ndarray = field(init=False)
+    first_quartile: int = field(init=False)
+    third_quartile: int = field(init=False)
+    median: int = field(init=False)
+    minimum: int = field(init=False)
+    maximum: int = field(init=False)
+
+    def __post_init__(self, binary_intensities: np.ndarray) -> None:
+        self.counts = np.sum(binary_intensities, axis=1).astype(int)
+        self.first_quartile = np.percentile(self.counts, 25).astype(int)
+        self.third_quartile = np.percentile(self.counts, 75).astype(int)
+        self.median = np.median(self.counts).astype(int)
+        self.iqr = self.third_quartile - self.first_quartile
+        iqr_factor = 1.5
+        self.minimum = self.counts[
+            self.counts >= self.first_quartile - iqr_factor * self.iqr
+        ].min()
+        self.maximum = self.counts[
+            self.counts <= self.third_quartile + iqr_factor * self.iqr
+        ].max()
+
+
+def create_xy_grid(image_size: int) -> np.ndarray:
+    """
+    Create x-y grid.
+
+    Parameters
+    ----------
+    image_size : int
+        Pixel count (the image is squared).
+
+    Returns
+    -------
+    np.ndarray
+
+    """
+    x = np.tile(np.linspace(0.0, 1.0, image_size), image_size)
+    y = np.repeat(np.linspace(0.0, 1.0, image_size), image_size)
+    return np.column_stack((x, y))
+
+
+def convert_images_to_point_clouds(
+    images: np.ndarray,
+    point_count: int,
+    pixel_intensity_threshold: int,
+    noise_standard_deviation: float,
+) -> np.ndarray:
+    """
+    Convert images to point clouds.
+
+    Parameters
+    ----------
+    images : np.ndarray
+    point_count : int
+    pixel_intensity_threshold : int
+    noise_standard_deviation : float
+
+    Returns
+    -------
+    np.ndarray
+
+    """
+    binary_intensities = compute_binary_intensities(images, pixel_intensity_threshold)
+
+    xy_grid = create_xy_grid(image_size=IMAGE_SIZE)
+    xy_grids = np.tile(xy_grid, (images.shape[0], 1, 1))
+    point_clouds = np.concatenate(
+        (xy_grids, binary_intensities[:, :, np.newaxis]), axis=2
+    )
+
+    point_clouds_resized = np.array(
+        [resize_point_cloud(point_cloud, point_count) for point_cloud in point_clouds]
+    )
+    point_clouds_resized_noisy = np.array(
+        [
+            add_noise(point_cloud, noise_standard_deviation)
+            for point_cloud in point_clouds_resized
+        ]
+    )
+    return point_clouds_resized_noisy.astype(np.float16)
+
+
+def compute_binary_intensities(
+    images: np.ndarray, pixel_intensity_threshold: int
+) -> np.ndarray:
+    """
+    Compute binary pixel intensities (i.e. 0 or 1).
+
+    Parameters
+    ----------
+    images : np.ndarray
+    pixel_intensity_threshold : int
+
+    Returns
+    -------
+    np.ndarray
+
+    """
+    images = (images > pixel_intensity_threshold).astype(int)
+    return images.reshape(images.shape[0], images.shape[1] * images.shape[2])
+
+
+def compute_point_count(binary_intensities: np.ndarray) -> int:
+    """
+    Compute the number of points as the maximum of the boxplot (excluding any outliers).
+
+    Parameters
+    ----------
+    binary_intensities : np.ndarray
+
+    Returns
+    -------
+    int
+
+    """
+    active_pixel_stats = ActivePixelStats(binary_intensities)
+    return active_pixel_stats.maximum
+
+
+def resize_point_cloud(point_cloud: np.ndarray, point_count: int) -> np.ndarray:
+    """
+    Resize point cloud to have `point_count` points.
+
+    Parameters
+    ----------
+    point_cloud :  p.ndarray
+    point_count : int
+
+    Returns
+    -------
+    np.ndarray
+
+    """
+    point_cloud = point_cloud[point_cloud[:, 2] > 0]
+    if len(point_cloud) < point_count:
+        missing_count = point_count - len(point_cloud)
+        indices = np.random.choice(len(point_cloud), missing_count)
+        return np.concatenate((point_cloud, point_cloud[indices, :]), axis=0)
+    elif len(point_cloud) > point_count:
+        indices = np.random.choice(len(point_cloud), point_count)
+        return point_cloud[indices, :]
+    else:
+        return point_cloud
+
+
+def add_noise(point_cloud: np.ndarray, standard_deviation: float) -> np.ndarray:
+    """
+    Add gaussian noise.
+
+    Parameters
+    ----------
+    point_cloud : np.ndarray
+    standard_deviation : float
+
+    Returns
+    -------
+    np.ndarray
+
+    """
+    point_cloud[:, 2] = point_cloud[:, 2] - 1.0
+    noise = np.random.normal(0.0, standard_deviation, point_cloud.shape)
+    return point_cloud + noise
+
+
+if __name__ == "__main__":
+    parameters_ = import_parameters()
+    train_point_clouds, train_labels, test_point_clouds, test_labels = main(parameters_)
+    export_dataset(
+        train_point_clouds,
+        train_labels,
+        test_point_clouds,
+        test_labels,
+        dir_path=Path("../../dataset"),
+    )

src/mnist3d/parameters.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import yaml
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
+
+
+class Parameters(BaseModel):
+    """
+    Parameters.
+
+    Attributes
+    ----------
+    pixel_intensity_threshold : int
+    noise_standard_deviation : float
+
+    """
+
+    pixel_intensity_threshold: Annotated[int, Field(strict=True, gt=0, lt=255)]
+    noise_standard_deviation: Annotated[float, Field(strict=True, gt=0.0, lt=1.0)]
+
+
+def import_parameters() -> Parameters:
+    """
+    Import parameters.
+
+    Returns
+    -------
+    Parameters
+
+    """
+    with open("params.yaml", "r") as file:
+        parameter_to_value = yaml.safe_load(file.read())
+
+    return Parameters(
+        pixel_intensity_threshold=parameter_to_value["pixel_intensity_threshold"],
+        noise_standard_deviation=parameter_to_value["noise_standard_deviation"],
+    )

src/mnist3d/params.yaml

@@ -0,0 +1,5 @@
+# Pixel intensity threshold (Integer)
+pixel_intensity_threshold: 128
+
+# Gaussian noise standard deviation (Float)
+noise_standard_deviation: 0.01

src/mnist3d/plotter.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import numpy as np
+import tensorflow as tf
+from matplotlib import pyplot as plt
+
+from io_ import import_dataset
+from main import compute_binary_intensities, ActivePixelStats
+from parameters import Parameters, import_parameters
+
+
+def main(parameters: Parameters) -> None:
+    """
+    Plot image pixel intensity distributions, active pixel count boxplot, and images and
+    corresponding point clouds.
+
+    Parameters
+    ----------
+    parameters : Parameters
+
+    """
+    mnist = tf.keras.datasets.mnist
+    (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
+    plot_image_pixel_intensity_distributions(
+        train_images, train_labels, title="Train Images"
+    )
+    plot_image_pixel_intensity_distributions(
+        test_images, test_labels, title="Test Images"
+    )
+
+    binary_intensities = compute_binary_intensities(
+        train_images, parameters.pixel_intensity_threshold
+    )
+    active_pixel_stats = ActivePixelStats(binary_intensities)
+    plot_active_pixel_count_boxplot(active_pixel_stats)
+
+    train_point_clouds, train_labels, test_point_clouds, test_labels = import_dataset(
+        dir_path=Path("../../dataset")
+    )
+    label_count = 10
+    label_to_indices = {
+        index: np.where(train_labels == index)[0] for index in range(label_count)
+    }
+    indices = [np.random.choice(indices) for indices in label_to_indices.values()]
+    for label, index in enumerate(indices):
+        plot_point_cloud_image(train_point_clouds[index], train_images[index], label)
+
+
+def plot_point_cloud_image(
+    point_cloud: np.ndarray, image: np.ndarray, label: int
+) -> None:
+    """
+    Plot point cloud and corresponding image.
+
+    Parameters
+    ----------
+    point_cloud : np.ndarray
+    image : np.ndarray
+    label : int
+
+    """
+    figure = plt.figure(figsize=(12, 6))
+
+    axis_point_cloud = figure.add_subplot(121, projection="3d")
+    axis_point_cloud.scatter(
+        point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2], s=40
+    )
+    axis_point_cloud.set_xlim(0.0, 1.0)
+    axis_point_cloud.set_ylim(0.0, 1.0)
+    axis_point_cloud.set_zlim(-0.1, 0.1)
+    axis_point_cloud.view_init(elev=-90, azim=-85)
+
+    axis_image = figure.add_subplot(122)
+    axis_image.imshow(image, cmap="gray")
+    axis_image.set_xticks([])
+    axis_image.set_yticks([])
+
+    figure.suptitle(f"Label: {label}")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_image_pixel_intensity_distributions(
+    images: np.ndarray, labels: np.ndarray, title: str
+) -> None:
+    """
+    Plot image pixel intensity distributions.
+
+    Parameters
+    ----------
+    images : np.ndarray
+    labels : np.ndarray
+    title : str
+
+    """
+    label_count = 10
+    figure, axis = plt.subplots(2, 5, figsize=(12, 5))
+    for label in range(label_count):
+        indices = np.where(labels == label)[0]
+        intensities = images[indices].flatten()
+        i = 0 if label < label_count // 2 else 1
+        j = label if label < label_count // 2 else (label - label_count // 2)
+        axis[i, j].hist(intensities, bins=40)
+        axis[i, j].set_title(label)
+        axis[i, j].set_xticks(np.arange(0, 256, 85))
+        axis[i, j].get_yaxis().set_visible(False)
+
+    figure.suptitle(f"{title} - Pixel Intensity Distributions")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_active_pixel_count_boxplot(active_pixel_stats: ActivePixelStats) -> None:
+    """
+    Plot active pixel counts boxplot.
+
+    Parameters
+    ----------
+    active_pixel_stats : ActivePixelStats
+
+    """
+    figure, axis = plt.subplots(figsize=(5, 6))
+    plt.boxplot(active_pixel_stats.counts)
+
+    median = np.median(active_pixel_stats.median)
+    minimum = np.min(active_pixel_stats.minimum)
+    maximum = np.max(active_pixel_stats.maximum)
+
+    axis.annotate(f"Median: {median}", xy=(1, median), xytext=(1.1, median))
+    axis.annotate(f"Minimum: {minimum}", xy=(1, minimum), xytext=(1.1, minimum))
+    axis.annotate(f"Maximum: {maximum}", xy=(1, maximum), xytext=(1.1, maximum))
+
+    plt.xlabel("Intensity = 1")
+    plt.ylabel("Count")
+    plt.tight_layout()
+    plt.show()
+
+
+if __name__ == "__main__":
+
+    parameters_ = import_parameters()
+    main(parameters_)

src/mnist3d/size_calculator.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import os
+import zipfile
+from pathlib import Path
+from typing import List
+
+DIR_PATH = Path("../../dataset")
+
+
+def compute_dataset_sizes() -> List[int]:
+    """
+    Compute the dataset size in bytes.
+
+    Returns
+    -------
+    List[int]
+
+    """
+    return [
+        os.path.getsize(Path(DIR_PATH, filename)) for filename in os.listdir(DIR_PATH)
+    ]
+
+
+def compute_download_size() -> int:
+    """
+    Compute the download size in bytes.
+
+    Returns
+    -------
+    int
+
+    """
+    archive_path = Path(DIR_PATH, "archive.zip")
+    with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_LZMA) as zipf:
+        for filename in os.listdir(DIR_PATH):
+            zipf.write(os.path.join(DIR_PATH, filename), arcname=filename)
+    return os.path.getsize(archive_path)
+
+
+if __name__ == "__main__":
+    dataset_sizes = compute_dataset_sizes()
+    dataset_size = sum(dataset_sizes)
+    download_size = compute_download_size()