Create app.py

app.py

@@ -0,0 +1,133 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import pandas as pd
+import streamlit as st
+from sklearn.preprocessing import LabelEncoder
+
+# === Alphabet Gate Definition ===
+class AlphabetGate(nn.Module):
+    def __init__(self):
+        super(AlphabetGate, self).__init__()
+        alphabet = list("abcdefghijklmnopqrstuvwxyz")
+        matrix_size = len(alphabet)
+        alphabet_matrix = [[ord(char) - ord('a') for char in alphabet[i:] + alphabet[:i]] for i in range(matrix_size)]
+        self.alphabet_gate = torch.tensor(alphabet_matrix, dtype=torch.float)
+    
+    def forward(self, x):
+        # Randomly select a row from the alphabet gate matrix
+        batch_size = x.size(0)
+        selected_rows = torch.randint(0, 26, (batch_size,)).to(x.device)
+        transformed = torch.stack([self.alphabet_gate[row] for row in selected_rows])
+        return torch.matmul(transformed, x.unsqueeze(-1)).squeeze(-1)
+
+# === Neural Network with Alphabet Gate ===
+class AlphabetGateNN(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super(AlphabetGateNN, self).__init__()
+        self.alphabet_gate = AlphabetGate()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        self.fc2 = nn.Linear(hidden_dim, output_dim)
+        self.activation = nn.ReLU()
+        self.softmax = nn.Softmax(dim=1)
+    
+    def forward(self, x):
+        x = self.alphabet_gate(x)  # Apply Alphabet Gate
+        x = self.activation(self.fc1(x))
+        x = self.softmax(self.fc2(x))
+        return x
+
+# === Helper Functions ===
+def process_file(file_path):
+    """
+    Process a CSV file and convert it into training-ready tensors.
+    Assumes the file has columns 'text' and 'label'.
+    """
+    data = pd.read_csv(file_path)
+    texts = data['text'].str.lower()  # Convert to lowercase
+    labels = data['label']
+    
+    # Encode labels
+    le = LabelEncoder()
+    labels = le.fit_transform(labels)
+    
+    # Transform texts into alphabet-based feature vectors
+    def text_to_vector(text):
+        vector = [0] * 26
+        for char in text:
+            if 'a' <= char <= 'z':
+                vector[ord(char) - ord('a')] += 1
+        return vector
+
+    X = torch.tensor([text_to_vector(text) for text in texts], dtype=torch.float)
+    y = torch.tensor(labels, dtype=torch.long)
+    
+    return X, y
+
+def train_on_file(file_path, model, optimizer, criterion):
+    """
+    Train the model on data from a given file.
+    """
+    X, y = process_file(file_path)
+    dataset = torch.utils.data.TensorDataset(X, y)
+    dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
+    
+    model.train()
+    for epoch in range(3):  # Train for 3 epochs per file
+        for batch_X, batch_y in dataloader:
+            optimizer.zero_grad()
+            outputs = model(batch_X)
+            loss = criterion(outputs, batch_y)
+            loss.backward()
+            optimizer.step()
+    return model
+
+# === Streamlit App ===
+# Initialize model, optimizer, and loss function
+input_dim = 26
+hidden_dim = 16
+output_dim = 3
+model = AlphabetGateNN(input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)
+optimizer = optim.Adam(model.parameters(), lr=0.01)
+criterion = nn.CrossEntropyLoss()
+
+st.title("Enterprise-Ready Continuous Training App with Alphabet Gate")
+st.write("""
+### How it Works:
+1. Upload a CSV file with the following format:
+   - **text**: Text column containing input strings.
+   - **label**: Target labels for classification.
+2. The model will train incrementally on each file you upload.
+3. You can download the updated model once training is complete.
+""")
+
+uploaded_file = st.file_uploader("Upload a training file (CSV format)", type="csv")
+
+if uploaded_file is not None:
+    # Save the uploaded file locally
+    file_path = os.path.join("uploads", uploaded_file.name)
+    os.makedirs("uploads", exist_ok=True)
+    with open(file_path, "wb") as f:
+        f.write(uploaded_file.getbuffer())
+    
+    # Train the model on the uploaded file
+    st.write("Processing and training on the uploaded file...")
+    model = train_on_file(file_path, model, optimizer, criterion)
+    st.success("Training complete!")
+
+    # Save the updated model
+    model_path = "trained_model.pth"
+    torch.save(model.state_dict(), model_path)
+    st.write("Model updated and saved.")
+
+    # Provide a download button for the trained model
+    with open(model_path, "rb") as f:
+        st.download_button(
+            label="Download Trained Model",
+            data=f,
+            file_name="trained_model.pth",
+            mime="application/octet-stream"
+        )
+
+st.write("Upload more files to continue training!")