Adds notebook and setup for testing models.

Dockerfile

@@ -90,6 +90,8 @@ RUN --mount=target=requirements.txt,source=requirements.txt \
 # Copy the current directory contents into the container at $HOME/app setting the owner to the user
 COPY --chown=user . $HOME/app
 
+RUN pip install -e .
+
 RUN chmod +x start_server.sh
 
 COPY --chown=user login.html /home/user/miniconda/lib/python3.9/site-packages/jupyter_server/templates/login.html

model/distilbert.py

@@ -0,0 +1,58 @@
+from transformers import AutoModel
+from huggingface_hub import hf_hub_download
+from safetensors.torch import load_file
+import torch.nn as nn
+import torch
+
+# Number of labels (update if different)
+NUM_LABELS = 4
+
+# Model with frozen DistilBERT weights
+class DistilBertClassificationModel(nn.Module):
+    def __init__(
+            self,
+            model_path="distilbert/distilbert-base-uncased",
+            freeze_weights=True,
+        ):
+        super(DistilBertClassificationModel, self).__init__()
+        if model_path == "distilbert/distilbert-base-uncased":
+            self.base_model = AutoModel.from_pretrained(model_path)
+        else:
+            pytorch_model_path = hf_hub_download(
+                repo_id=model_path,
+                repo_type="model",
+                filename="model.safetensors"
+            )
+            state_dict = load_file(pytorch_model_path)
+            filtered_state_dict = {
+                k.replace("base_model.", ""): v
+                for k, v in state_dict.items()
+                if not k.startswith("classifier.")
+            }
+
+            self.base_model = AutoModel.from_pretrained("distilbert/distilbert-base-uncased", state_dict=filtered_state_dict)
+
+        # For push to hub.
+        self.config = self.base_model.config
+
+        # Freeze the base model's weights
+        if freeze_weights:
+            for param in self.base_model.parameters():
+                param.requires_grad = False
+        
+        # Add a classification head
+        self.classifier = nn.Linear(self.base_model.config.hidden_size, NUM_LABELS)
+    
+    def forward(self, input_ids, attention_mask, labels=None):
+        with torch.no_grad():  # No gradients for the base model
+            outputs = self.base_model(input_ids=input_ids, attention_mask=attention_mask)
+        
+        # Sum hidden states over the sequence dimension
+        summed_representation = outputs.last_hidden_state.sum(dim=1)  # Summing over sequence length
+        
+        logits = self.classifier(summed_representation)  # Pass the summed representation to the classifier
+        loss = None
+        if labels is not None:
+            loss_fn = nn.BCEWithLogitsLoss()
+            loss = loss_fn(logits, labels.float())
+        return {"loss": loss, "logits": logits}

model/llama.py

@@ -0,0 +1,37 @@
+import torch.nn as nn
+import torch
+
+from transformers import AutoModel
+
+NUM_LABELS = 4
+
+# Model with frozen LLaMA weights
+class LlamaClassificationModel(nn.Module):
+    def __init__(self, model_path = "meta-llama/Llama-3.2-1B", freeze_weights = True):
+        super(LlamaClassificationModel, self).__init__()
+        self.base_model = AutoModel.from_pretrained(model_path)
+        
+        # For push to hub.
+        self.config = self.base_model.config
+
+        # Freeze the base model's weights
+        if freeze_weights:
+            for param in self.base_model.parameters():
+                param.requires_grad = False
+        
+        # Add a classification head
+        self.classifier = nn.Linear(self.base_model.config.hidden_size, NUM_LABELS)
+    
+    def forward(self, input_ids, attention_mask, labels=None):
+        with torch.no_grad():  # No gradients for the base model
+            outputs = self.base_model(input_ids=input_ids, attention_mask=attention_mask)
+        
+        # Sum hidden states over the sequence dimension
+        summed_representation = outputs.last_hidden_state.sum(dim=1)  # Summing over sequence length
+        
+        logits = self.classifier(summed_representation)  # Pass the summed representation to the classifier
+        loss = None
+        if labels is not None:
+            loss_fn = nn.BCEWithLogitsLoss()
+            loss = loss_fn(logits, labels.float())
+        return {"loss": loss, "logits": logits}

model/notebooks/inference.ipynb

@@ -0,0 +1,152 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "from huggingface_hub import hf_hub_download\n",
+    "from transformers import AutoTokenizer\n",
+    "\n",
+    "from model.distilbert import DistilBertClassificationModel\n",
+    "from model.scibert import SciBertClassificationModel\n",
+    "from model.llama import LlamaClassificationModel\n",
+    "from model.t5 import T5ClassificationModel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model Selection\n",
+    "Uncomment desired `repo_id` and corresponding `model` and input type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Baseline\n",
+    "repo_id = \"ppak10/defect-classification-distilbert-baseline-25-epochs\"\n",
+    "# repo_id = \"ppak10/defect-classification-scibert-baseline-25-epochs\"\n",
+    "# repo_id = \"ppak10/defect-classification-llama-baseline-25-epochs\"\n",
+    "# repo_id = \"ppak10/defect-classification-t5-baseline-25-epochs\"\n",
+    "\n",
+    "# Prompt \n",
+    "# repo_id = \"ppak10/defect-classification-distilbert-prompt-02-epochs\"\n",
+    "# repo_id = \"ppak10/defect-classification-scibert-prompt-02-epochs\"\n",
+    "# repo_id = \"ppak10/defect-classification-llama-prompt-02-epochs\"\n",
+    "# repo_id = \"ppak10/defect-classification-t5-prompt-02-epochs\"\n",
+    "\n",
+    "# Initialize the model\n",
+    "model = DistilBertClassificationModel(repo_id)\n",
+    "# model = SciBertClassificationModel(repo_id)\n",
+    "# model = LlamaClassificationModel()\n",
+    "# model = T5ClassificationModel(repo_id)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the tokenizer\n",
+    "tokenizer = AutoTokenizer.from_pretrained(repo_id)\n",
+    "\n",
+    "# Loads classification head weights\n",
+    "classification_head_path = hf_hub_download(\n",
+    "    repo_id=repo_id,\n",
+    "    repo_type=\"model\",\n",
+    "    filename=\"classification_head.pt\"\n",
+    ")\n",
+    "\n",
+    "model.classifier.load_state_dict(torch.load(classification_head_path, map_location=torch.device(\"cpu\")))\n",
+    "model.eval()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Baseline\n",
+    "# text = \"Ti-6Al-4V[SEP]280.0 W[SEP]400.0 mm/s[SEP]100.0 microns[SEP]50.0 microns[SEP]100.0 microns\"\n",
+    "\n",
+    "# Prompt\n",
+    "text = \"What are the likely imperfections that occur in Ti-6Al-4V L-PBF builds at 280.0 W, given a 100.0 microns beam diameter, a 400.0 mm/s scan speed, a 100.0 microns hatch spacing, and a 50.0 microns layer height?\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tokenize inputs \n",
+    "inputs = tokenizer(text, return_tensors=\"pt\", truncation=True, padding=\"max_length\", max_length=256)\n",
+    "\n",
+    "# For scibert\n",
+    "inputs_kwargs = {}\n",
+    "for key, value in inputs.items():\n",
+    "    if key not in [\"token_type_ids\"]:\n",
+    "        inputs_kwargs[key] = value\n",
+    "\n",
+    "# Perform inference\n",
+    "outputs = model(**inputs_kwargs)\n",
+    "\n",
+    "# Extract logits and apply sigmoid activation for multi-label classification\n",
+    "probs = torch.sigmoid(outputs[\"logits\"])\n",
+    "\n",
+    "# Convert probabilities to one-hot encoded labels\n",
+    "preds = (probs > 0.5).int().squeeze()\n",
+    "\n",
+    "# One hot encoded classifications\n",
+    "classifications = [\"None\", \"Keyhole\", \"Lack of Fusion\", \"Balling\"]\n",
+    "    \n",
+    "print([classifications[index] for index, encoding in enumerate(preds) if encoding == 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "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.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

model/scibert.py

@@ -0,0 +1,67 @@
+from transformers import AutoModel
+from huggingface_hub import hf_hub_download
+from safetensors.torch import load_file
+import torch.nn as nn
+import torch
+
+# Number of labels (update if different)
+NUM_LABELS = 4
+
+class SciBertClassificationModel(nn.Module):
+    def __init__(self, model_path="allenai/scibert_scivocab_uncased", freeze_weights=True):
+        super(SciBertClassificationModel, self).__init__()
+        if model_path == "allenai/scibert_scivocab_uncased":
+            self.base_model = AutoModel.from_pretrained(model_path)
+        else:
+            pytorch_model_path = hf_hub_download(
+                repo_id=model_path,
+                repo_type="model",
+                filename="model.safetensors"
+            )
+            state_dict = load_file(pytorch_model_path)
+            filtered_state_dict = {
+                k.replace("base_model.", ""): v
+                for k, v in state_dict.items()
+                if not k.startswith("classifier.")
+            }
+
+            self.base_model = AutoModel.from_pretrained("allenai/scibert_scivocab_uncased", state_dict=filtered_state_dict)
+
+        # For push to hub.
+        self.config = self.base_model.config
+        
+        # Freeze the base model's weights
+        if freeze_weights:
+            for param in self.base_model.parameters():
+                param.requires_grad = False
+        
+        # Add a classification head
+        self.classifier = nn.Linear(self.base_model.config.hidden_size, NUM_LABELS)
+    
+    def forward(self, input_ids, attention_mask, labels=None):
+        with torch.no_grad():  # No gradients for the base model
+            outputs = self.base_model(input_ids=input_ids, attention_mask=attention_mask)
+        
+        # Ensure the tensor is contiguous before passing to the classifier
+        # cls_token_representation = outputs.last_hidden_state[:, 0, :].contiguous()
+        # logits = self.classifier(cls_token_representation)
+
+        # Sum token representations
+        summed_representation = outputs.last_hidden_state.sum(dim=1)  # Summing over the sequence length (dim=1)
+        
+        logits = self.classifier(summed_representation)  # Pass the summed representation to the classifier
+        
+        loss = None
+        if labels is not None:
+            loss_fn = nn.BCEWithLogitsLoss()
+            loss = loss_fn(logits, labels.float())
+        return {"loss": loss, "logits": logits}
+
+    def state_dict(self, *args, **kwargs):
+        # Get the state dictionary
+        state_dict = super().state_dict(*args, **kwargs)
+        # Ensure all tensors are contiguous
+        for key, tensor in state_dict.items():
+            if isinstance(tensor, torch.Tensor) and not tensor.is_contiguous():
+                state_dict[key] = tensor.contiguous()
+        return state_dict

model/t5.py

@@ -0,0 +1,54 @@
+from transformers import T5EncoderModel, T5Config
+from huggingface_hub import hf_hub_download
+import torch.nn as nn
+import torch
+
+NUM_LABELS = 4
+
+class T5ClassificationModel(nn.Module):
+    def __init__(self, model_path="t5-small", freeze_weights=True):
+        super(T5ClassificationModel, self).__init__()
+        if model_path == "t5-small":
+            self.base_model = T5EncoderModel.from_pretrained(model_path)
+        else:
+            pytorch_model_path = hf_hub_download(
+                repo_id=model_path,
+                repo_type="model",
+                filename="pytorch_model.bin"
+            )
+            config = T5Config.from_pretrained(model_path)
+            self.base_model = T5EncoderModel(config)
+
+            # Load the state_dict and remove unwanted keys
+            state_dict = torch.load(pytorch_model_path)
+            filtered_state_dict = {
+                k.replace("base_model.", ""): v
+                for k, v in state_dict.items()
+                if not k.startswith("classifier.")
+            }
+            self.base_model.load_state_dict(filtered_state_dict)
+
+        # For push to hub.
+        self.config = self.base_model.config
+        
+        # Freeze the base model's weights
+        if freeze_weights:
+            for param in self.base_model.parameters():
+                param.requires_grad = False
+        
+        # Add a classification head
+        self.classifier = nn.Linear(self.base_model.config.hidden_size, NUM_LABELS)
+    
+    def forward(self, input_ids, attention_mask, labels=None):
+        with torch.no_grad():  # No gradients for the base model
+            outputs = self.base_model(input_ids=input_ids, attention_mask=attention_mask)
+        
+        # Sum token representations
+        summed_representation = outputs.last_hidden_state.sum(dim=1)  # Summing over the sequence length (dim=1)
+        
+        logits = self.classifier(summed_representation)  # Pass the summed representation to the classifier
+        loss = None
+        if labels is not None:
+            loss_fn = nn.BCEWithLogitsLoss()
+            loss = loss_fn(logits, labels.float())
+        return {"loss": loss, "logits": logits}

notebooks/inference.ipynb

@@ -1,313 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import torch\n",
-    "\n",
-    "from huggingface_hub import hf_hub_download\n",
-    "from transformers import AutoTokenizer\n",
-    "\n",
-    "from model.distilbert import DistilBertClassificationModel\n",
-    "from model.llama import LlamaClassificationModel"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "repo_id = \"ppak10/defect-classification-llama-baseline-25-epochs\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LlamaConfig {\n",
-      "  \"_attn_implementation_autoset\": true,\n",
-      "  \"_name_or_path\": \"meta-llama/Llama-3.2-1B\",\n",
-      "  \"architectures\": [\n",
-      "    \"LlamaForCausalLM\"\n",
-      "  ],\n",
-      "  \"attention_bias\": false,\n",
-      "  \"attention_dropout\": 0.0,\n",
-      "  \"bos_token_id\": 128000,\n",
-      "  \"eos_token_id\": 128001,\n",
-      "  \"head_dim\": 64,\n",
-      "  \"hidden_act\": \"silu\",\n",
-      "  \"hidden_size\": 2048,\n",
-      "  \"initializer_range\": 0.02,\n",
-      "  \"intermediate_size\": 8192,\n",
-      "  \"max_position_embeddings\": 131072,\n",
-      "  \"mlp_bias\": false,\n",
-      "  \"model_type\": \"llama\",\n",
-      "  \"num_attention_heads\": 32,\n",
-      "  \"num_hidden_layers\": 16,\n",
-      "  \"num_key_value_heads\": 8,\n",
-      "  \"pretraining_tp\": 1,\n",
-      "  \"rms_norm_eps\": 1e-05,\n",
-      "  \"rope_scaling\": {\n",
-      "    \"factor\": 32.0,\n",
-      "    \"high_freq_factor\": 4.0,\n",
-      "    \"low_freq_factor\": 1.0,\n",
-      "    \"original_max_position_embeddings\": 8192,\n",
-      "    \"rope_type\": \"llama3\"\n",
-      "  },\n",
-      "  \"rope_theta\": 500000.0,\n",
-      "  \"tie_word_embeddings\": true,\n",
-      "  \"torch_dtype\": \"bfloat16\",\n",
-      "  \"transformers_version\": \"4.47.0\",\n",
-      "  \"use_cache\": true,\n",
-      "  \"vocab_size\": 128256\n",
-      "}\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/tmp/ipykernel_3716586/1335258174.py:14: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
-      "  model.classifier.load_state_dict(torch.load(classification_head_path))\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "LlamaClassificationModel(\n",
-       "  (base_model): LlamaModel(\n",
-       "    (embed_tokens): Embedding(128256, 2048)\n",
-       "    (layers): ModuleList(\n",
-       "      (0-15): 16 x LlamaDecoderLayer(\n",
-       "        (self_attn): LlamaSdpaAttention(\n",
-       "          (q_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
-       "          (k_proj): Linear(in_features=2048, out_features=512, bias=False)\n",
-       "          (v_proj): Linear(in_features=2048, out_features=512, bias=False)\n",
-       "          (o_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
-       "          (rotary_emb): LlamaRotaryEmbedding()\n",
-       "        )\n",
-       "        (mlp): LlamaMLP(\n",
-       "          (gate_proj): Linear(in_features=2048, out_features=8192, bias=False)\n",
-       "          (up_proj): Linear(in_features=2048, out_features=8192, bias=False)\n",
-       "          (down_proj): Linear(in_features=8192, out_features=2048, bias=False)\n",
-       "          (act_fn): SiLU()\n",
-       "        )\n",
-       "        (input_layernorm): LlamaRMSNorm((2048,), eps=1e-05)\n",
-       "        (post_attention_layernorm): LlamaRMSNorm((2048,), eps=1e-05)\n",
-       "      )\n",
-       "    )\n",
-       "    (norm): LlamaRMSNorm((2048,), eps=1e-05)\n",
-       "    (rotary_emb): LlamaRotaryEmbedding()\n",
-       "  )\n",
-       "  (classifier): Linear(in_features=2048, out_features=4, bias=True)\n",
-       ")"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# Initialize the model\n",
-    "# model = DistilBertClassificationModel(repo_id)\n",
-    "model = LlamaClassificationModel()\n",
-    "\n",
-    "# Load the tokenizer\n",
-    "tokenizer = AutoTokenizer.from_pretrained(repo_id)\n",
-    "\n",
-    "classification_head_path = hf_hub_download(\n",
-    "    repo_id=repo_id,\n",
-    "    repo_type=\"model\",\n",
-    "    filename=\"classification_head.pt\"\n",
-    ")\n",
-    "\n",
-    "model.classifier.load_state_dict(torch.load(classification_head_path))\n",
-    "model.eval()  # Set the model to evaluation mode"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 56,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor([[1, 0, 0, 0]], dtype=torch.int32)\n"
-     ]
-    }
-   ],
-   "source": [
-    "# text = \"What defects would occur with a beam size of 100 microns, a power of 500 W, a velocity of 100 mm/s and layer height of 10 microns and a hatch spacing of 10 microns for Ti-6Al-4V\"\n",
-    "# text = \"SS316L[SEP]500 W[SEP]10.0 mm/s[SEP]500.0 microns[SEP]500.0 microns[SEP]100.0 microns\"\n",
-    "text = \"SS316L[SEP]250.0 W[SEP]280.0 mm/s[SEP][SEP]950.0 microns[SEP]600.0 microns\"\n",
-    "\n",
-    "# Ensure the model is on the GPU\n",
-    "# device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
-    "device = \"cpu\"\n",
-    "model = model.to(device)\n",
-    "\n",
-    "# Tokenize input for the entire batch and move to GPU\n",
-    "inputs = tokenizer(text, return_tensors=\"pt\", truncation=True, padding=\"max_length\", max_length=256)\n",
-    "inputs = {key: value.to(device) for key, value in inputs.items()}\n",
-    "\n",
-    "# Perform inference\n",
-    "outputs = model(**inputs)\n",
-    "\n",
-    "# Extract logits and apply sigmoid activation for multi-label classification\n",
-    "logits = outputs[\"logits\"]\n",
-    "probs = torch.sigmoid(logits)\n",
-    "\n",
-    "# Convert probabilities to one-hot encoded labels\n",
-    "preds = (probs > 0.5).int()\n",
-    "\n",
-    "# None, keyhole, lack of fusion, balling\n",
-    "print(preds)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/mnt/am/GitHub/LLM-Enabled-Process-Map/venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n"
-     ]
-    }
-   ],
-   "source": [
-    "import torch.nn as nn\n",
-    "from transformers import  PreTrainedModel\n",
-    "\n",
-    "class PretrainedLlamaClassificationModel(PreTrainedModel):\n",
-    "    def __init__(self, config):\n",
-    "        super().__init__(config)\n",
-    "        self.base_model = AutoModel.from_pretrained(config.model_path, config=config)\n",
-    "        self.classifier = nn.Linear(config.hidden_size, config.num_labels)\n",
-    "        self.config = config\n",
-    "\n",
-    "    def forward(self, input_ids, attention_mask, labels=None):\n",
-    "        outputs = self.base_model(input_ids=input_ids, attention_mask=attention_mask)\n",
-    "        summed_representation = outputs.last_hidden_state.sum(dim=1)\n",
-    "        logits = self.classifier(summed_representation)\n",
-    "        loss = None\n",
-    "        if labels is not None:\n",
-    "            loss_fn = nn.BCEWithLogitsLoss()\n",
-    "            loss = loss_fn(logits, labels.float())\n",
-    "        return {\"loss\": loss, \"logits\": logits}\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/mnt/am/GitHub/LLM-Enabled-Process-Map/venv/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "Some weights of LlamaModel were not initialized from the model checkpoint at ppak10/defect-classification-llama-baseline-25-epochs and are newly initialized: ['embed_tokens.weight', 'layers.0.input_layernorm.weight', 'layers.0.mlp.down_proj.weight', 'layers.0.mlp.gate_proj.weight', 'layers.0.mlp.up_proj.weight', 'layers.0.post_attention_layernorm.weight', 'layers.0.self_attn.k_proj.weight', 'layers.0.self_attn.o_proj.weight', 'layers.0.self_attn.q_proj.weight', 'layers.0.self_attn.v_proj.weight', 'layers.1.input_layernorm.weight', 'layers.1.mlp.down_proj.weight', 'layers.1.mlp.gate_proj.weight', 'layers.1.mlp.up_proj.weight', 'layers.1.post_attention_layernorm.weight', 'layers.1.self_attn.k_proj.weight', 'layers.1.self_attn.o_proj.weight', 'layers.1.self_attn.q_proj.weight', 'layers.1.self_attn.v_proj.weight', 'layers.10.input_layernorm.weight', 'layers.10.mlp.down_proj.weight', 'layers.10.mlp.gate_proj.weight', 'layers.10.mlp.up_proj.weight', 'layers.10.post_attention_layernorm.weight', 'layers.10.self_attn.k_proj.weight', 'layers.10.self_attn.o_proj.weight', 'layers.10.self_attn.q_proj.weight', 'layers.10.self_attn.v_proj.weight', 'layers.11.input_layernorm.weight', 'layers.11.mlp.down_proj.weight', 'layers.11.mlp.gate_proj.weight', 'layers.11.mlp.up_proj.weight', 'layers.11.post_attention_layernorm.weight', 'layers.11.self_attn.k_proj.weight', 'layers.11.self_attn.o_proj.weight', 'layers.11.self_attn.q_proj.weight', 'layers.11.self_attn.v_proj.weight', 'layers.12.input_layernorm.weight', 'layers.12.mlp.down_proj.weight', 'layers.12.mlp.gate_proj.weight', 'layers.12.mlp.up_proj.weight', 'layers.12.post_attention_layernorm.weight', 'layers.12.self_attn.k_proj.weight', 'layers.12.self_attn.o_proj.weight', 'layers.12.self_attn.q_proj.weight', 'layers.12.self_attn.v_proj.weight', 'layers.13.input_layernorm.weight', 'layers.13.mlp.down_proj.weight', 'layers.13.mlp.gate_proj.weight', 'layers.13.mlp.up_proj.weight', 'layers.13.post_attention_layernorm.weight', 'layers.13.self_attn.k_proj.weight', 'layers.13.self_attn.o_proj.weight', 'layers.13.self_attn.q_proj.weight', 'layers.13.self_attn.v_proj.weight', 'layers.14.input_layernorm.weight', 'layers.14.mlp.down_proj.weight', 'layers.14.mlp.gate_proj.weight', 'layers.14.mlp.up_proj.weight', 'layers.14.post_attention_layernorm.weight', 'layers.14.self_attn.k_proj.weight', 'layers.14.self_attn.o_proj.weight', 'layers.14.self_attn.q_proj.weight', 'layers.14.self_attn.v_proj.weight', 'layers.15.input_layernorm.weight', 'layers.15.mlp.down_proj.weight', 'layers.15.mlp.gate_proj.weight', 'layers.15.mlp.up_proj.weight', 'layers.15.post_attention_layernorm.weight', 'layers.15.self_attn.k_proj.weight', 'layers.15.self_attn.o_proj.weight', 'layers.15.self_attn.q_proj.weight', 'layers.15.self_attn.v_proj.weight', 'layers.16.input_layernorm.weight', 'layers.16.mlp.down_proj.weight', 'layers.16.mlp.gate_proj.weight', 'layers.16.mlp.up_proj.weight', 'layers.16.post_attention_layernorm.weight', 'layers.16.self_attn.k_proj.weight', 'layers.16.self_attn.o_proj.weight', 'layers.16.self_attn.q_proj.weight', 'layers.16.self_attn.v_proj.weight', 'layers.17.input_layernorm.weight', 'layers.17.mlp.down_proj.weight', 'layers.17.mlp.gate_proj.weight', 'layers.17.mlp.up_proj.weight', 'layers.17.post_attention_layernorm.weight', 'layers.17.self_attn.k_proj.weight', 'layers.17.self_attn.o_proj.weight', 'layers.17.self_attn.q_proj.weight', 'layers.17.self_attn.v_proj.weight', 'layers.18.input_layernorm.weight', 'layers.18.mlp.down_proj.weight', 'layers.18.mlp.gate_proj.weight', 'layers.18.mlp.up_proj.weight', 'layers.18.post_attention_layernorm.weight', 'layers.18.self_attn.k_proj.weight', 'layers.18.self_attn.o_proj.weight', 'layers.18.self_attn.q_proj.weight', 'layers.18.self_attn.v_proj.weight', 'layers.19.input_layernorm.weight', 'layers.19.mlp.down_proj.weight', 'layers.19.mlp.gate_proj.weight', 'layers.19.mlp.up_proj.weight', 'layers.19.post_attention_layernorm.weight', 'layers.19.self_attn.k_proj.weight', 'layers.19.self_attn.o_proj.weight', 'layers.19.self_attn.q_proj.weight', 'layers.19.self_attn.v_proj.weight', 'layers.2.input_layernorm.weight', 'layers.2.mlp.down_proj.weight', 'layers.2.mlp.gate_proj.weight', 'layers.2.mlp.up_proj.weight', 'layers.2.post_attention_layernorm.weight', 'layers.2.self_attn.k_proj.weight', 'layers.2.self_attn.o_proj.weight', 'layers.2.self_attn.q_proj.weight', 'layers.2.self_attn.v_proj.weight', 'layers.20.input_layernorm.weight', 'layers.20.mlp.down_proj.weight', 'layers.20.mlp.gate_proj.weight', 'layers.20.mlp.up_proj.weight', 'layers.20.post_attention_layernorm.weight', 'layers.20.self_attn.k_proj.weight', 'layers.20.self_attn.o_proj.weight', 'layers.20.self_attn.q_proj.weight', 'layers.20.self_attn.v_proj.weight', 'layers.21.input_layernorm.weight', 'layers.21.mlp.down_proj.weight', 'layers.21.mlp.gate_proj.weight', 'layers.21.mlp.up_proj.weight', 'layers.21.post_attention_layernorm.weight', 'layers.21.self_attn.k_proj.weight', 'layers.21.self_attn.o_proj.weight', 'layers.21.self_attn.q_proj.weight', 'layers.21.self_attn.v_proj.weight', 'layers.22.input_layernorm.weight', 'layers.22.mlp.down_proj.weight', 'layers.22.mlp.gate_proj.weight', 'layers.22.mlp.up_proj.weight', 'layers.22.post_attention_layernorm.weight', 'layers.22.self_attn.k_proj.weight', 'layers.22.self_attn.o_proj.weight', 'layers.22.self_attn.q_proj.weight', 'layers.22.self_attn.v_proj.weight', 'layers.23.input_layernorm.weight', 'layers.23.mlp.down_proj.weight', 'layers.23.mlp.gate_proj.weight', 'layers.23.mlp.up_proj.weight', 'layers.23.post_attention_layernorm.weight', 'layers.23.self_attn.k_proj.weight', 'layers.23.self_attn.o_proj.weight', 'layers.23.self_attn.q_proj.weight', 'layers.23.self_attn.v_proj.weight', 'layers.24.input_layernorm.weight', 'layers.24.mlp.down_proj.weight', 'layers.24.mlp.gate_proj.weight', 'layers.24.mlp.up_proj.weight', 'layers.24.post_attention_layernorm.weight', 'layers.24.self_attn.k_proj.weight', 'layers.24.self_attn.o_proj.weight', 'layers.24.self_attn.q_proj.weight', 'layers.24.self_attn.v_proj.weight', 'layers.25.input_layernorm.weight', 'layers.25.mlp.down_proj.weight', 'layers.25.mlp.gate_proj.weight', 'layers.25.mlp.up_proj.weight', 'layers.25.post_attention_layernorm.weight', 'layers.25.self_attn.k_proj.weight', 'layers.25.self_attn.o_proj.weight', 'layers.25.self_attn.q_proj.weight', 'layers.25.self_attn.v_proj.weight', 'layers.26.input_layernorm.weight', 'layers.26.mlp.down_proj.weight', 'layers.26.mlp.gate_proj.weight', 'layers.26.mlp.up_proj.weight', 'layers.26.post_attention_layernorm.weight', 'layers.26.self_attn.k_proj.weight', 'layers.26.self_attn.o_proj.weight', 'layers.26.self_attn.q_proj.weight', 'layers.26.self_attn.v_proj.weight', 'layers.27.input_layernorm.weight', 'layers.27.mlp.down_proj.weight', 'layers.27.mlp.gate_proj.weight', 'layers.27.mlp.up_proj.weight', 'layers.27.post_attention_layernorm.weight', 'layers.27.self_attn.k_proj.weight', 'layers.27.self_attn.o_proj.weight', 'layers.27.self_attn.q_proj.weight', 'layers.27.self_attn.v_proj.weight', 'layers.28.input_layernorm.weight', 'layers.28.mlp.down_proj.weight', 'layers.28.mlp.gate_proj.weight', 'layers.28.mlp.up_proj.weight', 'layers.28.post_attention_layernorm.weight', 'layers.28.self_attn.k_proj.weight', 'layers.28.self_attn.o_proj.weight', 'layers.28.self_attn.q_proj.weight', 'layers.28.self_attn.v_proj.weight', 'layers.29.input_layernorm.weight', 'layers.29.mlp.down_proj.weight', 'layers.29.mlp.gate_proj.weight', 'layers.29.mlp.up_proj.weight', 'layers.29.post_attention_layernorm.weight', 'layers.29.self_attn.k_proj.weight', 'layers.29.self_attn.o_proj.weight', 'layers.29.self_attn.q_proj.weight', 'layers.29.self_attn.v_proj.weight', 'layers.3.input_layernorm.weight', 'layers.3.mlp.down_proj.weight', 'layers.3.mlp.gate_proj.weight', 'layers.3.mlp.up_proj.weight', 'layers.3.post_attention_layernorm.weight', 'layers.3.self_attn.k_proj.weight', 'layers.3.self_attn.o_proj.weight', 'layers.3.self_attn.q_proj.weight', 'layers.3.self_attn.v_proj.weight', 'layers.30.input_layernorm.weight', 'layers.30.mlp.down_proj.weight', 'layers.30.mlp.gate_proj.weight', 'layers.30.mlp.up_proj.weight', 'layers.30.post_attention_layernorm.weight', 'layers.30.self_attn.k_proj.weight', 'layers.30.self_attn.o_proj.weight', 'layers.30.self_attn.q_proj.weight', 'layers.30.self_attn.v_proj.weight', 'layers.31.input_layernorm.weight', 'layers.31.mlp.down_proj.weight', 'layers.31.mlp.gate_proj.weight', 'layers.31.mlp.up_proj.weight', 'layers.31.post_attention_layernorm.weight', 'layers.31.self_attn.k_proj.weight', 'layers.31.self_attn.o_proj.weight', 'layers.31.self_attn.q_proj.weight', 'layers.31.self_attn.v_proj.weight', 'layers.4.input_layernorm.weight', 'layers.4.mlp.down_proj.weight', 'layers.4.mlp.gate_proj.weight', 'layers.4.mlp.up_proj.weight', 'layers.4.post_attention_layernorm.weight', 'layers.4.self_attn.k_proj.weight', 'layers.4.self_attn.o_proj.weight', 'layers.4.self_attn.q_proj.weight', 'layers.4.self_attn.v_proj.weight', 'layers.5.input_layernorm.weight', 'layers.5.mlp.down_proj.weight', 'layers.5.mlp.gate_proj.weight', 'layers.5.mlp.up_proj.weight', 'layers.5.post_attention_layernorm.weight', 'layers.5.self_attn.k_proj.weight', 'layers.5.self_attn.o_proj.weight', 'layers.5.self_attn.q_proj.weight', 'layers.5.self_attn.v_proj.weight', 'layers.6.input_layernorm.weight', 'layers.6.mlp.down_proj.weight', 'layers.6.mlp.gate_proj.weight', 'layers.6.mlp.up_proj.weight', 'layers.6.post_attention_layernorm.weight', 'layers.6.self_attn.k_proj.weight', 'layers.6.self_attn.o_proj.weight', 'layers.6.self_attn.q_proj.weight', 'layers.6.self_attn.v_proj.weight', 'layers.7.input_layernorm.weight', 'layers.7.mlp.down_proj.weight', 'layers.7.mlp.gate_proj.weight', 'layers.7.mlp.up_proj.weight', 'layers.7.post_attention_layernorm.weight', 'layers.7.self_attn.k_proj.weight', 'layers.7.self_attn.o_proj.weight', 'layers.7.self_attn.q_proj.weight', 'layers.7.self_attn.v_proj.weight', 'layers.8.input_layernorm.weight', 'layers.8.mlp.down_proj.weight', 'layers.8.mlp.gate_proj.weight', 'layers.8.mlp.up_proj.weight', 'layers.8.post_attention_layernorm.weight', 'layers.8.self_attn.k_proj.weight', 'layers.8.self_attn.o_proj.weight', 'layers.8.self_attn.q_proj.weight', 'layers.8.self_attn.v_proj.weight', 'layers.9.input_layernorm.weight', 'layers.9.mlp.down_proj.weight', 'layers.9.mlp.gate_proj.weight', 'layers.9.mlp.up_proj.weight', 'layers.9.post_attention_layernorm.weight', 'layers.9.self_attn.k_proj.weight', 'layers.9.self_attn.o_proj.weight', 'layers.9.self_attn.q_proj.weight', 'layers.9.self_attn.v_proj.weight', 'norm.weight']\n",
-      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
-     ]
-    }
-   ],
-   "source": [
-    "from transformers import AutoModel, pipeline\n",
-    "\n",
-    "repo_id = \"ppak10/defect-classification-llama-baseline-25-epochs\"\n",
-    "model = AutoModel.from_pretrained(repo_id)\n",
-    "# tokenizer = AutoTokenizer.from_pretrained(repo_id)\n",
-    "\n",
-    "# classification_pipeline = pipeline(\"text-classification\", model=model, tokenizer=tokenizer)\n",
-    "# result = classification_pipeline(\"Test input text\")\n",
-    "# print(result)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "LlamaModel(\n",
-      "  (embed_tokens): Embedding(32000, 2048)\n",
-      "  (layers): ModuleList(\n",
-      "    (0-31): 32 x LlamaDecoderLayer(\n",
-      "      (self_attn): LlamaSdpaAttention(\n",
-      "        (q_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
-      "        (k_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
-      "        (v_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
-      "        (o_proj): Linear(in_features=2048, out_features=2048, bias=False)\n",
-      "        (rotary_emb): LlamaRotaryEmbedding()\n",
-      "      )\n",
-      "      (mlp): LlamaMLP(\n",
-      "        (gate_proj): Linear(in_features=2048, out_features=11008, bias=False)\n",
-      "        (up_proj): Linear(in_features=2048, out_features=11008, bias=False)\n",
-      "        (down_proj): Linear(in_features=11008, out_features=2048, bias=False)\n",
-      "        (act_fn): SiLU()\n",
-      "      )\n",
-      "      (input_layernorm): LlamaRMSNorm((2048,), eps=1e-06)\n",
-      "      (post_attention_layernorm): LlamaRMSNorm((2048,), eps=1e-06)\n",
-      "    )\n",
-      "  )\n",
-      "  (norm): LlamaRMSNorm((2048,), eps=1e-06)\n",
-      "  (rotary_emb): LlamaRotaryEmbedding()\n",
-      ")\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(model)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "venv",
-   "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.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

requirements.txt

@@ -1,3 +1,9 @@
 jupyterlab==4.2.5
-tornado==6.2
-ipywidgets
+ipywidgets
+torch
+huggingface_hub
+transformers
+sentencepiece
+safetensors
+datasets
+numpy

setup.py

@@ -0,0 +1,6 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="llm_enabled_process_map",
+    packages=find_packages()
+)

start_server.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 JUPYTER_TOKEN="${JUPYTER_TOKEN:=huggingface}"
 
-NOTEBOOK_DIR="./notebooks"
+NOTEBOOK_DIR="model"
 
 jupyter labextension disable "@jupyterlab/apputils-extension:announcements"