Centralized Learning – Neural Networks

Examples of centralized machine learning with neural networks on various datasets.

---

Banknote Dataset

banknote_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.banknote_dataset import BanknoteDataset
from kosmos.utils.rng import RNG


def banknote_nn_example() -> None:
    """Run example of training and testing on the Banknote dataset using a neural network."""
    RNG.initialize(seed=1)

    banknote_dataset = BanknoteDataset()

    config = SLTrainConfig(
        dataset=banknote_dataset,
        train_split=0.7,
        batch_size=32,
        num_epochs=50,
        model_config=NeuralNetworkConfig([16, 16]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    banknote_nn_example()

---

Digits Dataset

digits_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.digits_dataset import DigitsDataset
from kosmos.utils.rng import RNG


def digits_nn_example() -> None:
    """Run example of training and testing on the Digits dataset using a neural network."""
    RNG.initialize(seed=1)

    digits_dataset = DigitsDataset()

    config = SLTrainConfig(
        dataset=digits_dataset,
        train_split=0.8,
        batch_size=64,
        num_epochs=50,
        model_config=NeuralNetworkConfig([128, 64]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    digits_nn_example()

---

Income Dataset

income_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.income_dataset import IncomeDataset
from kosmos.utils.rng import RNG


def income_nn_example() -> None:
    """Run example of training and testing on the Income dataset using a neural network."""
    RNG.initialize(seed=1)

    income_dataset = IncomeDataset()

    config = SLTrainConfig(
        dataset=income_dataset,
        train_split=0.7,
        batch_size=128,
        num_epochs=50,
        model_config=NeuralNetworkConfig([128, 64, 32]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    income_nn_example()

---

Iris Dataset

iris_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.iris_dataset import IrisDataset
from kosmos.utils.rng import RNG


def iris_nn_example() -> None:
    """Run example of training and testing on the Iris dataset using a neural network."""
    RNG.initialize(seed=1)

    iris_dataset = IrisDataset()

    config = SLTrainConfig(
        dataset=iris_dataset,
        train_split=0.7,
        batch_size=32,
        num_epochs=50,
        model_config=NeuralNetworkConfig([16, 16]),
        optimizer_config=AdamOptimizerConfig(lr=0.01),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    iris_nn_example()

---

MNIST Dataset

mnist_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.mnist_dataset import MNISTDataset
from kosmos.utils.rng import RNG


def mnist_nn_example() -> None:
    """Run example of training and testing on the MNIST dataset using a neural network."""
    RNG.initialize(seed=1)

    mnist_dataset = MNISTDataset()

    config = SLTrainConfig(
        dataset=mnist_dataset,
        train_split=0.9,
        batch_size=128,
        num_epochs=20,
        model_config=NeuralNetworkConfig([256, 128, 64]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    mnist_nn_example()

---

QSAR Dataset

qsar_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.qsar_dataset import QSARDataset
from kosmos.utils.rng import RNG


def qsar_nn_example() -> None:
    """Run example of training and testing on the QSAR dataset using a neural network."""
    RNG.initialize(seed=1)

    qsar_dataset = QSARDataset()

    config = SLTrainConfig(
        dataset=qsar_dataset,
        train_split=0.8,
        batch_size=32,
        num_epochs=25,
        model_config=NeuralNetworkConfig([64, 32]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    qsar_nn_example()

---

WDBC Dataset

wdbc_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.wdbc_dataset import WDBCDataset
from kosmos.utils.rng import RNG


def wdbc_nn_example() -> None:
    """Run example of training and testing on the WDBC dataset using a neural network."""
    RNG.initialize(seed=1)

    wdbc_dataset = WDBCDataset()

    config = SLTrainConfig(
        dataset=wdbc_dataset,
        train_split=0.8,
        batch_size=32,
        num_epochs=50,
        model_config=NeuralNetworkConfig([64, 32]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    wdbc_nn_example()

---

Wine Dataset

wine_nn_example.py

from kosmos.ml.cl_manager import CLManager
from kosmos.ml.config.factories.loss import CrossEntropyLossConfig
from kosmos.ml.config.factories.lr_scheduler import CosineLearningRateSchedulerConfig
from kosmos.ml.config.factories.model import NeuralNetworkConfig
from kosmos.ml.config.factories.optimizer import AdamOptimizerConfig
from kosmos.ml.config.sl_train import SLTrainConfig
from kosmos.ml.datasets.wine_dataset import WineDataset
from kosmos.utils.rng import RNG


def wine_nn_example() -> None:
    """Run example of training and testing on the Wine dataset using a neural network."""
    RNG.initialize(seed=1)

    wine_dataset = WineDataset()

    config = SLTrainConfig(
        dataset=wine_dataset,
        train_split=0.7,
        batch_size=32,
        num_epochs=50,
        model_config=NeuralNetworkConfig([64, 64]),
        optimizer_config=AdamOptimizerConfig(lr=1e-3),
        lr_scheduler_config=CosineLearningRateSchedulerConfig(max_epochs=50),
        max_grad_norm=1.0,
        loss_config=CrossEntropyLossConfig(),
    )

    manager = CLManager(config)

    for epoch_result in manager.train():
        print(epoch_result)  # noqa: T201
    print(manager.test())  # noqa: T201


if __name__ == "__main__":
    wine_nn_example()