final

app.py

@@ -0,0 +1,55 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from transformers import AutoTokenizer, AutoModel
+import torch.nn.functional as F
+import timm
+from huggingface_hub import PyTorchModelHubMixin
+
+
+
+class TwoLayerNN(nn.Module, PyTorchModelHubMixin):
+    def __init__(self, input_dim, hidden_dim, output_dim):
+        super(TwoLayerNN, self).__init__()
+        self.fc1 = nn.Linear(input_dim, hidden_dim)
+        self.relu = nn.ReLU()
+        self.fc2 = nn.Linear(hidden_dim, output_dim)
+        self.sigmoid = nn.Sigmoid()
+
+    def forward(self, x):
+        out = self.fc1(x)
+        out = self.relu(out)
+        out = self.fc2(out)
+        out = self.sigmoid(out)
+        return out
+
+
+
+classifier = TwoLayerNN.from_pretrained("Robzy/job-classifier", input_dim=384, hidden_dim=128, output_dim=1)
+tokenizer = AutoTokenizer.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+embedding_model = AutoModel.from_pretrained("sentence-transformers/all-MiniLM-L6-v2")
+
+    
+def mean_pooling(model_output, attention_mask):
+    token_embeddings = model_output[0] #First element of model_output contains all token embeddings
+    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
+def infer(text):
+    
+    encoded_input = tokenizer(text, padding=True, truncation=True, return_tensors='pt')
+
+    with torch.no_grad():
+        model_output = embedding_model(**encoded_input)
+        
+    sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
+    sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)
+    
+    output = classifier(sentence_embeddings)
+    return output.item()   
+
+
+demo = gr.Interface(fn=infer, inputs="text", outputs="text")
+gr.Textbox(placeholder="Enter job description here", label="Job Description")
+demo.launch()

browser.py

@@ -0,0 +1,150 @@
+from io import BytesIO
+from time import sleep
+
+import helium
+from dotenv import load_dotenv
+from PIL import Image
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+
+from smolagents import CodeAgent, tool
+from smolagents.agents import ActionStep
+
+# Load environment variables
+load_dotenv()
+
+
+@tool
+def search_item_ctrl_f(text: str, nth_result: int = 1) -> str:
+    """
+    Searches for text on the current page via Ctrl + F and jumps to the nth occurrence.
+    Args:
+        text: The text to search for
+        nth_result: Which occurrence to jump to (default: 1)
+    """
+    elements = driver.find_elements(By.XPATH, f"//*[contains(text(), '{text}')]")
+    if nth_result > len(elements):
+        raise Exception(f"Match n°{nth_result} not found (only {len(elements)} matches found)")
+    result = f"Found {len(elements)} matches for '{text}'."
+    elem = elements[nth_result - 1]
+    driver.execute_script("arguments[0].scrollIntoView(true);", elem)
+    result += f"Focused on element {nth_result} of {len(elements)}"
+    return result
+
+@tool
+def go_back() -> None:
+    """Goes back to previous page."""
+    driver.back()
+
+@tool
+def close_popups() -> str:
+    """
+    Closes any visible modal or pop-up on the page. Use this to dismiss pop-up windows!
+    This does not work on cookie consent banners.
+    """
+    webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
+    
+    
+# Configure Chrome options
+chrome_options = webdriver.ChromeOptions()
+chrome_options.add_argument("--force-device-scale-factor=1")
+chrome_options.add_argument("--window-size=1000,1350")
+chrome_options.add_argument("--disable-pdf-viewer")
+chrome_options.add_argument("--window-position=0,0")
+
+# Initialize the browser
+driver = helium.start_chrome(headless=False, options=chrome_options)
+
+# Set up screenshot callback
+def save_screenshot(memory_step: ActionStep, agent: CodeAgent) -> None:
+    sleep(1.0)  # Let JavaScript animations happen before taking the screenshot
+    driver = helium.get_driver()
+    current_step = memory_step.step_number
+    if driver is not None:
+        for previous_memory_step in agent.memory.steps:  # Remove previous screenshots for lean processing
+            if isinstance(previous_memory_step, ActionStep) and previous_memory_step.step_number <= current_step - 2:
+                previous_memory_step.observations_images = None
+        png_bytes = driver.get_screenshot_as_png()
+        image = Image.open(BytesIO(png_bytes))
+        print(f"Captured a browser screenshot: {image.size} pixels")
+        memory_step.observations_images = [image.copy()]  # Create a copy to ensure it persists
+
+    # Update observations with current URL
+    url_info = f"Current url: {driver.current_url}"
+    memory_step.observations = (
+        url_info if memory_step.observations is None else memory_step.observations + "\n" + url_info
+    )
+    
+from smolagents import HfApiModel
+
+# Initialize the model
+model_id = "meta-llama/Llama-3.3-70B-Instruct"  # You can change this to your preferred model
+model = HfApiModel(model_id)
+
+# Create the agent
+agent = CodeAgent(
+    tools=[go_back, close_popups, search_item_ctrl_f],
+    model=model,
+    additional_authorized_imports=["helium"],
+    step_callbacks=[save_screenshot],
+    max_steps=20,
+    verbosity_level=2,
+)
+
+# Import helium for the agent
+agent.python_executor("from helium import *", agent.state)
+
+helium_instructions = """
+You can use helium to access websites. Don't bother about the helium driver, it's already managed.
+We've already ran "from helium import *"
+Then you can go to pages!
+Code:
+```py
+go_to('github.com/trending')
+```<end_code>
+
+You can directly click clickable elements by inputting the text that appears on them.
+Code:
+```py
+click("Top products")
+```<end_code>
+
+If it's a link:
+Code:
+```py
+click(Link("Top products"))
+```<end_code>
+
+If you try to interact with an element and it's not found, you'll get a LookupError.
+In general stop your action after each button click to see what happens on your screenshot.
+Never try to login in a page.
+
+To scroll up or down, use scroll_down or scroll_up with as an argument the number of pixels to scroll from.
+Code:
+```py
+scroll_down(num_pixels=1200) # This will scroll one viewport down
+```<end_code>
+
+When you have pop-ups with a cross icon to close, don't try to click the close icon by finding its element or targeting an 'X' element (this most often fails).
+Just use your built-in tool `close_popups` to close them:
+Code:
+```py
+close_popups()
+```<end_code>
+
+You can use .exists() to check for the existence of an element. For example:
+Code:
+```py
+if Text('Accept cookies?').exists():
+    click('I accept')
+```<end_code>
+"""
+
+search_request = """
+Please navigate to https://en.wikipedia.org/wiki/Chicago and give me a sentence containing the word "1992" that mentions a construction accident.
+"""
+
+agent_output = agent.run(search_request + helium_instructions)
+print("Final output:")
+print(agent_output)

job-search.py

@@ -0,0 +1,35 @@
+import requests
+
+url = "https://jobsearch.api.jobtechdev.se/search"
+
+response = requests.get(url)
+
+if response.status_code == 200:
+    data = response.json()
+    print(data)
+else:
+    print(f"Failed to retrieve data: {response.status_code}")
+    
+  
+    
+{
+  "hits": [
+    {
+      "id": "1",
+      "headline": "Data Scientist",
+      "description": {"text": "We are looking for a data scientist to join our team.",
+                      "text-formatted": "text_formatted"},
+      "location": "Stockholm",
+      "company": "Company A"
+    },
+    {
+      "id": "2",
+      "headline": "Software Engineer",
+      "description": {"text": "We are looking for a data scientist to join our team.",
+                      "text-formatted": "text_formatted"},
+      "location": "Gothenburg",
+      "company": "Company B"
+    },
+    ...
+  ]
+}

main.ipynb

@@ -0,0 +1,382 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "from transformers import AutoTokenizer, AutoModel\n",
+    "import os\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "import torch.nn.functional as F\n",
+    "from huggingface_hub import PyTorchModelHubMixin"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model directly\n",
+    "    \n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "model = AutoModel.from_pretrained(\"sentence-transformers/all-MiniLM-L6-v2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "43\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "\n",
+    "# Directory containing the job files\n",
+    "jobs_dir = 'jobs'\n",
+    "\n",
+    "# List to store the contents of the txt files with labels\n",
+    "dataset = []\n",
+    "\n",
+    "# Walk through the directory\n",
+    "for root, dirs, files in os.walk(jobs_dir):\n",
+    "    for file in files:\n",
+    "        if file.endswith('.txt'):\n",
+    "            file_path = os.path.join(root, file)\n",
+    "            with open(file_path, 'r') as f:\n",
+    "                txt = f.read()\n",
+    "                label = 0 if 'disliked' in root else 1\n",
+    "                dataset.append((txt, label))\n",
+    "\n",
+    "# Print the number of txt files\n",
+    "print(len(dataset))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "txts = [txt for txt, label in dataset]\n",
+    "labels = [label for txt, label in dataset]\n",
+    "\n",
+    "# Generate a list of indices and shuffle them\n",
+    "indices = list(range(len(txts)))\n",
+    "random.shuffle(indices)\n",
+    "\n",
+    "# Apply the shuffled indices to txts and labels\n",
+    "txts = [txts[i] for i in indices]\n",
+    "labels = [labels[i] for i in indices]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Tokenize sentences\n",
+    "# text = [\"Hello, my dog is cute\", \"Hello, my cat is cute\"]\n",
+    "encoded_input = tokenizer(txts, padding=True, truncation=True, return_tensors='pt')\n",
+    "\n",
+    "# Compute token embeddings\n",
+    "with torch.no_grad():\n",
+    "    model_output = model(**encoded_input)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def mean_pooling(model_output, attention_mask):\n",
+    "    token_embeddings = model_output[0] #First element of model_output contains all token embeddings\n",
+    "    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()\n",
+    "    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)\n",
+    "\n",
+    "\n",
+    "# Perform pooling\n",
+    "sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])\n",
+    "\n",
+    "# Normalize embeddings\n",
+    "sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([43, 384])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sentence_embeddings.size()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 1,\n",
+       " 1,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 1,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0,\n",
+       " 0]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "labels"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [5/20], Loss: 0.6616\n",
+      "Epoch [10/20], Loss: 0.6401\n",
+      "Epoch [15/20], Loss: 0.6221\n",
+      "Epoch [20/20], Loss: 0.6074\n",
+      "Training complete.\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "\n",
+    "# Define the neural network\n",
+    "class TwoLayerNN(nn.Module, PyTorchModelHubMixin):\n",
+    "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
+    "        super(TwoLayerNN, self).__init__()\n",
+    "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
+    "        self.relu = nn.ReLU()\n",
+    "        self.fc2 = nn.Linear(hidden_dim, output_dim)\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        out = self.fc1(x)\n",
+    "        out = self.relu(out)\n",
+    "        out = self.fc2(out)\n",
+    "        out = self.sigmoid(out)\n",
+    "        return out\n",
+    "\n",
+    "# Hyperparameters\n",
+    "input_dim = sentence_embeddings.size(1)\n",
+    "hidden_dim = 128\n",
+    "output_dim = 1\n",
+    "num_epochs = 20\n",
+    "learning_rate = 0.001\n",
+    "\n",
+    "# Model, loss function, and optimizer\n",
+    "classifier = TwoLayerNN(input_dim, hidden_dim, output_dim)\n",
+    "criterion = nn.BCELoss()\n",
+    "optimizer = optim.Adam(classifier.parameters(), lr=learning_rate)\n",
+    "\n",
+    "# Convert labels to tensor\n",
+    "labels_tensor = torch.tensor(labels, dtype=torch.float32).unsqueeze(1)\n",
+    "\n",
+    "# Training loop\n",
+    "for epoch in range(num_epochs):\n",
+    "    classifier.train()\n",
+    "    optimizer.zero_grad()\n",
+    "    outputs = classifier(sentence_embeddings)\n",
+    "    loss = criterion(outputs, labels_tensor)\n",
+    "    loss.backward()\n",
+    "    optimizer.step()\n",
+    "\n",
+    "    if (epoch+1) % 5 == 0:\n",
+    "        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')\n",
+    "\n",
+    "print(\"Training complete.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Job description: A very fun job with data science and machine learning\n",
+      "Prediction: liked (score: 0.5050)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Inference\n",
+    "classifier.eval()\n",
+    "job_description = \"A very fun job with data science and machine learning\"\n",
+    "encoded_input = tokenizer(job_description, padding=True, truncation=True, return_tensors='pt')\n",
+    "with torch.no_grad():\n",
+    "    model_output = model(**encoded_input)\n",
+    "sentence_embedding = mean_pooling(model_output, encoded_input['attention_mask'])\n",
+    "sentence_embedding = F.normalize(sentence_embedding, p=2, dim=1)\n",
+    "output = classifier(sentence_embedding)\n",
+    "prediction = 'liked' if output.item() > 0.5 else 'disliked'\n",
+    "print(f\"Job description: {job_description}\")\n",
+    "print(f\"Prediction: {prediction} (score: {output.item():.4f})\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from huggingface_hub import HfApi, HfFolder\n",
+    "\n",
+    "# Save the model and tokenizer\n",
+    "classifier.save_pretrained(\"job-classifier\")\n",
+    "tokenizer.save_pretrained(\"job-classifier\")\n",
+    "\n",
+    "# Initialize the HfApi\n",
+    "api = HfApi()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "No files have been modified since last commit. Skipping to prevent empty commit.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "CommitInfo(commit_url='https://huggingface.co/Robzy/job-classifier/commit/fbe58c86c6d0859305675ac93f155fef7462a58d', commit_message='Upload model', commit_description='', oid='fbe58c86c6d0859305675ac93f155fef7462a58d', pr_url=None, repo_url=RepoUrl('https://huggingface.co/Robzy/job-classifier', endpoint='https://huggingface.co', repo_type='model', repo_id='Robzy/job-classifier'), pr_revision=None, pr_num=None)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.push_to_hub(\"Robzy/job-classifier\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "input_dim = 384\n",
+    "hidden_dim = 128\n",
+    "output_dim = 1\n",
+    "classifier = TwoLayerNN.from_pretrained(\"Robzy/job-classifier\", input_dim=input_dim, hidden_dim=hidden_dim, output_dim=output_dim)"
+   ]
+  },
+  {
+   "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "hf-workshop"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "gradio>=5.21.0",
+    "helium>=5.1.1",
+    "llama-index>=0.12.24",
+    "numpy>=2.2.3",
+    "pillow>=11.1.0",
+    "scipy>=1.15.2",
+    "selenium>=4.29.0",
+    "smolagents>=1.10.0",
+    "timm>=1.0.15",
+    "torch>=2.6.0",
+    "torchvision>=0.21.0",
+    "transformers>=4.49.0",
+]
+
+[dependency-groups]
+dev = [
+    "ipykernel>=6.29.5",
+]
+
+[tool.uv.sources]
+torch = [
+    { index = "pytorch-cpu" },
+]
+torchvision = [
+    { index = "pytorch-cpu" },
+]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true

requirements.txt

@@ -0,0 +1,10 @@
+smolagents
+selenium
+helium
+pillow
+gradio
+transformers
+numpy
+sentence-transformers
+torch
+timm