Chore: Removed unused files

scripts/app.py

@@ -1,74 +0,0 @@
-@app.post("/train")
-async def train_model(config: dict):
-    network_config = NetworkConfig()
-    network_config.update(**config)
-    
-    # Create model with configured architecture
-    model = Net(
-        block1=network_config.block1,
-        block2=network_config.block2,
-        block3=network_config.block3
-    )
-    
-    # Start training with websocket updates
-    result = await train(model, network_config)
-    return result 
-
-@app.websocket("/ws/compare")
-async def websocket_compare_endpoint(websocket: WebSocket):
-    await websocket.accept()
-    try:
-        while True:
-            data = await websocket.receive_json()
-            if data.get("type") == "start_comparison":
-                # Create and train both models
-                model1_config = NetworkConfig()
-                model2_config = NetworkConfig()
-                
-                # Update configs with received data
-                model1_config.update(**data["model1"])
-                model2_config.update(**data["model2"])
-                
-                # Create models with respective configurations
-                model1 = Net(
-                    block1=model1_config.block1,
-                    block2=model1_config.block2,
-                    block3=model1_config.block3
-                )
-                
-                model2 = Net(
-                    block1=model2_config.block1,
-                    block2=model2_config.block2,
-                    block3=model2_config.block3
-                )
-                
-                # Train both models concurrently
-                tasks = [
-                    train(model1, model1_config, websocket),
-                    train(model2, model2_config, websocket)
-                ]
-                
-                results = await asyncio.gather(*tasks)
-                
-                # Send completion message
-                await websocket.send_json({
-                    "type": "comparison_complete",
-                    "data": {
-                        "model1": results[0],
-                        "model2": results[1]
-                    }
-                })
-                
-    except Exception as e:
-        print(f"Error in websocket connection: {e}")
-    finally:
-        await websocket.close()
-
-@app.post("/compare")
-async def compare_models(request: Request):
-    data = await request.json()
-    return {"status": "started", "message": "Model comparison initiated"}
-
-@app.get("/train/compare")
-async def compare_page(request: Request):
-    return templates.TemplateResponse("train_compare.html", {"request": request}) 

scripts/training/model.py

@@ -1,37 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.nn import Conv2d, MaxPool2d, Linear, Sequential, ReLU, LogSoftmax, Flatten
-
-
-class Net(torch.nn.Module):
-    def __init__(self, block1=32, block2=64, block3=128):
-        """
-        Constructor
-        """
-        super(Net, self).__init__()
-
-        # Define model architecture with configurable blocks
-        self.conv1 = nn.Conv2d(1, block1, kernel_size=3)
-        self.conv2 = nn.Conv2d(block1, block2, kernel_size=3)
-        self.conv3 = nn.Conv2d(block2, block3, kernel_size=3)
-        self.conv4 = nn.Conv2d(block3, block3*2, kernel_size=3)
-        
-        # Calculate the input size for the first fully connected layer
-        self.fc1 = nn.Linear(block3*2*16, 50)
-        self.fc2 = nn.Linear(50, 10)
-
-    def forward(self, x):
-        """
-        Forward pass for model training
-        :param x: Input layer
-        :return: Output of the model
-        """
-        x = F.relu(self.conv1(x))
-        x = F.relu(F.max_pool2d(self.conv2(x), 2))
-        x = F.relu(self.conv3(x))
-        x = F.relu(F.max_pool2d(self.conv4(x), 2))
-        x = x.view(x.size(0), -1)
-        x = F.relu(self.fc1(x))
-        x = self.fc2(x)
-        return x