diff --git a/notebooks/news_recommendation_byom.ipynb b/notebooks/news_recommendation_byom.ipynb
index c38e4c6..1d35c41 100644
--- a/notebooks/news_recommendation_byom.ipynb
+++ b/notebooks/news_recommendation_byom.ipynb
@@ -2,14 +2,138 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The autoreload extension is already loaded. To reload it, use:\n",
+      "  %reload_ext autoreload\n"
+     ]
+    }
+   ],
    "source": [
-    "# ! pip install ../\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
+      "To disable this warning, you can either:\n",
+      "\t- Avoid using `tokenizers` before the fork if possible\n",
+      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Processing /home/chetan/dev/learn_to_pick\n",
+      "  Preparing metadata (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25hRequirement already satisfied: numpy>=1.24.4 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.26.1)\n",
+      "Requirement already satisfied: pandas>=2.0.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.1.1)\n",
+      "Requirement already satisfied: vowpal-wabbit-next==0.7.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.7.0)\n",
+      "Requirement already satisfied: sentence-transformers>=2.2.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.2.2)\n",
+      "Requirement already satisfied: torch==2.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (2.0.1)\n",
+      "Requirement already satisfied: pyskiplist in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (1.0.0)\n",
+      "Requirement already satisfied: parameterfree in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from learn-to-pick==0.0.3) (0.0.1)\n",
+      "Requirement already satisfied: filelock in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.12.4)\n",
+      "Requirement already satisfied: typing-extensions in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (4.8.0)\n",
+      "Requirement already satisfied: sympy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (1.12)\n",
+      "Requirement already satisfied: networkx in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.2)\n",
+      "Requirement already satisfied: jinja2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (3.1.2)\n",
+      "Requirement already satisfied: nvidia-cuda-nvrtc-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.99)\n",
+      "Requirement already satisfied: nvidia-cuda-runtime-cu11==11.7.99 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.99)\n",
+      "Requirement already satisfied: nvidia-cuda-cupti-cu11==11.7.101 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.101)\n",
+      "Requirement already satisfied: nvidia-cudnn-cu11==8.5.0.96 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (8.5.0.96)\n",
+      "Requirement already satisfied: nvidia-cublas-cu11==11.10.3.66 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.10.3.66)\n",
+      "Requirement already satisfied: nvidia-cufft-cu11==10.9.0.58 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (10.9.0.58)\n",
+      "Requirement already satisfied: nvidia-curand-cu11==10.2.10.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (10.2.10.91)\n",
+      "Requirement already satisfied: nvidia-cusolver-cu11==11.4.0.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.4.0.1)\n",
+      "Requirement already satisfied: nvidia-cusparse-cu11==11.7.4.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.4.91)\n",
+      "Requirement already satisfied: nvidia-nccl-cu11==2.14.3 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (2.14.3)\n",
+      "Requirement already satisfied: nvidia-nvtx-cu11==11.7.91 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (11.7.91)\n",
+      "Requirement already satisfied: triton==2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torch==2.0.1->learn-to-pick==0.0.3) (2.0.0)\n",
+      "Requirement already satisfied: setuptools in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch==2.0.1->learn-to-pick==0.0.3) (68.0.0)\n",
+      "Requirement already satisfied: wheel in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nvidia-cublas-cu11==11.10.3.66->torch==2.0.1->learn-to-pick==0.0.3) (0.41.2)\n",
+      "Requirement already satisfied: cmake in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch==2.0.1->learn-to-pick==0.0.3) (3.27.7)\n",
+      "Requirement already satisfied: lit in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from triton==2.0.0->torch==2.0.1->learn-to-pick==0.0.3) (17.0.4)\n",
+      "Requirement already satisfied: python-dateutil>=2.8.2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2.8.2)\n",
+      "Requirement already satisfied: pytz>=2020.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3.post1)\n",
+      "Requirement already satisfied: tzdata>=2022.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from pandas>=2.0.3->learn-to-pick==0.0.3) (2023.3)\n",
+      "Requirement already satisfied: transformers<5.0.0,>=4.6.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.34.1)\n",
+      "Requirement already satisfied: tqdm in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (4.66.1)\n",
+      "Requirement already satisfied: torchvision in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.15.2)\n",
+      "Requirement already satisfied: scikit-learn in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n",
+      "Requirement already satisfied: scipy in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.11.3)\n",
+      "Requirement already satisfied: nltk in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.8.1)\n",
+      "Requirement already satisfied: sentencepiece in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.1.99)\n",
+      "Requirement already satisfied: huggingface-hub>=0.4.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.17.3)\n",
+      "Requirement already satisfied: fsspec in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.0)\n",
+      "Requirement already satisfied: requests in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.31.0)\n",
+      "Requirement already satisfied: pyyaml>=5.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (6.0.1)\n",
+      "Requirement already satisfied: packaging>=20.9 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (23.2)\n",
+      "Requirement already satisfied: six>=1.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from python-dateutil>=2.8.2->pandas>=2.0.3->learn-to-pick==0.0.3) (1.16.0)\n",
+      "Requirement already satisfied: regex!=2019.12.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.10.3)\n",
+      "Requirement already satisfied: tokenizers<0.15,>=0.14 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.14.1)\n",
+      "Requirement already satisfied: safetensors>=0.3.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (0.4.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from jinja2->torch==2.0.1->learn-to-pick==0.0.3) (2.1.3)\n",
+      "Requirement already satisfied: click in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (8.1.7)\n",
+      "Requirement already satisfied: joblib in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from nltk->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (1.3.2)\n",
+      "Requirement already satisfied: threadpoolctl>=2.0.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from scikit-learn->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.2.0)\n",
+      "Requirement already satisfied: mpmath>=0.19 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from sympy->torch==2.0.1->learn-to-pick==0.0.3) (1.3.0)\n",
+      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from torchvision->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (10.1.0)\n",
+      "Requirement already satisfied: charset-normalizer<4,>=2 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.3.1)\n",
+      "Requirement already satisfied: idna<4,>=2.5 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (3.4)\n",
+      "Requirement already satisfied: urllib3<3,>=1.21.1 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2.0.7)\n",
+      "Requirement already satisfied: certifi>=2017.4.17 in /anaconda/envs/learn_to_pick/lib/python3.10/site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers>=2.2.2->learn-to-pick==0.0.3) (2023.7.22)\n",
+      "Building wheels for collected packages: learn-to-pick\n",
+      "  Building wheel for learn-to-pick (setup.py) ... \u001b[?25ldone\n",
+      "\u001b[?25h  Created wheel for learn-to-pick: filename=learn_to_pick-0.0.3-py3-none-any.whl size=22905 sha256=212caafaac49093734f8b40ad0fbc03ac97fa9af06f7166aaa7252166a0c4395\n",
+      "  Stored in directory: /tmp/pip-ephem-wheel-cache-qsmxj9e8/wheels/18/bf/25/d8dda8a9a6b5284eaed510a4708ef9b22b9894a5e94b329ea2\n",
+      "Successfully built learn-to-pick\n",
+      "Installing collected packages: learn-to-pick\n",
+      "  Attempting uninstall: learn-to-pick\n",
+      "    Found existing installation: learn-to-pick 0.0.3\n",
+      "    Uninstalling learn-to-pick-0.0.3:\n",
+      "      Successfully uninstalled learn-to-pick-0.0.3\n",
+      "Successfully installed learn-to-pick-0.0.3\n"
+     ]
+    }
+   ],
+   "source": [
+    "! pip install ../\n",
     "# ! pip install matplotlib"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2.0.1+cu117\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "print(torch.__version__)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -25,13 +149,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
     "import random\n",
-    "from typing import Any, Dict, List, Optional\n",
-    "import re\n",
     "\n",
     "users = [\"Tom\", \"Anna\"]\n",
     "times_of_day = [\"morning\", \"afternoon\"]\n",
@@ -47,7 +169,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -91,23 +213,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from learn_to_pick import PyTorchFeatureEmbedder\n",
+    "fe = PyTorchFeatureEmbedder(auto_embed=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
-    "picker = learn_to_pick.PickBest.create(metrics_step=20, metrics_window_size=20, selection_scorer=CustomSelectionScorer())\n",
-    "random_picker = learn_to_pick.PickBest.create(metrics_step=20, metrics_window_size=20, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())"
+    "from learn_to_pick import PyTorchPolicy\n",
+    "\n",
+    "picker = learn_to_pick.PickBest.create(\n",
+    "    metrics_step=100, metrics_window_size=100, selection_scorer=CustomSelectionScorer())\n",
+    "pytorch_picker = learn_to_pick.PickBest.create(\n",
+    "    metrics_step=100, metrics_window_size=100, policy=PyTorchPolicy(feature_embedder=fe), selection_scorer=CustomSelectionScorer())\n",
+    "random_picker = learn_to_pick.PickBest.create(\n",
+    "    metrics_step=100, metrics_window_size=100, policy=learn_to_pick.PickBestRandomPolicy(), selection_scorer=CustomSelectionScorer())"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
     "# randomly pick users and times of day\n",
     "\n",
-    "for i in range(500):\n",
+    "for i in range(2500):\n",
     "    user = choose_user(users)\n",
     "    time_of_day = choose_time_of_day(times_of_day)\n",
     "    picker.run(\n",
@@ -115,10 +253,17 @@
     "        user = learn_to_pick.BasedOn(user),\n",
     "        time_of_day = learn_to_pick.BasedOn(time_of_day),\n",
     "    )\n",
+    "\n",
     "    random_picker.run(\n",
     "        article = learn_to_pick.ToSelectFrom(articles),\n",
     "        user = learn_to_pick.BasedOn(user),\n",
     "        time_of_day = learn_to_pick.BasedOn(time_of_day),\n",
+    "    )\n",
+    "\n",
+    "    pytorch_picker.run(\n",
+    "        article = learn_to_pick.ToSelectFrom(articles),\n",
+    "        user = learn_to_pick.BasedOn(user),\n",
+    "        time_of_day = learn_to_pick.BasedOn(time_of_day),\n",
     "    )"
    ]
   },
@@ -131,20 +276,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "The final average score for the default policy, calculated over a rolling window, is: 1.0\n",
-      "The final average score for the random policy, calculated over a rolling window, is: 0.6\n"
+      "The final average score for the default policy, calculated over a rolling window, is: 0.95\n",
+      "The final average score for the default policy, calculated over a rolling window, is: 0.77\n",
+      "The final average score for the random policy, calculated over a rolling window, is: 0.58\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -157,8 +303,11 @@
     "from matplotlib import pyplot as plt\n",
     "picker.metrics.to_pandas()['score'].plot(label=\"vw\")\n",
     "random_picker.metrics.to_pandas()['score'].plot(label=\"random\")\n",
+    "pytorch_picker.metrics.to_pandas()['score'].plot(label=\"pytorch\")\n",
+    "\n",
     "plt.legend()\n",
     "\n",
+    "print(f\"The final average score for the default policy, calculated over a rolling window, is: {pytorch_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n",
     "print(f\"The final average score for the default policy, calculated over a rolling window, is: {picker.metrics.to_pandas()['score'].iloc[-1]}\")\n",
     "print(f\"The final average score for the random policy, calculated over a rolling window, is: {random_picker.metrics.to_pandas()['score'].iloc[-1]}\")\n"
    ]
@@ -180,7 +329,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.5"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,
diff --git a/setup.py b/setup.py
index 880aa4f..c2a8676 100644
--- a/setup.py
+++ b/setup.py
@@ -1,5 +1,4 @@
 from setuptools import setup, find_packages
-import os
 
 with open("README.md", "r", encoding="UTF-8") as fh:
     long_description = fh.read()
diff --git a/src/learn_to_pick/__init__.py b/src/learn_to_pick/__init__.py
index a6894b3..11f0b59 100644
--- a/src/learn_to_pick/__init__.py
+++ b/src/learn_to_pick/__init__.py
@@ -21,6 +21,13 @@
     PickBestSelected,
 )
 
+from learn_to_pick.byom.pytorch_policy import (
+    PyTorchPolicy
+)
+
+from learn_to_pick.byom.pytorch_feature_embedder import (
+    PyTorchFeatureEmbedder
+)
 
 def configure_logger() -> None:
     logger = logging.getLogger(__name__)
@@ -50,6 +57,8 @@ def configure_logger() -> None:
     "Featurizer",
     "ModelRepository",
     "Policy",
+    "PyTorchPolicy",
+    "PyTorchFeatureEmbedder",
     "VwPolicy",
     "VwLogger",
     "embed",
diff --git a/src/learn_to_pick/byom/__init__.py b/src/learn_to_pick/byom/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/learn_to_pick/byom/igw.py b/src/learn_to_pick/byom/igw.py
new file mode 100644
index 0000000..80369a3
--- /dev/null
+++ b/src/learn_to_pick/byom/igw.py
@@ -0,0 +1,16 @@
+import torch
+
+def IGW(fhat, gamma):
+    from math import sqrt
+    fhatahat, ahat = fhat.max(dim=1)
+    A = fhat.shape[1]
+    gamma *= sqrt(A)
+    p = 1 / (A +  gamma * (fhatahat.unsqueeze(1) - fhat))
+    sump = p.sum(dim=1)
+    p[range(p.shape[0]), ahat] += torch.clamp(1 - sump, min=0, max=None)
+    return torch.multinomial(p, num_samples=1).squeeze(1), ahat
+
+def SamplingIGW(A, P, gamma):
+    exploreind, _ = IGW(P, gamma)
+    explore = [ ind for _, ind in zip(A, exploreind) ]
+    return explore
diff --git a/src/learn_to_pick/byom/logistic_regression.py b/src/learn_to_pick/byom/logistic_regression.py
new file mode 100644
index 0000000..e2a8981
--- /dev/null
+++ b/src/learn_to_pick/byom/logistic_regression.py
@@ -0,0 +1,70 @@
+import parameterfree
+import torch
+import torch.nn.functional as F
+
+class MLP(torch.nn.Module):
+    @staticmethod
+    def new_gelu(x):
+        import math
+        return 0.5 * x * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (x + 0.044715 * torch.pow(x, 3.0))))
+
+    def __init__(self, dim):
+        super().__init__()
+        self.c_fc    = torch.nn.Linear(dim, 4 * dim)
+        self.c_proj  = torch.nn.Linear(4 * dim, dim)
+        self.dropout = torch.nn.Dropout(0.5)
+
+    def forward(self, x):
+        x = self.c_fc(x)
+        x = self.new_gelu(x)
+        x = self.c_proj(x)
+        x = self.dropout(x)
+        return x
+
+class Block(torch.nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.layer = MLP(dim)
+
+    def forward(self, x):
+        return x + self.layer(x)
+
+class ResidualLogisticRegressor(torch.nn.Module):
+    def __init__(self, in_features, depth):
+        super().__init__()
+        self._in_features = in_features
+        self._depth = depth
+        self.blocks = torch.nn.Sequential(*[ Block(in_features) for _ in range(depth) ])
+        self.linear  = torch.nn.Linear(in_features=in_features, out_features=1)
+        self.optim = parameterfree.COCOB(self.parameters())
+
+    def clone(self):
+        other = ResidualLogisticRegressor(self._in_features, self._depth)
+        other.load_state_dict(self.state_dict())
+        other.optim = parameterfree.COCOB(other.parameters())
+        other.optim.load_state_dict(self.optim.state_dict())
+        return other
+
+    def forward(self, X, A):
+        return self.logits(X, A)
+
+    def logits(self, X, A):
+        # X = batch x features
+        # A = batch x actionbatch x actionfeatures
+
+        Xreshap = X.unsqueeze(1).expand(-1, A.shape[1], -1)                      # batch x actionbatch x features
+        XA = torch.cat((Xreshap, A), dim=-1).reshape(X.shape[0], A.shape[1], -1) # batch x actionbatch x (features + actionfeatures)
+        return self.linear(self.blocks(XA)).squeeze(2)                           # batch x actionbatch
+
+    def predict(self, X, A):
+        self.eval()
+        return torch.special.expit(self.logits(X, A))
+
+    def bandit_learn(self, X, A, R):
+        self.train()
+        self.optim.zero_grad()
+        output = self(X, A)
+        loss = F.binary_cross_entropy_with_logits(output, R)
+        loss.backward()
+        self.optim.step()
+        return loss.item()
diff --git a/src/learn_to_pick/byom/pytorch_feature_embedder.py b/src/learn_to_pick/byom/pytorch_feature_embedder.py
new file mode 100644
index 0000000..09491ac
--- /dev/null
+++ b/src/learn_to_pick/byom/pytorch_feature_embedder.py
@@ -0,0 +1,87 @@
+import learn_to_pick as rl_chain
+from sentence_transformers import SentenceTransformer
+import torch
+
+class PyTorchFeatureEmbedder(): #rl_chain.Embedder[rl_chain.PickBestEvent]
+    def __init__(
+        self, auto_embed, model = None, *args, **kwargs
+    ):
+        if model is None:
+            model = model = SentenceTransformer('all-MiniLM-L6-v2')
+
+        self.model = model
+        self.auto_embed = auto_embed
+
+    def encode(self, stuff):
+        embeddings = self.model.encode(stuff, convert_to_tensor=True)
+        normalized = torch.nn.functional.normalize(embeddings)
+        return normalized
+
+    def get_label(self, event: rl_chain.PickBestEvent) -> tuple:
+        cost = None
+        if event.selected:
+            chosen_action = event.selected.index
+            cost = (
+                -1.0 * event.selected.score
+                if event.selected.score is not None
+                else None
+            )
+            prob = event.selected.probability
+            return chosen_action, cost, prob
+        else:
+            return None, None, None
+
+    def get_context_and_action_embeddings(self, event: rl_chain.PickBestEvent) -> tuple:
+        context_emb = rl_chain.embed(event.based_on, self) if event.based_on else None
+        to_select_from_var_name, to_select_from = next(
+            iter(event.to_select_from.items()), (None, None)
+        )
+
+        action_embs = (
+            (
+                rl_chain.embed(to_select_from, self, to_select_from_var_name)
+                if event.to_select_from
+                else None
+            )
+            if to_select_from
+            else None
+        )
+
+        if not context_emb or not action_embs:
+            raise ValueError(
+                "Context and to_select_from must be provided in the inputs dictionary"
+            )
+        return context_emb, action_embs
+
+    def format(self, event: rl_chain.PickBestEvent):
+        chosen_action, cost, prob = self.get_label(event)
+        context_emb, action_embs = self.get_context_and_action_embeddings(event)
+
+        context = ""
+        for context_item in context_emb:
+            for ns, based_on in context_item.items():
+                e = " ".join(based_on) if isinstance(based_on, list) else based_on
+                context += f"{ns}={e} "
+
+        if self.auto_embed:
+            context = self.encode([context])
+
+        actions = []
+        for action in action_embs:
+            action_str = ""
+            for ns, action_embedding in action.items():
+                e = (
+                    " ".join(action_embedding)
+                    if isinstance(action_embedding, list)
+                    else action_embedding
+                )
+                action_str += f"{ns}={e} "
+            actions.append(action_str)
+
+        if self.auto_embed:
+            actions = self.encode(actions).unsqueeze(0)
+
+        if cost is None:
+            return context, actions
+        else:
+            return torch.Tensor([[-1.0 * cost]]), context, actions[:,chosen_action,:].unsqueeze(1)
diff --git a/src/learn_to_pick/byom/pytorch_policy.py b/src/learn_to_pick/byom/pytorch_policy.py
new file mode 100644
index 0000000..985f454
--- /dev/null
+++ b/src/learn_to_pick/byom/pytorch_policy.py
@@ -0,0 +1,54 @@
+from learn_to_pick import base, PickBestEvent
+from learn_to_pick.byom.logistic_regression import ResidualLogisticRegressor
+from learn_to_pick.byom.igw import SamplingIGW
+
+class PyTorchPolicy(base.Policy[PickBestEvent]):
+    def __init__(
+        self,
+        feature_embedder,
+        depth: int = 2,
+        device: str = 'cuda',
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.workspace = ResidualLogisticRegressor(feature_embedder.model.get_sentence_embedding_dimension() * 2, depth).to(device)
+        self.feature_embedder = feature_embedder
+        self.device = device
+        self.index = 0
+
+    def predict(self, event):
+        X, A = self.feature_embedder.format(event)
+        # print(f"X shape: {X.shape}")
+        # print(f"A shape: {A.shape}")
+        # TODO IGW sampling then create the distro so that the one
+        # that was sampled here is the one that will def be sampled by
+        # the base sampler, and in the future replace the sampler so that it
+        # is something that can be plugged in
+        p = self.workspace.predict(X, A)
+        # print(f"p: {p}")
+        import math
+        explore = SamplingIGW(A, p, math.sqrt(self.index))
+        self.index += 1
+        # print(f"explore: {explore}")
+        r = []
+        for index in range(p.shape[1]):
+            if index == explore[0]:
+                r.append((index, 1))
+            else:
+                r.append((index, 0))
+        # print(f"returning: {r}")
+        return r
+        return [(index, val) for index, val in enumerate(p[0].tolist())]
+
+    def learn(self, event):
+        R, X, A = self.feature_embedder.format(event)
+        # print(f"R: {R}")
+        R, X, A = R.to(self.device), X.to(self.device), A.to(self.device)
+        self.workspace.bandit_learn(X, A, R)
+
+    def log(self, event):
+        pass
+
+    def save(self) -> None:
+        pass
\ No newline at end of file
diff --git a/src/learn_to_pick/pick_best.py b/src/learn_to_pick/pick_best.py
index dee6e80..e0b53fc 100644
--- a/src/learn_to_pick/pick_best.py
+++ b/src/learn_to_pick/pick_best.py
@@ -325,7 +325,7 @@ def _call_after_scoring_before_learning(
 
     @classmethod
     def create(
-        # cls: Type[PickBest],
+        cls: Type[PickBest],
         policy: Optional[base.Policy] = None,
         llm=None,
         selection_scorer: Union[base.AutoSelectionScorer, object] = SENTINEL,