algopipe 0.1.0__tar.gz

algopipe-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: algopipe
+Version: 0.1.0
+Summary: Interactive CLI to generate ML/DL pipelines.
+Author-email: Dhruv Mittal <mittaldhruv41@gmail.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: questionary
+Requires-Dist: rich
+Requires-Dist: black
+Dynamic: license-file

algopipe-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "algopipe"
+version = "0.1.0"
+description = "Interactive CLI to generate ML/DL pipelines."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [{name = "Dhruv Mittal", email = "mittaldhruv41@gmail.com"}]
+dependencies = [
+    "questionary",  # For interactive menus
+    "rich",         # For pretty printing
+    "black",        # For formatting generated code
+]
+
+[project.scripts]
+AlgoPipe = "AlgoPipe.cli:main"  # This allows users to type 'aitool' in terminal

algopipe-0.1.0/setup.cfg

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

algopipe-0.1.0/src/AlgoPipe/cli.py

@@ -0,0 +1,76 @@
+import sys
+import os
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+import AlgoPipe.modules 
+from AlgoPipe.registry import Registry
+from AlgoPipe.generator import PipelineGenerator
+
+console = Console()
+
+def main():
+    console.print(Panel.fit("AI Tool - Interactive Pipeline Builder", style="bold blue"))
+    
+    generator = PipelineGenerator()
+    
+    while True:
+        
+        categories = Registry.get_categories()
+        category = questionary.select(
+            "What would you like to add next?",
+            choices=categories + ["Done (Generate Code)", "Exit"]
+        ).ask()
+
+        if category == "Exit":
+            sys.exit()
+        if category == "Done (Generate Code)":
+            break
+
+        
+        subcategories = Registry.get_subcategories(category)
+        
+        
+        if len(subcategories) == 1:
+            subcategory = subcategories[0]
+        else:
+            subcategory = questionary.select(
+                f"Select a type of {category}:",
+                choices=subcategories
+            ).ask()
+
+        
+        modules = Registry.get_modules(category, subcategory)
+        if not modules:
+            console.print(f"[yellow]No modules found.[/yellow]")
+            continue
+
+        module_name = questionary.select(
+            f"Choose algorithm:",
+            choices=modules
+        ).ask()
+
+        
+        module_instance = Registry.get_module(category, subcategory, module_name)
+        generator.add_step(module_instance)
+        console.print(f"[green]Added {module_name} to pipeline.[/green]")
+
+    
+    output_filename = questionary.text("Output filename:", default="pipeline.py").ask()
+    
+    code = generator.generate_code()
+    
+    
+    try:
+        import black
+        code = black.format_str(code, mode=black.Mode())
+    except ImportError:
+        pass
+
+    with open(output_filename, "w") as f:
+        f.write(code)
+
+    console.print(Panel(f"Successfully generated pipeline at [bold]{os.path.abspath(output_filename)}[/bold]", style="green"))
+
+if __name__ == "__main__":
+    main()

algopipe-0.1.0/src/AlgoPipe/generator.py

@@ -0,0 +1,43 @@
+from typing import List, Tuple
+from AlgoPipe.registry import BaseModule
+
+class PipelineGenerator:
+    def __init__(self):
+        self.pipeline: List[BaseModule] = []
+
+    def add_step(self, module: BaseModule):
+        self.pipeline.append(module)
+
+    def generate_code(self) -> str:
+        all_imports = set()
+        code_blocks = []
+
+        
+        for module in self.pipeline:
+            all_imports.update(module.get_imports())
+            code_blocks.append(module.get_code())
+
+        
+        imports_str = "\n".join(sorted(list(all_imports)))
+
+        body_str = "\n\n".join(code_blocks)
+
+        
+        full_script = (
+            f"# Generated by AI Tool\n"
+            f"import pandas as pd\n"
+            f"import numpy as np\n"
+            f"{imports_str}\n\n"
+            f"def main():\n"
+            f"    # Load your data here (Placeholder)\n"
+            f"    df = pd.read_csv('data.csv')\n\n"
+            f"{self._indent_code(body_str)}\n\n"
+            f"if __name__ == '__main__':\n"
+            f"    main()"
+        )
+        return full_script
+
+    def _indent_code(self, code: str, spaces=4) -> str:
+        """Helper to indent the generated body code."""
+        indentation = " " * spaces
+        return "\n".join([f"{indentation}{line}" if line else line for line in code.split('\n')])

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Basic_NN/Backpropagation.py

@@ -0,0 +1,29 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Basic_NN")
+class Backpropagation(BaseModule):
+    name = "Backpropagation"
+    description = "Backpropagation Algorithm for training neural networks"
+
+    def get_imports(self):
+        return [
+            "import numpy as np"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# Backpropagation Algorithm\n"
+            f"def backpropagation(X, y, weights, learning_rate=0.01):\n"
+            f"    # Forward pass\n"
+            f"    outputs = np.dot(X, weights)\n"
+            f"    predictions = 1 / (1 + np.exp(-outputs))  # Sigmoid activation\n\n"
+            f"    # Compute error\n"
+            f"    error = predictions - y\n\n"
+            f"    # Backward pass (compute gradients)\n"
+            f"    gradients = np.dot(X.T, error) / len(X)\n\n"
+            f"    # Update weights\n"
+            f"    weights -= learning_rate * gradients\n\n"
+            f"    return weights"
+            f"# Example usage\n"
+            f"{variable_name} = backpropagation(X, y, weights)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Basic_NN/Multi-Layer_Perceptron.py

@@ -0,0 +1,22 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Basic_NN")
+class MultiLayerPerceptron(BaseModule):
+    name = "Multi-Layer Perceptron"
+    description = "Multi-Layer Perceptron (MLP) implementation using scikit-learn"
+
+    def get_imports(self):
+        return [
+            "from sklearn.neural_network import MLPClassifier",
+            "from sklearn.metrics import accuracy_score"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# Initialize and Train Model\n"
+            f"{variable_name} = MLPClassifier(hidden_layer_sizes=(100,), max_iter=300, random_state=42)\n"
+            f"{variable_name}.fit(X_train, y_train)\n\n"
+            f"# Predictions\n"
+            f"preds = {variable_name}.predict(X_test)\n"
+            f"print(f'Accuracy: {{accuracy_score(y_test, preds)}}')"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Basic_NN/Perceptron.py

@@ -0,0 +1,27 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Basic_NN")
+class Perceptron(BaseModule):
+    name = "Perceptron"
+    description = "Perceptron Algorithm for binary classification"
+
+    def get_imports(self):
+        return [
+            "import numpy as np"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# Perceptron Algorithm\n"
+            f"def perceptron(X, y, weights, learning_rate=0.01, epochs=1000):\n"
+            f"    for epoch in range(epochs):\n"
+            f"        for i in range(len(X)):\n"
+            f"            linear_output = np.dot(X[i], weights)\n"
+            f"            predicted = 1 if linear_output >= 0 else 0\n\n"
+            f"            # Update weights\n"
+            f"            update = learning_rate * (y[i] - predicted)\n"
+            f"            weights += update * X[i]\n\n"
+            f"    return weights\n\n"
+            f"# Example usage\n"
+            f"{variable_name} = perceptron(X, y, weights)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/AlexNet.py

@@ -0,0 +1,63 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class AlexNet(BaseModule):
+    name = "AlexNet"
+    description = "AlexNet architecture for image classification"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.optim as optim",
+            "from torchvision import datasets, transforms"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# Define AlexNet Architecture\n"
+            f"class AlexNet(nn.Module):\n"
+            f"    def __init__(self, num_classes=1000):\n"
+            f"        super(AlexNet, self).__init__()\n"
+            f"        self.features = nn.Sequential(\n"
+            f"            nn.Conv2d(3, 96, kernel_size=11, stride=4),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.MaxPool2d(kernel_size=3, stride=2),\n"
+            f"            nn.Conv2d(96, 256, kernel_size=5, padding=2),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.MaxPool2d(kernel_size=3, stride=2),\n"
+            f"            nn.Conv2d(256, 384, kernel_size=3, padding=1),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.Conv2d(384, 384, kernel_size=3, padding=1),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.Conv2d(384, 256, kernel_size=3, padding=1),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.MaxPool2d(kernel_size=3, stride=2)\n"
+            f"        )\n\n"
+            f"        self.classifier = nn.Sequential(\n"
+            f"            nn.Dropout(),\n"
+            f"            nn.Linear(256 * 6 * 6, 4096),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.Dropout(),\n"
+            f"            nn.Linear(4096, 4096),\n"
+            f"            nn.ReLU(inplace=True),\n"
+            f"            nn.Linear(4096, num_classes)\n"
+            f"        )\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = self.features(x)\n"
+            f"        x = x.view(x.size(0), 256 * 6 * 6)\n"
+            f"        x = self.classifier(x)\n"
+            f"        return x\n\n"
+            f"# Initialize Model\n"
+            f"{variable_name} = AlexNet(num_classes=1000)\n\n"
+            f"# Example Training Loop\n"
+            f"criterion = nn.CrossEntropyLoss()\n"
+            f"optimizer = optim.SGD({variable_name}.parameters(), lr=0.01, momentum=0.9)\n\n"
+            f"for epoch in range(10):\n"
+            f"    for inputs, labels in train_loader:\n"
+            f"        optimizer.zero_grad()\n"
+            f"        outputs = {variable_name}(inputs)\n"
+            f"        loss = criterion(outputs, labels)\n"
+            f"        loss.backward()\n"
+            f"        optimizer.step()\n"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/ConvNEXt.py

@@ -0,0 +1,40 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class ConvNEXt(BaseModule):
+    name = "ConvNEXt"
+    description = "ConvNEXt: A modernized convolutional neural network architecture"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.nn.functional as F"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# ConvNEXt Architecture\n"
+            f"class ConvNEXt(nn.Module):\n"
+            f"    def __init__(self, num_classes=10):\n"
+            f"        super(ConvNEXt, self).__init__()\n"
+            f"        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, padding=1)\n"
+            f"        self.conv2 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n"
+            f"        self.conv3 = nn.Conv2d(128, 256, kernel_size=3, padding=1)\n"
+            f"        self.pool = nn.MaxPool2d(2, 2)\n"
+            f"        self.fc1 = nn.Linear(256 * 4 * 4, 512)\n"
+            f"        self.fc2 = nn.Linear(512, num_classes)\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = F.relu(self.conv1(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = F.relu(self.conv2(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = F.relu(self.conv3(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = x.view(-1, 256 * 4 * 4)\n"
+            f"        x = F.relu(self.fc1(x))\n"
+            f"        x = self.fc2(x)\n"
+            f"        return x\n\n"
+            f"# Initialize model\n"
+            f"{variable_name} = ConvNEXt(num_classes=10)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/DenseNet.py

@@ -0,0 +1,57 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class DenseNet(BaseModule):
+    name = "DenseNet"
+    description = "DenseNet: Densely Connected Convolutional Networks"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.nn.functional as F"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# DenseNet Architecture\n"
+            f"class DenseBlock(nn.Module):\n"
+            f"    def __init__(self, num_layers, in_channels, growth_rate):\n"
+            f"        super(DenseBlock, self).__init__()\n"
+            f"        self.layers = nn.ModuleList()\n"
+            f"        for i in range(num_layers):\n"
+            f"            self.layers.append(nn.Sequential(\n"
+            f"                nn.BatchNorm2d(in_channels + i * growth_rate),\n"
+            f"                nn.ReLU(inplace=True),\n"
+            f"                nn.Conv2d(in_channels + i * growth_rate, growth_rate, kernel_size=3, padding=1)\n"
+            f"            ))\n\n"
+            f"    def forward(self, x):\n"
+            f"        features = [x]\n"
+            f"        for layer in self.layers:\n"
+            f"            new_feature = layer(torch.cat(features, 1))\n"
+            f"            features.append(new_feature)\n"
+            f"        return torch.cat(features, 1)\n\n"
+            f"class DenseNet(nn.Module):\n"
+            f"    def __init__(self, growth_rate=32, num_blocks=4, num_layers_per_block=6, num_classes=10):\n"
+            f"        super(DenseNet, self).__init__()\n"
+            f"        self.conv1 = nn.Conv2d(3, growth_rate * 2, kernel_size=7, stride=2, padding=3)\n"
+            f"        self.pool = nn.MaxPool2d(3, stride=2, padding=1)\n"
+            f"        self.blocks = nn.ModuleList()\n"
+            f"        num_channels = growth_rate * 2\n"
+            f"        for _ in range(num_blocks):\n"
+            f"            block = DenseBlock(num_layers_per_block, num_channels, growth_rate)\n"
+            f"            self.blocks.append(block)\n"
+            f"            num_channels += num_layers_per_block * growth_rate\n"
+            f"        self.classifier = nn.Linear(num_channels, num_classes)\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = self.conv1(x)\n"
+            f"        x = self.pool(x)\n"
+            f"        for block in self.blocks:\n"
+            f"            x = block(x)\n"
+            f"        x = F.adaptive_avg_pool2d(x, (1, 1))\n"
+            f"        x = x.view(x.size(0), -1)\n"
+            f"        x = self.classifier(x)\n"
+            f"        return x\n\n"
+            f"# Initialize model\n"
+            f"{variable_name} = DenseNet(growth_rate=32, num_blocks=4, num_layers_per_block=6, num_classes=10)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/EfficientNet.py

@@ -0,0 +1,41 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class EfficientNet(BaseModule):
+    name = "EfficientNet"
+    description = "EfficientNet: A family of convolutional neural networks that achieve high accuracy with fewer parameters"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.nn.functional as F"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# EfficientNet Architecture\n"
+            f"class EfficientNet(nn.Module):\n"
+            f"    def __init__(self, num_classes=10):\n"
+            f"        super(EfficientNet, self).__init__()\n"
+            f"        # Define layers here (this is a simplified version)\n"
+            f"        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)\n"
+            f"        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n"
+            f"        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)\n"
+            f"        self.pool = nn.MaxPool2d(2, 2)\n"
+            f"        self.fc1 = nn.Linear(128 * 4 * 4, 512)\n"
+            f"        self.fc2 = nn.Linear(512, num_classes)\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = F.relu(self.conv1(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = F.relu(self.conv2(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = F.relu(self.conv3(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = x.view(-1, 128 * 4 * 4)\n"
+            f"        x = F.relu(self.fc1(x))\n"
+            f"        x = self.fc2(x)\n"
+            f"        return x\n\n"
+            f"# Initialize model\n"
+            f"{variable_name} = EfficientNet(num_classes=10)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/GoogLeNet.py

@@ -0,0 +1,87 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class GoogLeNet(BaseModule):
+    name = "GoogLeNet"
+    description = "GoogLeNet (Inception v1) architecture for image classification"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.nn.functional as F"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# GoogLeNet Architecture\n"
+            f"class Inception(nn.Module):\n"
+            f"    def __init__(self, in_channels, out1x1, out3x3red, out3x3, out5x5red, out5x5, pool_proj):\n"
+            f"        super(Inception, self).__init__()\n"
+            f"        self.branch1 = nn.Conv2d(in_channels, out1x1, kernel_size=1)\n"
+            f"        self.branch2 = nn.Sequential(\n"
+            f"            nn.Conv2d(in_channels, out3x3red, kernel_size=1),\n"
+            f"            nn.Conv2d(out3x3red, out3x3, kernel_size=3, padding=1)\n"
+            f"        )\n"
+            f"        self.branch3 = nn.Sequential(\n"
+            f"            nn.Conv2d(in_channels, out5x5red, kernel_size=1),\n"
+            f"            nn.Conv2d(out5x5red, out5x5, kernel_size=5, padding=2)\n"
+            f"        )\n"
+            f"        self.branch4 = nn.Sequential(\n"
+            f"            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),\n"
+            f"            nn.Conv2d(in_channels, pool_proj, kernel_size=1)\n"
+            f"        )\n\n"
+            f"    def forward(self, x):\n"
+            f"        branch1 = F.relu(self.branch1(x))\n"
+            f"        branch2 = F.relu(self.branch2(x))\n"
+            f"        branch3 = F.relu(self.branch3(x))\n"
+            f"        branch4 = F.relu(self.branch4(x))\n"
+            f"        outputs = [branch1, branch2, branch3, branch4]\n"
+            f"        return torch.cat(outputs, 1)\n\n"
+            f"class GoogLeNet(nn.Module):\n"
+            f"    def __init__(self, num_classes=1000):\n"
+            f"        super(GoogLeNet, self).__init__()\n"
+            f"        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)\n"
+            f"        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n"
+            f"        self.conv2 = nn.Conv2d(64, 64, kernel_size=1)\n"
+            f"        self.conv3 = nn.Conv2d(64, 192, kernel_size=3, padding=1)\n"
+            f"        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n"
+            f"        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)\n"
+            f"        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)\n"
+            f"        self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n"
+            f"        self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)\n"
+            f"        self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)\n"
+            f"        self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)\n"
+            f"        self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)\n"
+            f"        self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)\n"
+            f"        self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n"
+            f"        self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)\n"
+            f"        self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)\n"
+            f"        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))\n"
+            f"        self.dropout = nn.Dropout(0.4)\n"
+            f"        self.fc = nn.Linear(1024, num_classes)\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = F.relu(self.conv1(x))\n"
+            f"        x = self.maxpool1(x)\n"
+            f"        x = F.relu(self.conv2(x))\n"
+            f"        x = F.relu(self.conv3(x))\n"
+            f"        x = self.maxpool2(x)\n"
+            f"        x = self.inception3a(x)\n"
+            f"        x = self.inception3b(x)\n"
+            f"        x = self.maxpool3(x)\n"
+            f"        x = self.inception4a(x)\n"
+            f"        x = self.inception4b(x)\n"
+            f"        x = self.inception4c(x)\n"
+            f"        x = self.inception4d(x)\n"
+            f"        x = self.inception4e(x)\n"
+            f"        x = self.maxpool4(x)\n"
+            f"        x = self.inception5a(x)\n"
+            f"        x = self.inception5b(x)\n"
+            f"        x = self.avgpool(x)\n"
+            f"        x = x.view(x.size(0), -1)\n"
+            f"        x = self.dropout(x)\n"
+            f"        x = self.fc(x)\n"
+            f"        return x\n\n"
+            f"# Initialize model\n"
+            f"{variable_name} = GoogLeNet(num_classes=1000)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/LeNet.py

@@ -0,0 +1,39 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class LeNet(BaseModule):
+    name = "LeNet"
+    description = "LeNet-5: A pioneering convolutional neural network architecture for digit recognition"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.nn.functional as F"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# LeNet-5 Architecture\n"
+            f"class LeNet(nn.Module):\n"
+            f"    def __init__(self, num_classes=10):\n"
+            f"        super(LeNet, self).__init__()\n"
+            f"        self.conv1 = nn.Conv2d(1, 6, kernel_size=5)\n"
+            f"        self.conv2 = nn.Conv2d(6, 16, kernel_size=5)\n"
+            f"        self.pool = nn.AvgPool2d(2, 2)\n"
+            f"        self.fc1 = nn.Linear(16 * 4 * 4, 120)\n"
+            f"        self.fc2 = nn.Linear(120, 84)\n"
+            f"        self.fc3 = nn.Linear(84, num_classes)\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = F.relu(self.conv1(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = F.relu(self.conv2(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = x.view(-1, 16 * 4 * 4)\n"
+            f"        x = F.relu(self.fc1(x))\n"
+            f"        x = F.relu(self.fc2(x))\n"
+            f"        x = self.fc3(x)\n"
+            f"        return x\n\n"
+            f"# Initialize model\n"
+            f"{variable_name} = LeNet(num_classes=10)"
+        )

algopipe-0.1.0/src/AlgoPipe/modules/DL_Algorithms/Convolutional_NN/MobileNet.py

@@ -0,0 +1,38 @@
+from AlgoPipe.registry import Registry, BaseModule
+
+@Registry.register("DL_Algorithms",subcategory="Convolutional_NN")
+class MobileNet(BaseModule):
+    name = "MobileNet"
+    description = "MobileNet: A lightweight convolutional neural network architecture for mobile and embedded vision applications"
+
+    def get_imports(self):
+        return [
+            "import torch",
+            "import torch.nn as nn",
+            "import torch.nn.functional as F"
+        ]
+    
+    def get_code(self, variable_name="model"):
+        return (
+            f"# MobileNet Architecture\n"
+            f"class MobileNet(nn.Module):\n"
+            f"    def __init__(self, num_classes=10):\n"
+            f"        super(MobileNet, self).__init__()\n"
+            f"        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1)\n"
+            f"        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)\n"
+            f"        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)\n"
+            f"        self.conv4 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)\n"
+            f"        self.pool = nn.AdaptiveAvgPool2d((1, 1))\n"
+            f"        self.fc = nn.Linear(256, num_classes)\n\n"
+            f"    def forward(self, x):\n"
+            f"        x = F.relu(self.conv1(x))\n"
+            f"        x = F.relu(self.conv2(x))\n"
+            f"        x = F.relu(self.conv3(x))\n"
+            f"        x = F.relu(self.conv4(x))\n"
+            f"        x = self.pool(x)\n"
+            f"        x = x.view(-1, 256)\n"
+            f"        x = self.fc(x)\n"
+            f"        return x\n\n"
+            f"# Initialize model\n"
+            f"{variable_name} = MobileNet(num_classes=10)"
+        )