myfirstnn 0.1.0__py3-none-any.whl

myfirstnn/__main__.py

@@ -0,0 +1,10 @@
+"""
+This file is called at the start of the package myfirstNN
+Authors: Alessio Parolini
+"""
+
+from myfirstnn.core import main
+
+if __name__ == "__main__":
+
+    main()

myfirstnn/core/__init__.py

@@ -0,0 +1,3 @@
+from myfirstnn.core.start import *
+
+__all__ = ["main"]

myfirstnn/core/start.py

@@ -0,0 +1,21 @@
+"""
+main.py
+Authors: Alessio Parolini
+Manage and starts all the functions from other sub-packages. Imported in __main__.py for starts the package.
+"""
+
+__all__ = ["main"]
+
+from myfirstnn.display import AutoNNApp
+
+
+def main() -> None:
+
+    app = AutoNNApp()
+
+    app.run()
+
+
+if __name__ == "__main__":
+
+    main()

myfirstnn/display/__init__.py

@@ -0,0 +1,3 @@
+from myfirstnn.display.app import *
+
+__all__ = ["AutoNNApp"]

myfirstnn/display/app.py

@@ -0,0 +1,21 @@
+"""
+This file manage the user interaction with the software via CLI
+Authors: Alessio Parolini
+"""
+
+__all__ = ["AutoNNApp"]
+
+from textual.app import App, ComposeResult
+
+from .components import Titles, ModelConfig
+
+
+class AutoNNApp(App):
+
+    CSS_PATH = "styles/app.tcss"
+
+    def compose(self) -> ComposeResult:
+
+        yield Titles()
+
+        yield ModelConfig()

myfirstnn/display/components/__init__.py

@@ -0,0 +1,5 @@
+from myfirstnn.display.components.headers import *
+
+from myfirstnn.display.components.form import *
+
+__all__ = ["Titles", "ModelConfig"]

myfirstnn/display/components/form.py

@@ -0,0 +1,107 @@
+"""
+form.py
+Authors: Alessio Parolini
+This file contains the class to make the user config his model
+"""
+
+__all__ = ["ModelConfig"]
+
+from textual.widgets import Label, Input, Button, RichLog
+
+from textual.app import ComposeResult
+
+from textual.containers import Container, Center
+
+from textual import work
+
+from myfirstnn.learning import model_learning as model_l
+
+from myfirstnn.learning import random_io_tensors as rand_tens
+
+from myfirstnn.neuraln import SimpleNN
+
+
+class ModelConfig(Container):
+    """
+    This class manage the user inputs to start the training
+    """
+
+    def __init__(self, *children, **kwargs):
+
+        super().__init__(*children, **kwargs)
+
+    def compose(self) -> ComposeResult:
+
+        yield Label(
+            content="[bold]Write here your model name:[/]",
+            id="model-label",
+            classes="form-label",
+        )
+
+        yield Input(
+            placeholder="Your model name here...",
+            id="model-name",
+            type="text",
+        )
+
+        yield Label(
+            content="[bold]How much data you wanna use (type an integer)?[/] Remind: more data means more work for your CPU/GPU",
+            id="inputs-label",
+            classes="form-label",
+        )
+
+        yield Input(
+            placeholder="Enter the number of input do you wanna use...",
+            id="model-inputs",
+            type="integer",
+            restrict="^[0-9]+$",
+        )
+
+        with Center():
+
+            yield Button(
+                label="Start training!",
+                id="start-button",
+                variant="warning",
+            )
+
+        yield RichLog(markup=True, id="training-log")
+
+    # functions
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+
+        if event.button.id == "start-button":
+
+            model_name = self.query_one("#model-name", Input).value or "UserModel"
+
+            model_inputs = self.query_one("#model-inputs", Input).value or 200
+
+            self.query_one("#start-button", Button).disabled = True
+
+            self.app.set_focus(self.query_one("#training-log"))
+
+            self.training_setup(model_name=model_name, model_inputs=int(model_inputs))
+
+    @work(thread=True, exclusive=True)
+    def training_setup(self, model_name: str, model_inputs: int):
+        """
+        Uses the resources form other sub-packages (learning and neuraln) to create a model and train it.
+        Everything runs on a separate thread
+        """
+
+        model = SimpleNN(name=model_name)
+
+        test_data = rand_tens(
+            n_input=model_inputs, n_range=2, y_function=lambda x: x**2
+        )
+
+        text_log = self.query_one(RichLog)
+
+        text_log.write("Starting the model log...")
+
+        model_l(model=model, data=test_data, epochs=10000, log_func=text_log.write)
+
+        self.app.call_from_thread(
+            lambda: setattr(self.query_one("#start-button", Button), "disabled", False)
+        )

myfirstnn/display/components/headers.py

@@ -0,0 +1,39 @@
+"""
+tui.py
+Authors: Alessio Parolini
+This file contains the class for the app headers
+"""
+
+__all__ = ["Titles"]
+
+from textual.app import ComposeResult
+
+from textual.widgets import Label
+
+from textual.containers import Container, Center
+
+
+class Titles(Container):
+
+    def compose(self) -> ComposeResult:
+
+        with Center():
+
+            yield Label(
+                content=r"""
+                         ░██               ░███    ░██ ░███    ░██
+                         ░██               ░████   ░██ ░████   ░██
+ ░██████   ░██    ░██ ░████████  ░███████  ░██░██  ░██ ░██░██  ░██
+      ░██  ░██    ░██    ░██    ░██    ░██ ░██ ░██ ░██ ░██ ░██ ░██
+ ░███████  ░██    ░██    ░██    ░██    ░██ ░██  ░██░██ ░██  ░██░██
+░██   ░██  ░██   ░███    ░██    ░██    ░██ ░██   ░████ ░██   ░████
+ ░█████░██  ░█████░██     ░████  ░███████  ░██    ░███ ░██    ░███ """,
+                id="tui-title",
+            )
+
+            yield Label(
+                content="""An incredible tool to create [bold #ffffff]your own AI model[/] from [bold #ffffff]random datas[/]!.\n
+For now, it can learn only how to calculate squares (x^2) of numbers.\n
+[bold]Try to edit number of inputs[/] to see how the precision changes!""",
+                id="description",
+            )

myfirstnn/display/styles/app.tcss

@@ -0,0 +1,93 @@
+/* Styles for the main TUI */
+
+Screen {
+
+    /* for the main app*/
+
+    overflow-y: scroll;
+
+}
+
+#tui-title {
+
+    /* the title */
+
+    color: #ffcc00;
+
+    text-align: center;
+
+}
+
+#description {
+
+    /* the description */
+
+    color: #fffae6;
+
+    text-align: center;
+
+    margin-top: 2;
+
+    border: solid #fffae6;
+
+    padding: 1 2 1 2
+
+}
+
+#start-button {
+
+    /* the button to start the training*/
+
+    margin: 1 2 1 2;
+
+    align: center middle;
+
+}
+
+#training-log {
+
+    height: 10;
+
+    margin: 1 2 1 2;
+
+    border: solid #ffcc00;
+
+}
+
+.form-label {
+
+    /* for the labels in form.py */
+
+    padding: 1 2 1 2
+
+}
+
+Button {
+
+    /* for all the buttons generally */
+
+    margin: 0 5 0 5;
+
+    background: #ffcc00;
+
+}
+
+Titles {
+
+    /* for the TUI titles */
+
+    height: auto;
+
+    align: center middle;
+}
+
+ModelConfig {
+
+    /* for the form.py component */
+
+    margin: 2 2 2 2;
+
+    height: auto;
+
+}
+

myfirstnn/learning/__init__.py

@@ -0,0 +1,3 @@
+from myfirstnn.learning.training import *
+
+__all__ = ["random_io_tensors", "model_learning"]

myfirstnn/learning/training.py

@@ -0,0 +1,98 @@
+"""
+training.py
+Authors: Alessio Parolini
+Manage the training of the model
+"""
+
+__all__ = ["random_io_tensors", "model_learning"]
+
+import torch
+
+from torch import nn
+
+from torch import optim
+
+from myfirstnn.neuraln import SimpleNN
+
+from typing import Callable, Any
+
+
+def random_io_tensors(
+    n_input: int,
+    n_range: int,
+    y_function: Callable[[torch.Tensor], torch.Tensor],
+    seed: int = 28,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Generates random numbers for the tests. They will be always the sames, but's better for training.
+    :param n_input: the number of the random generated numbers
+    :param n_range: the range (before and after zero) where the number are created in
+    :param y_function: the function (even a lambda) to calculate the expected output
+    :param seed: the manual seed, to generate every time the same numbers.
+    :return: 2 torch.Tensors with X and Y
+    """
+
+    torch.manual_seed(seed)  # setting the manual seed
+
+    x = (
+        2 * n_range * torch.rand(n_input, 1) - n_range
+    )  # creating the results and putting in a range from -2 to 2
+
+    y = (
+        y_function(x) + torch.randn(n_input, 1) * 0.001
+    )  # calculating the Y starting from X, using the given function and add a Gaussian noise
+
+    return x, y
+
+
+def model_learning(
+    model: SimpleNN,
+    data: tuple[torch.Tensor, torch.Tensor],
+    epochs: int = 300,
+    log_func: Callable[..., Any] = print,
+):
+    """
+
+    :param model: the model to train
+    :param data: the tuple of data (input and output) to use for the training
+    :param epochs: the number of epochs the training lasts
+    :param log_func: the function to show the log (ex: RichLog to shows logs in the TUI)
+    :return:
+    """
+
+    error = nn.MSELoss()  # initializing the error function
+
+    learning_optimizer = optim.Adam(
+        model.parameters(), lr=0.02
+    )  # initializing the optimizer (ADAM)
+
+    final_loss = 0
+
+    log_func(
+        f"Starting the training for [bold]{getattr(model, 'name')}[/]. It will last exactly [bold]{epochs} epochs[/]. "
+    )
+
+    for epoch in range(epochs):
+
+        learning_optimizer.zero_grad()  # resets the model gradients
+
+        expected_out = model(data[0])  # get the model output
+
+        loss = error(
+            expected_out, data[1]
+        )  # calculate the error from the expected output
+
+        loss.backward()  # update the gradients
+
+        learning_optimizer.step()  # the optimizer updates the weights
+
+        if epoch % 10 == 0:  # every 10 epochs gives a report
+
+            log_func(f"Epoch: {epoch} on {epochs} - Actual loss: {loss.item():.6f}")
+
+        final_loss = (
+            loss.item()
+        )  # updating every epoch for logic causes (if the loop doesn't start) the assignment doesn't happen and there's no error
+
+    log_func(f"""[italic]Training is done[/].\n
+            Final loss: [bold]{final_loss:.6f}[/]""")

myfirstnn/neuraln/__init__.py

@@ -0,0 +1,3 @@
+from myfirstnn.neuraln.model import *
+
+__all__ = ["SimpleNN"]

myfirstnn/neuraln/model.py

@@ -0,0 +1,55 @@
+"""
+model.py
+Author: Alessio Parolini
+Contains the data about the Neural Network Model
+"""
+
+__all__ = ["SimpleNN"]
+
+import torch
+
+from torch import nn
+
+
+class SimpleNN(nn.Module):
+    """
+    This is the class to create the model to predict parables
+    It has got 3 layers:
+    1 -> 22 -> 1.
+    Uses the ReLU
+    """
+
+    def __init__(self, name: str):
+
+        super().__init__()
+
+        self.relu = nn.ReLU()
+
+        self.name = name
+
+        self.layer1 = nn.Linear(in_features=1, out_features=22)  # first layer
+
+        self.layer2 = nn.Linear(in_features=22, out_features=22)  # hidden layer
+
+        self.layer3 = nn.Linear(in_features=22, out_features=1)  # final layer
+
+        self.layers: list[nn.Linear] = [self.layer1, self.layer2, self.layer3]
+
+    def __str__(self) -> str:
+
+        return f"""Model name: {self.name}\n
+                Layers: {len(self.layers)}\n
+                Input: {getattr(self.layers[0], "in_features")}\n
+                Output: {getattr(self.layers[-1], "out_features")}\n"""
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+
+        for layer in self.layers:
+
+            x = layer(x)
+
+            if layer is not self.layers[-1]:
+
+                x = self.relu(x)
+
+        return x

myfirstnn-0.1.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: myfirstnn
+Version: 0.1.0
+Summary: A simple TUI tool to creates and train NN from random data
+Author-email: Alessio Parolini <alepar.ap9@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Environment :: Console
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=8.2.8
+Requires-Dist: torch>=2.14.1
+
+# autoNN
+
+A simple TUI tool to create and train NN on random datas, to **teach the model how to calculate squares (x^2)**
+
+> [!NOTE]
+> I built this project for consolidate my skills and my knowledge about AI and Deep Learning. I know isn't perfect, I
+know isn't so useful, I know the README is a too short... but is a **part of a bigger goal I'm working on. Stay tuned,
+I'm gonna develop it soon**!
+
+## Software Structure
+
+The file has 4 packages:
+
++ **display**: contains the module that handles the TUI with Textual. Also contains the sub-package **components** with
+  the different TUI components.
+
++ **learning**: contains the module with the functions to train the model once is created.
+
++ **neuraln**: contains the module with the class to create the model with his NN.
+
++ **core**: starts and runs all the software. His called in __main__.py to start the whole package
+
+## How it works
+
+When you start the software, the TUI runs in your terminal. When you set the name and the number of inputs, you can
+press the button **"Start Training"** and let the magic starts! You'll see al the log of the training, with a live loss,
+and ** you're gonna prove how an AI model training works!**
+
+## How to install
+
+To install this software, I need to have installed on your machine Python 3.11
+
+## Credit
+
+This project was built using the following amazing open-source libraries:
+
+* **[PyTorch](https://pytorch.org)** - An open-source machine learning framework used for creating, structuring, and
+  training the neural network models.
+* **[Textual](https://textualize.io)** - A Python framework, used to build the beautiful and interactive Terminal User
+  Interface (TUI).
+

myfirstnn-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+myfirstnn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+myfirstnn/__main__.py,sha256=TcQlUl7fpQgW29WnmbkgODwhSjSkWAdbQ7F3ctmzZbw,175
+myfirstnn/core/__init__.py,sha256=L2vT5QwIJj6Y0RF8U2KDy-3ErkX6dnZ5LK_CCdzJMRY,58
+myfirstnn/core/start.py,sha256=XJIkcnJHU0TL9cIvn-9Y_MJ5cJovPRS4iOsJINBoL5A,334
+myfirstnn/display/__init__.py,sha256=NEDcupevQaRSf3VwMEKn43w9a0Qo_8nE6YHIzvZ2giQ,64
+myfirstnn/display/app.py,sha256=22QEkVYwAO2KKsn03PVh8GPtARNSFEagI9SyN8obTF4,385
+myfirstnn/display/components/__init__.py,sha256=vAldwuw63hD7BPn0vAyQs95VFE-1dhESG18siCNvDiE,142
+myfirstnn/display/components/form.py,sha256=-5J-Tyq3wwYAhb7pPQARMaJ7zO_c333KLA1xeOvZJ4U,3032
+myfirstnn/display/components/headers.py,sha256=aO99LoIJ7WMt3MpzBvGkCNxBH8WXiwE-Lg_wfAXnyDQ,1782
+myfirstnn/display/styles/app.tcss,sha256=yXAAHApgjYcqEjVFeimHYdRJNgdVB9XaApbjrmaTYIA,997
+myfirstnn/learning/__init__.py,sha256=NJqUxYAngtzjyYrFSVjkGELOLTcNmzmoyPzn9L7QvE0,96
+myfirstnn/learning/training.py,sha256=ow_oUd8kyHo4xj7HSU0VPOb1AcOtTOGGJlz_I9eb3-o,2995
+myfirstnn/neuraln/__init__.py,sha256=41ymRkks5xfju4sqwWuglA37RTEzCAxkA0kYaTFg7Uw,65
+myfirstnn/neuraln/model.py,sha256=ZJgw_Z-y3i_Nc_rrxpQWi9_rBKGbr4RowG-CGxaxaEQ,1293
+myfirstnn-0.1.0.dist-info/METADATA,sha256=3lZ3DI4KFArbtKBNn5jF7pEga115STyfb_tpfCEFvTI,2227
+myfirstnn-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+myfirstnn-0.1.0.dist-info/entry_points.txt,sha256=3IOrjR6P6Zh4h2cxckcOyk4j4ZidbCZbDNMm4U2kdso,54
+myfirstnn-0.1.0.dist-info/top_level.txt,sha256=TqjeQpcOtbvdiYTwkDdVmGLAedbLCN2NU3UIpQeUYC4,10
+myfirstnn-0.1.0.dist-info/RECORD,,

myfirstnn-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

myfirstnn-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+myfirstnn = myfirstnn.__main__:main

myfirstnn-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+myfirstnn