Adding MorseHModel and documentation

MorseH_Model.py

@@ -0,0 +1,148 @@
+# IMPORTS
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, TensorDataset
+import torch.optim as optim
+import matplotlib.pyplot as plt
+import time
+
+# LOAD DATA
+df = pd.read_csv('C:/My Projects/MorseH Model/morse_data.csv')
+
+# ENCODE CHARACTERS AND MORSE CODE
+# Encoding characters as integers
+label_encoder = LabelEncoder()
+df['Character'] = label_encoder.fit_transform(df['Character'])
+
+# Encoding Morse Code
+morse_dict = {'.': 0, '-': 1, ' ': 2}  # '.' -> 0, '-' -> 1, ' ' -> 2 for padding
+df['Morse Code Enc'] = df['Morse Code'].apply(lambda x: [morse_dict[char] for char in x])
+
+# Pad Morse Code sequences to equal length
+max_length = df['Morse Code Enc'].apply(len).max()
+df['Morse Code Enc'] = pad_sequences(df['Morse Code Enc'], maxlen=max_length, padding='post', value=2).tolist()
+
+# PREPARE FEATURES AND LABELS
+X = torch.tensor(df['Character'].values, dtype=torch.long)
+y = torch.tensor(df['Morse Code Enc'].tolist(), dtype=torch.long)
+
+# MODEL DEFINITION
+class MorseHModel(nn.Module):
+    def __init__(self, input_size, output_size, max_length):
+        super(MorseHModel, self).__init__()
+        self.emmbedding = nn.Embedding(input_size, 16)
+        self.fc1 = nn.Linear(16, 32)
+        self.fc2 = nn.Linear(32, output_size * max_length)
+        self.output_size = output_size
+        self.max_length = max_length
+
+    def forward(self, x):
+        x = self.emmbedding(x).view(-1, 16)
+        x = torch.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x.view(-1, self.max_length, self.output_size)
+
+input_size = len(label_encoder.classes_)
+output_size = 3
+model = MorseHModel(input_size=input_size, output_size=output_size, max_length=max_length)
+
+# Load the model weights if available
+not_pretrained = True
+try:
+    model.load_state_dict(torch.load('morse_model_weights.pth', weights_only=True))
+    not_pretrained = False
+except FileNotFoundError:
+    print("Pre-trained weights not found, starting training from scratch.")
+
+# CREATE DATALOADER
+dataset = TensorDataset(X, y)
+data_loader = DataLoader(dataset, batch_size=16, shuffle=True)
+
+# LOSS FUNCTION AND OPTIMIZER
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+# TRAINING LOOP
+num_epochs = 20
+if not_pretrained:
+    for epoch in range(num_epochs):
+        model.train()
+        total_loss = 0.0
+        for inputs, targets in data_loader:
+            optimizer.zero_grad()
+            outputs = model(inputs)
+
+            targets = targets.view(-1)
+            outputs = outputs.view(-1, output_size)
+
+            loss = criterion(outputs, targets)
+            loss.backward()
+            optimizer.step()
+
+            total_loss += loss.item()
+        
+        print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {total_loss / len(data_loader):.4f}")
+
+    # MODEL EVALUATION
+    model.eval()
+    sample_size = 10
+    correct_predictions = 0
+    total_elements = 0
+
+    with torch.no_grad():
+        for i in range(sample_size):
+            input_sample = X[i].unsqueeze(0)
+            target_sample = y[i]
+
+            output = model(input_sample)
+            _, predicted = torch.max(output.data, 2)
+
+            total_elements += target_sample.size(0)
+            correct_predictions += (predicted.squeeze() == target_sample).sum().item()
+
+    accuracy = 100 * correct_predictions / total_elements
+    print(f"Accuracy on sample of training set: {accuracy:.2f}%")
+
+# INFERENCE FUNCTIONS
+def predict(character_index):
+    """Predict the Morse code sequence for a given character index."""
+    with torch.no_grad():
+        output = model(torch.tensor([character_index]))
+        _, prediction = torch.max(output, 2)
+        return prediction[0]
+
+def decode(prediction):
+    """Decode a prediction from numerical values to Morse code symbols."""
+    prediction = [p for p in prediction if p != 2]
+    return ''.join('.' if c == 0 else '-' for c in prediction)
+
+def encode(word):
+    """Encode a word into character indices."""
+    return [label_encoder.transform([char])[0] for char in word.upper()]
+
+def get_morse_word(word):
+    """Convert a word into Morse code using the model predictions."""
+    char_indices = encode(word)
+    morse_sequence = []
+    for index in char_indices:
+        pred = predict(index)
+        morse_sequence.append(decode(pred))
+        morse_sequence.append(' ')
+    return ''.join(morse_sequence)
+
+# USER INPUT INFERENCE
+user_input = input("Type your message: ")
+response = [get_morse_word(word) + '   ' for word in user_input.split()]
+response = ''.join(response)
+
+print("Response: ", response)
+# for char in response:
+#     print(char, end="")
+    # time.sleep(10*pow(10, -3))  # Delay for visualization
+
+# SAVE MODEL
+torch.save(model.state_dict(), 'morse_model_weights.pth')
+torch.save(model, 'complete_model.pth')

README.md

@@ -0,0 +1,30 @@
+# MorseHModel
+
+This model is designed to convert textual characters into Morse code symbols (dots, dashes, and spaces) using a custom neural network in PyTorch.
+
+## Model Architecture
+The model uses an embedding layer followed by two fully connected layers to predict Morse code encodings.
+
+### Model Inputs and Outputs
+- **Inputs:** Character indices of textual input.
+- **Outputs:** Morse code sequence for each character in the input.
+
+### Training and Dataset
+- **Dataset:** Custom Morse code dataset.
+- **Training:** Trained for 20 epochs with a batch size of 16.
+
+### Usage
+Below is an example of how to use the model.
+
+```python
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import torch
+
+# Load model and tokenizer
+model = torch.load("morse_model_weights.pth")
+tokenizer = AutoTokenizer.from_pretrained("username/MorseH_Model")
+
+# Predict Morse code
+input_text = "HELLO"
+inputs = tokenizer(input_text, return_tensors="pt")
+outputs = model(**inputs)

complete_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9990aec7a43bc52b3ad9ffb120987f7bc8a8ad251bab82630e7a625dd1fcbd3f
+size 12683

config.json

@@ -0,0 +1,6 @@
+{
+    "model_type": "morseh_model",
+    "input_size": 26,
+    "output_size": 3,
+    "max_length": 10
+}

model.ipynb

@@ -0,0 +1,859 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "IMPORTS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from sklearn.preprocessing import LabelEncoder\n",
+    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torch.utils.data import DataLoader, TensorDataset\n",
+    "import torch.optim as optim\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "LOAD DATA"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Character</th>\n",
+       "      <th>Morse Code</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>A</td>\n",
+       "      <td>.-</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>B</td>\n",
+       "      <td>-...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>C</td>\n",
+       "      <td>-.-.</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>D</td>\n",
+       "      <td>-..</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>E</td>\n",
+       "      <td>.</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Character Morse Code\n",
+       "0         A         .-\n",
+       "1         B       -...\n",
+       "2         C       -.-.\n",
+       "3         D        -..\n",
+       "4         E          ."
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv('C:/My Projects/MorseH Model/morse_data.csv')\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Checking Data types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(str, str)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "type(df['Character'][0]), type(df['Morse Code'][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ENCODE THE STRINGS"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lb = LabelEncoder()\n",
+    "df['Character'] = lb.fit_transform(df['Character'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ENCODE THE MORSE CODES <br>\n",
+    "'.' -> 0, <br>\n",
+    "'-' -> 1, <br>\n",
+    "' ' -> 2  PADDING"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Character</th>\n",
+       "      <th>Morse Code</th>\n",
+       "      <th>Morse Code Enc</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>25</td>\n",
+       "      <td>.-</td>\n",
+       "      <td>[0, 1]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>26</td>\n",
+       "      <td>-...</td>\n",
+       "      <td>[1, 0, 0, 0]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>27</td>\n",
+       "      <td>-.-.</td>\n",
+       "      <td>[1, 0, 1, 0]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>28</td>\n",
+       "      <td>-..</td>\n",
+       "      <td>[1, 0, 0]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>29</td>\n",
+       "      <td>.</td>\n",
+       "      <td>[0]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Character Morse Code Morse Code Enc\n",
+       "0         25         .-         [0, 1]\n",
+       "1         26       -...   [1, 0, 0, 0]\n",
+       "2         27       -.-.   [1, 0, 1, 0]\n",
+       "3         28        -..      [1, 0, 0]\n",
+       "4         29          .            [0]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "morse_dict = {'.':0,'-':1,' ':2}\n",
+    "df['Morse Code Enc'] = df['Morse Code'].apply(lambda x: [morse_dict[char] for char in x])\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "max_length = df['Morse Code Enc'].apply(len).max()\n",
+    "max_length"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Adding Padding to equalize the length of each morse code enocoded to max length"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Character</th>\n",
+       "      <th>Morse Code</th>\n",
+       "      <th>Morse Code Enc</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>25</td>\n",
+       "      <td>.-</td>\n",
+       "      <td>[0, 1, 2, 2, 2, 2, 2, 2]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>26</td>\n",
+       "      <td>-...</td>\n",
+       "      <td>[1, 0, 0, 0, 2, 2, 2, 2]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>27</td>\n",
+       "      <td>-.-.</td>\n",
+       "      <td>[1, 0, 1, 0, 2, 2, 2, 2]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>28</td>\n",
+       "      <td>-..</td>\n",
+       "      <td>[1, 0, 0, 2, 2, 2, 2, 2]</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>29</td>\n",
+       "      <td>.</td>\n",
+       "      <td>[0, 2, 2, 2, 2, 2, 2, 2]</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Character Morse Code            Morse Code Enc\n",
+       "0         25         .-  [0, 1, 2, 2, 2, 2, 2, 2]\n",
+       "1         26       -...  [1, 0, 0, 0, 2, 2, 2, 2]\n",
+       "2         27       -.-.  [1, 0, 1, 0, 2, 2, 2, 2]\n",
+       "3         28        -..  [1, 0, 0, 2, 2, 2, 2, 2]\n",
+       "4         29          .  [0, 2, 2, 2, 2, 2, 2, 2]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df['Morse Code Enc'] = pad_sequences(df['Morse Code Enc'],maxlen = max_length, padding='post', value=2).tolist()\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Taking Features and Labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df['Character'].values\n",
+    "y = df['Morse Code Enc'].tolist()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Splitting Data (Traditional Way) (NOT PREFERRED) (Scroll Down for torch approach)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train_tensor = torch.tensor(X_train, dtype=torch.long).view(-1, 1)\n",
+    "X_test_tensor = torch.tensor(X_test, dtype=torch.long)\n",
+    "y_train_tensor = torch.tensor(y_train, dtype=torch.long).view(-1, 1)\n",
+    "y_test_tensor = torch.tensor(y_test, dtype=torch.long)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MorseH_Model(nn.Module):\n",
+    "    def __init__(self, input_size, output_size, max_length):\n",
+    "        super(MorseH_Model, self).__init__()\n",
+    "        # Embedding layer to represent each character as a vector\n",
+    "        self.emmbedding = nn.Embedding(input_size, 16)\n",
+    "\n",
+    "        # Linear Layers\n",
+    "        self.fc1 = nn.Linear(16, 32)\n",
+    "        self.fc2 = nn.Linear(32, output_size*max_length)\n",
+    "\n",
+    "        #Reshaping output shape to match morse code shape\n",
+    "        self.output_size = output_size\n",
+    "        self.max_length = max_length\n",
+    "    \n",
+    "    def forward(self, x):\n",
+    "        # Pass input through embedding layer\n",
+    "        x = self.emmbedding(x).view(-1, 16)\n",
+    "        x = torch.relu(self.fc1(x))\n",
+    "        x = self.fc2(x)\n",
+    "\n",
+    "        return x.view(-1, self.max_length, self.output_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "MorseH_Model(\n",
+       "  (emmbedding): Embedding(54, 16)\n",
+       "  (fc1): Linear(in_features=16, out_features=32, bias=True)\n",
+       "  (fc2): Linear(in_features=32, out_features=24, bias=True)\n",
+       ")"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "input_size = len(lb.classes_)\n",
+    "output_size = 3\n",
+    "max_len = max_length\n",
+    "model = MorseH_Model(input_size=input_size, output_size=output_size, max_length=max_len)\n",
+    "# Load the weights into a new model\n",
+    "model.load_state_dict(torch.load('morse_model_weights.pth', weights_only=True))\n",
+    "model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Prepare Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "X = torch.tensor(df['Character'].values, dtype=torch.long)\n",
+    "y = torch.tensor(df['Morse Code Enc'].tolist(), dtype=torch.long)\n",
+    "\n",
+    "data = TensorDataset(X, y)\n",
+    "loader = DataLoader(data, batch_size=16, shuffle=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Define Loss Function and Optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.Adam(model.parameters(), lr = 0.001)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Training Loop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# num_epochs = 20\n",
+    "# for epoch in range(num_epochs):\n",
+    "#     model.train()\n",
+    "#     running_loss = 0.0\n",
+    "#     for inputs, targets in loader:\n",
+    "#         optimizer.zero_grad() # Reset gradients\n",
+    "#         outputs = model(inputs) # Forward Pass\n",
+    "\n",
+    "#         #  Redhape for Loss Calculation\n",
+    "#         targets = targets.view(-1)\n",
+    "#         outputs = outputs.view(-1, output_size)\n",
+    "\n",
+    "#         loss = criterion(outputs, targets) # Calculate loss\n",
+    "#         loss.backward() # Backward Pass\n",
+    "#         optimizer.step() # Update weights\n",
+    "\n",
+    "#         running_loss += loss.item()\n",
+    "    \n",
+    "#     print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(loader):.4f}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Evaluating Trained Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# model.eval()  # set model to evaluation mode\n",
+    "# sample_size = 10\n",
+    "# correct = 0\n",
+    "# total = 0\n",
+    "# with torch.no_grad():\n",
+    "#     for i in range(sample_size):\n",
+    "#         input_sample = X[i].unsqueeze(0)\n",
+    "#         target_sample = y[i]\n",
+    "\n",
+    "#         output = model(input_sample)\n",
+    "#         _, predicted = torch.max(output.data, 2)\n",
+    "\n",
+    "#         total += target_sample.size(0)\n",
+    "#         correct += (predicted.squeeze()==target_sample).sum().item()\n",
+    "\n",
+    "# accuracy = 100*correct/total\n",
+    "# print(f'Accuracy on sample of training set: {accuracy:.2f}%')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Predicting and Decoding the Predicted Output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def predict(char_index):\n",
+    "    with torch.no_grad():\n",
+    "        output = model(torch.tensor([char_index]))\n",
+    "        _, prediction = torch.max(output, 2)\n",
+    "        return prediction[0]\n",
+    "\n",
+    "def decode(prediction):\n",
+    "    # Removing Padding\n",
+    "    prediction = [p for p in prediction if p!=2]\n",
+    "    decode_symb = ['.' if c == 0 else '-' for c in prediction]\n",
+    "    morse_code = ''.join(decode_symb)\n",
+    "    return morse_code"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def encode(word):\n",
+    "    word = word.upper()\n",
+    "    return [lb.transform([c])[0] for c in word]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Testing with Some Random Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['.- .--. .--. .-.. . ',\n",
+       " '-... .- .-.. .-.. ',\n",
+       " '-.-. .- - ',\n",
+       " '-..- -- .- ... -....- - .-. . . ']"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trancode_list = [\"apple\", \"ball\", \"cat\" ,\"xmas-tree\"]\n",
+    "def get_morse_word(word):\n",
+    "    char_indices = encode(word)\n",
+    "    decoded = []\n",
+    "    for ind in char_indices:\n",
+    "        pred = predict(ind)\n",
+    "        decoded.append(decode(pred))\n",
+    "        decoded.append(' ')\n",
+    "    return ''.join(decoded)\n",
+    "codes = [get_morse_word(word) for word in trancode_list]\n",
+    "codes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Testing with long Sentences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[['Be', 'yourself;', 'everyone', 'else', 'is', 'already', 'taken.'],\n",
+       " ['So', 'many', 'books', 'so', 'little', 'time.'],\n",
+       " ['Two',\n",
+       "  'things',\n",
+       "  'are',\n",
+       "  'infinite:',\n",
+       "  'the',\n",
+       "  'universe',\n",
+       "  'and',\n",
+       "  'human',\n",
+       "  'stupidity;',\n",
+       "  'and',\n",
+       "  \"I'm\",\n",
+       "  'not',\n",
+       "  'sure',\n",
+       "  'about',\n",
+       "  'the',\n",
+       "  'universe.']]"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trancode_sentences = [\"Be yourself; everyone else is already taken.\", \"So many books so little time.\", \"Two things are infinite: the universe and human stupidity; and I'm not sure about the universe.\" ]\n",
+    "trancode_lists = [ sen.split(' ') for sen in trancode_sentences ]\n",
+    "trancode_lists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['-... .    -.-- --- ..- .-. ... . .-.. ..-. -.-.-.    . ...- . .-. -.-- --- -. .    . .-.. ... .    .. ...    .- .-.. .-. . .- -.. -.--    - .- -.- . -. .-.-.-    ',\n",
+       " '... ---    -- .- -. -.--    -... --- --- -.- ...    ... ---    .-.. .. - - .-.. .    - .. -- . .-.-.-    ',\n",
+       " '- .-- ---    - .... .. -. --. ...    .- .-. .    .. -. ..-. .. -. .. - . ---...    - .... .    ..- -. .. ...- . .-. ... .    .- -. -..    .... ..- -- .- -.    ... - ..- .--. .. -.. .. - -.-- -.-.-.    .- -. -..    .. .----. --    -. --- -    ... ..- .-. .    .- -... --- ..- -    - .... .    ..- -. .. ...- . .-. ... . .-.-.-    ']"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "get_morse_codes = []\n",
+    "for l1 in trancode_lists:\n",
+    "    codes = [get_morse_word(word)+'   ' for word in l1]\n",
+    "    get_morse_codes.append(''.join(codes))\n",
+    "get_morse_codes"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### INFERENCE API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "- . -- .--. . .-. .- - ..- .-. .    "
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "take_input = input(\"Type your message: \")\n",
+    "response = [get_morse_word(word)+'   ' for word in take_input.split()]\n",
+    "response = ''.join(response)\n",
+    "for i in response:\n",
+    "    print(i, end=\"\")\n",
+    "    # time.sleep(100*pow(10, -3)) FUN"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Save the model's weights\n",
+    "torch.save(model.state_dict(), 'morse_model_weights.pth')\n",
+    "\n",
+    "# Load the weights into a new model\n",
+    "model.load_state_dict(torch.load('morse_model_weights.pth', weights_only=True))\n",
+    "\n",
+    "# Set the model to evaluation mode\n",
+    "model.eval()\n",
+    "# Save the entire model\n",
+    "torch.save(model, 'complete_model.pth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "MorseH_Model(\n",
+       "  (emmbedding): Embedding(54, 16)\n",
+       "  (fc1): Linear(in_features=16, out_features=32, bias=True)\n",
+       "  (fc2): Linear(in_features=32, out_features=24, bias=True)\n",
+       ")"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Save the model weights as pytorch_model.bin\n",
+    "import torch\n",
+    "torch.save(model.state_dict(), \"pytorch_model.bin\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To Use it later"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Instantiate the model (ensure it has the same architecture)\n",
+    "# model = MorseH_Model(input_size=input_size, output_size=output_size, max_length=max_len)\n",
+    "\n",
+    "# # Load the saved weights\n",
+    "# model.load_state_dict(torch.load(\"pytorch_model.bin\"))\n",
+    "\n",
+    "# # Set the model to evaluation mode if needed\n",
+    "# model.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

morse_data.csv

@@ -0,0 +1,55 @@
+Character,Morse Code
+A,.-
+B,-...
+C,-.-.
+D,-..
+E,.
+F,..-.
+G,--.
+H,....
+I,..
+J,.---
+K,-.-
+L,.-..
+M,--
+N,-.
+O,---
+P,.--.
+Q,--.-
+R,.-.
+S,...
+T,-
+U,..-
+V,...-
+W,.--
+X,-..-
+Y,-.--
+Z,--..
+0,-----
+1,.----
+2,..---
+3,...--
+4,....-
+5,.....
+6,-....
+7,--...
+8,---..
+9,----.
+.,.-.-.-
+c,--..--
+?,..--..
+’,.----.
+!,-.-.--
+/,-..-.
+(,-.--.
+),-.--.-
+&,.-...
+:,---...
+;,-.-.-.
+=,-...-
++,.-.-.
+-,-....-
+_,..--.-
+$,...-..-.
+ , 
+',.----. 

morse_model_weights.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fda920b27896795388d1c5479204c8ca14828741ad13073714812c3decad9355
+size 11256

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a6b27780d2d6187d91f3080b9ed45e9ecab93c1862241a76bb46d7d6688140f
+size 11202