diff --git a/examples/classifier_integration_ex.py b/examples/classifier_integration_ex.py
index 5ebf028d..04cfd5f9 100644
--- a/examples/classifier_integration_ex.py
+++ b/examples/classifier_integration_ex.py
@@ -35,7 +35,7 @@
 fraud_detector = pr.LogicIntegratedClassifier(
     model,
     class_names,
-    identifier="fraud_detector",
+    model_name="fraud_detector",
     interface_options=interface_options
 )
 
diff --git a/examples/image_classifier_example/classifier.ipynb b/examples/image_classifier_example/classifier.ipynb
new file mode 100644
index 00000000..50278f1a
--- /dev/null
+++ b/examples/image_classifier_example/classifier.ipynb
@@ -0,0 +1,622 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Image Classifier with pyreason\n",
+    "Using a modified image classifier from this tutorial: https://www.youtube.com/watch?v=igQeI29FIQM\n",
+    "This creates a CNN using the CIFAR10 Dataset used to classify images into ten different subclasses"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Import dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: torch in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (2.6.0)\n",
+      "Collecting torchvision\n",
+      "  Downloading torchvision-0.21.0-cp39-cp39-macosx_11_0_arm64.whl.metadata (6.1 kB)\n",
+      "Collecting torchsummary\n",
+      "  Downloading torchsummary-1.5.1-py3-none-any.whl.metadata (296 bytes)\n",
+      "Requirement already satisfied: numpy in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (2.0.2)\n",
+      "Requirement already satisfied: matplotlib in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (3.9.4)\n",
+      "Requirement already satisfied: filelock in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torch) (3.18.0)\n",
+      "Requirement already satisfied: typing-extensions>=4.10.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torch) (4.13.1)\n",
+      "Requirement already satisfied: networkx in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torch) (3.2.1)\n",
+      "Requirement already satisfied: jinja2 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torch) (3.1.6)\n",
+      "Requirement already satisfied: fsspec in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torch) (2025.3.2)\n",
+      "Requirement already satisfied: sympy==1.13.1 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torch) (1.13.1)\n",
+      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from sympy==1.13.1->torch) (1.3.0)\n",
+      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from torchvision) (11.1.0)\n",
+      "Requirement already satisfied: contourpy>=1.0.1 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (1.3.0)\n",
+      "Requirement already satisfied: cycler>=0.10 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (0.12.1)\n",
+      "Requirement already satisfied: fonttools>=4.22.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (4.57.0)\n",
+      "Requirement already satisfied: kiwisolver>=1.3.1 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (1.4.7)\n",
+      "Requirement already satisfied: packaging>=20.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (24.2)\n",
+      "Requirement already satisfied: pyparsing>=2.3.1 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (3.2.3)\n",
+      "Requirement already satisfied: python-dateutil>=2.7 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (2.9.0.post0)\n",
+      "Requirement already satisfied: importlib-resources>=3.2.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from matplotlib) (6.5.2)\n",
+      "Requirement already satisfied: zipp>=3.1.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from importlib-resources>=3.2.0->matplotlib) (3.21.0)\n",
+      "Requirement already satisfied: six>=1.5 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /Users/coltonpayne/pyreason/env/lib/python3.9/site-packages (from jinja2->torch) (3.0.2)\n",
+      "Downloading torchvision-0.21.0-cp39-cp39-macosx_11_0_arm64.whl (1.8 MB)\n",
+      "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0ma \u001b[36m0:00:01\u001b[0m\n",
+      "\u001b[?25hDownloading torchsummary-1.5.1-py3-none-any.whl (2.8 kB)\n",
+      "Installing collected packages: torchsummary, torchvision\n",
+      "Successfully installed torchsummary-1.5.1 torchvision-0.21.0\n",
+      "Note: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install torch torchvision torchsummary numpy matplotlib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.optim as optim\n",
+    "import torchvision\n",
+    "import torchvision.transforms as transforms\n",
+    "from torchsummary import summary\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Use GPU instead of CPU if you can"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mps\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = torch.device(\"cpu\")\n",
+    "if torch.cuda.is_available():\n",
+    "    device = torch.device(\"cuda\")\n",
+    "elif torch.backends.mps.is_built() and torch.backends.mps.is_available():\n",
+    "    device = torch.device(\"mps\")\n",
+    "print(device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Download the dataset, transform image data to tensors and normalize the tensors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'DataLoader' object has no attribute 'to'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[15], line 15\u001b[0m\n\u001b[1;32m     12\u001b[0m train_loader \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mutils\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mDataLoader(train_set, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4\u001b[39m, shuffle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m     13\u001b[0m test_loader \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mutils\u001b[38;5;241m.\u001b[39mdata\u001b[38;5;241m.\u001b[39mDataLoader(test_set, batch_size\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m4\u001b[39m,shuffle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m---> 15\u001b[0m \u001b[43mtrain_loader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m(device)\n\u001b[1;32m     16\u001b[0m test_loader\u001b[38;5;241m.\u001b[39mto(device)\n\u001b[1;32m     18\u001b[0m classes \u001b[38;5;241m=\u001b[39m (\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mplane\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcar\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbird\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcat\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdeer\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdog\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfrog\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mhorse\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mship\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtruck\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
+      "\u001b[0;31mAttributeError\u001b[0m: 'DataLoader' object has no attribute 'to'"
+     ]
+    }
+   ],
+   "source": [
+    "transform = transforms.Compose([\n",
+    "    transforms.ToTensor(),\n",
+    "    transforms.Normalize(\n",
+    "        (0.5, 0.5, 0.5),\n",
+    "        (0.5, 0.5, 0.5)\n",
+    "    )\n",
+    "])\n",
+    "\n",
+    "train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
+    "test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)\n",
+    "\n",
+    "train_loader = torch.utils.data.DataLoader(train_set, batch_size=4, shuffle=True)\n",
+    "test_loader = torch.utils.data.DataLoader(test_set, batch_size=4,shuffle=False)\n",
+    "\n",
+    "classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of images in the training dataset: 50000\n",
+      "Number of images in the testing dataset: 10000\n",
+      "Shape of the images in the training dataset: torch.Size([3, 32, 32])\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Number of images in the training dataset:', len(train_set))\n",
+    "print('Number of images in the testing dataset:', len(test_set))\n",
+    "print(f\"Shape of the images in the training dataset: {train_loader.dataset[0][0].shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Print the first 10 images in the dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x300 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 10, figsize=(12, 3))\n",
+    "for i in range(10):\n",
+    "    image = train_loader.dataset[i][0].permute(1, 2, 0)\n",
+    "    denormalized_image= image / 2 + 0.5\n",
+    "    axes[i].imshow(denormalized_image)\n",
+    "    axes[i].set_title(classes[train_loader.dataset[i][1]])\n",
+    "    axes[i].axis('off')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create a convolutional neural network to classify images.  We use two convolution layers, a max pooling layer, and 3 fully connected layers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "ConvNeuralNet(\n",
+       "  (conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1))\n",
+       "  (conv2): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1))\n",
+       "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+       "  (fc1): Linear(in_features=4608, out_features=120, bias=True)\n",
+       "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+       "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+       ")"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "class ConvNeuralNet(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.conv1 = nn.Conv2d(3, 64, 3)\n",
+    "        self.conv2 = nn.Conv2d(64, 128, 3)\n",
+    "\n",
+    "        self.pool = nn.MaxPool2d(2, stride=2)\n",
+    "\n",
+    "        self.fc1 = nn.Linear(128 * 6 * 6, 120)\n",
+    "        self.fc2 = nn.Linear(120, 84)\n",
+    "        self.fc3 = nn.Linear(84, 10)\n",
+    "\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = F.relu(self.conv1(x))\n",
+    "        x = self.pool(x)\n",
+    "        x = F.relu(self.conv2(x))\n",
+    "        x = self.pool(x)\n",
+    "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = F.log_softmax(self.fc3(x), dim=1)\n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "net = ConvNeuralNet()\n",
+    "net.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "----------------------------------------------------------------\n",
+      "        Layer (type)               Output Shape         Param #\n",
+      "================================================================\n",
+      "            Conv2d-1           [-1, 64, 30, 30]           1,792\n",
+      "         MaxPool2d-2           [-1, 64, 15, 15]               0\n",
+      "            Conv2d-3          [-1, 128, 13, 13]          73,856\n",
+      "         MaxPool2d-4            [-1, 128, 6, 6]               0\n",
+      "            Linear-5                  [-1, 120]         553,080\n",
+      "            Linear-6                   [-1, 84]          10,164\n",
+      "            Linear-7                   [-1, 10]             850\n",
+      "================================================================\n",
+      "Total params: 639,742\n",
+      "Trainable params: 639,742\n",
+      "Non-trainable params: 0\n",
+      "----------------------------------------------------------------\n",
+      "Input size (MB): 0.01\n",
+      "Forward/backward pass size (MB): 0.75\n",
+      "Params size (MB): 2.44\n",
+      "Estimated Total Size (MB): 3.20\n",
+      "----------------------------------------------------------------\n"
+     ]
+    }
+   ],
+   "source": [
+    "summary(net.to(device), (3, 32, 32), device=str(device))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Run training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1/10,  2000] loss: 1.757\n",
+      "[1/10,  4000] loss: 1.473\n",
+      "[1/10,  6000] loss: 1.353\n",
+      "[1/10,  8000] loss: 1.291\n",
+      "[1/10, 10000] loss: 1.219\n",
+      "[1/10, 12000] loss: 1.178\n",
+      "[2/10,  2000] loss: 1.093\n",
+      "[2/10,  4000] loss: 1.068\n",
+      "[2/10,  6000] loss: 1.073\n",
+      "[2/10,  8000] loss: 1.044\n",
+      "[2/10, 10000] loss: 1.022\n",
+      "[2/10, 12000] loss: 1.018\n",
+      "[3/10,  2000] loss: 0.904\n",
+      "[3/10,  4000] loss: 0.969\n",
+      "[3/10,  6000] loss: 0.930\n",
+      "[3/10,  8000] loss: 0.941\n",
+      "[3/10, 10000] loss: 0.911\n",
+      "[3/10, 12000] loss: 0.926\n",
+      "[4/10,  2000] loss: 0.831\n",
+      "[4/10,  4000] loss: 0.838\n",
+      "[4/10,  6000] loss: 0.845\n",
+      "[4/10,  8000] loss: 0.825\n",
+      "[4/10, 10000] loss: 0.881\n",
+      "[4/10, 12000] loss: 0.871\n",
+      "[5/10,  2000] loss: 0.766\n",
+      "[5/10,  4000] loss: 0.784\n",
+      "[5/10,  6000] loss: 0.792\n",
+      "[5/10,  8000] loss: 0.782\n",
+      "[5/10, 10000] loss: 0.819\n",
+      "[5/10, 12000] loss: 0.803\n",
+      "[6/10,  2000] loss: 0.710\n",
+      "[6/10,  4000] loss: 0.732\n",
+      "[6/10,  6000] loss: 0.754\n",
+      "[6/10,  8000] loss: 0.762\n",
+      "[6/10, 10000] loss: 0.770\n",
+      "[6/10, 12000] loss: 0.779\n",
+      "[7/10,  2000] loss: 0.679\n",
+      "[7/10,  4000] loss: 0.699\n",
+      "[7/10,  6000] loss: 0.715\n",
+      "[7/10,  8000] loss: 0.709\n",
+      "[7/10, 10000] loss: 0.708\n",
+      "[7/10, 12000] loss: 0.751\n",
+      "[8/10,  2000] loss: 0.631\n",
+      "[8/10,  4000] loss: 0.642\n",
+      "[8/10,  6000] loss: 0.665\n",
+      "[8/10,  8000] loss: 0.704\n",
+      "[8/10, 10000] loss: 0.685\n",
+      "[8/10, 12000] loss: 0.705\n",
+      "[9/10,  2000] loss: 0.613\n",
+      "[9/10,  4000] loss: 0.604\n",
+      "[9/10,  6000] loss: 0.651\n",
+      "[9/10,  8000] loss: 0.642\n",
+      "[9/10, 10000] loss: 0.675\n",
+      "[9/10, 12000] loss: 0.661\n",
+      "[10/10,  2000] loss: 0.576\n",
+      "[10/10,  4000] loss: 0.609\n",
+      "[10/10,  6000] loss: 0.592\n",
+      "[10/10,  8000] loss: 0.628\n",
+      "[10/10, 10000] loss: 0.637\n",
+      "[10/10, 12000] loss: 0.629\n",
+      "Finished Training\n"
+     ]
+    }
+   ],
+   "source": [
+    "loss_function = nn.NLLLoss()\n",
+    "optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
+    "\n",
+    "epochs = 10\n",
+    "for epoch in range(epochs):\n",
+    "\n",
+    "    running_loss = 0.0\n",
+    "    for i, data in enumerate(train_loader):\n",
+    "        inputs, labels = data[0].to(device), data[1].to(device)\n",
+    "\n",
+    "        optimizer.zero_grad()\n",
+    "        outputs = net(inputs)\n",
+    "        loss = loss_function(outputs, labels)\n",
+    "\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        running_loss += loss.item()\n",
+    "        if i % 2000 == 1999:\n",
+    "            print(f'[{epoch + 1}/{epochs}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
+    "            running_loss = 0.0\n",
+    "\n",
+    "print('Finished Training')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "View image classification"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def view_classification(image, probabilities):\n",
+    "    probabilities = probabilities.data.numpy().squeeze()\n",
+    "\n",
+    "    fig, (ax1, ax2) = plt.subplots(figsize=(6,9), ncols=2)\n",
+    "\n",
+    "    image = image.permute(1, 2, 0)\n",
+    "    denormalized_image= image / 2 + 0.5\n",
+    "    ax1.imshow(denormalized_image)\n",
+    "    ax1.axis('off')\n",
+    "    ax2.barh(np.arange(10), probabilities)\n",
+    "    ax2.set_aspect(0.1)\n",
+    "    ax2.set_yticks(np.arange(10))\n",
+    "    ax2.set_yticklabels(classes)\n",
+    "    ax2.set_title('Class Probability')\n",
+    "    ax2.set_xlim(0, 1.1)\n",
+    "    plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x900 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "images, _ = next(iter(test_loader))\n",
+    "\n",
+    "image = images[3]\n",
+    "batched_image = image.unsqueeze(0).to(device)\n",
+    "with torch.no_grad():\n",
+    "    log_probabilities = net(batched_image)\n",
+    "\n",
+    "probabilities = torch.exp(log_probabilities).squeeze().cpu()\n",
+    "view_classification(image, probabilities)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "View accuracy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy of the network on the 10000 test images: 69 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "correct = 0\n",
+    "total = 0\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for data in test_loader:\n",
+    "        images, labels = data[0].to(device), data[1].to(device)\n",
+    "\n",
+    "        outputs = net(images)\n",
+    "\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "\n",
+    "print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now, we will use pyreason to make infrences from our CNN"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyreason as pr\n",
+    "import networkx as nx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define integration options.\n",
+    "# Only probabilities above 0.5 are considered for adjustment.\n",
+    "interface_options = pr.ModelInterfaceOptions(\n",
+    "    threshold=0.5,       # Only process probabilities above 0.5\n",
+    "    set_lower_bound=True,  # For high confidence, adjust the lower bound.\n",
+    "    set_upper_bound=False, # Keep the upper bound unchanged.\n",
+    "    snap_value=1.0      # Use 1.0 as the snap value.\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Wrap the model using LogicIntegratedClassifier\n",
+    "image_classifier = pr.LogicIntegratedClassifier(\n",
+    "    net,\n",
+    "    classes,\n",
+    "    model_name=\"image_classifier\",\n",
+    "    interface_options=interface_options\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "linear(): input and weight.T shapes cannot be multiplied (128x36 and 4608x120)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[63], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m image \u001b[38;5;241m=\u001b[39m train_loader\u001b[38;5;241m.\u001b[39mdataset[i][\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mto(device)  \u001b[38;5;66;03m# Move the image to the same device as the model\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m logits, probabilities, classifier_facts \u001b[38;5;241m=\u001b[39m \u001b[43mimage_classifier\u001b[49m\u001b[43m(\u001b[49m\u001b[43mimage\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/module.py:1739\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1737\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1738\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1739\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/module.py:1750\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1746\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1747\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1748\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1749\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1750\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1752\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1753\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/pyreason/scripts/learning/classification/classifier.py:48\u001b[0m, in \u001b[0;36mLogicIntegratedClassifier.forward\u001b[0;34m(self, x, t1, t2)\u001b[0m\n\u001b[1;32m     40\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, x, t1: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m, t2: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tuple[torch\u001b[38;5;241m.\u001b[39mTensor, torch\u001b[38;5;241m.\u001b[39mTensor, List[Fact]]:\n\u001b[1;32m     41\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     42\u001b[0m \u001b[38;5;124;03m    Forward pass of the model\u001b[39;00m\n\u001b[1;32m     43\u001b[0m \u001b[38;5;124;03m    :param x: Input tensor\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[38;5;124;03m    :return: Output tensor\u001b[39;00m\n\u001b[1;32m     47\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m---> 48\u001b[0m     output \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     50\u001b[0m     \u001b[38;5;66;03m# Convert logits to probabilities assuming a multi-class classification.\u001b[39;00m\n\u001b[1;32m     51\u001b[0m     probabilities \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39msoftmax(output, dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39msqueeze()\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/module.py:1739\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1737\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1738\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1739\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/module.py:1750\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1746\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1747\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1748\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1749\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1750\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1752\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1753\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "Cell \u001b[0;32mIn[36], line 21\u001b[0m, in \u001b[0;36mConvNeuralNet.forward\u001b[0;34m(self, x)\u001b[0m\n\u001b[1;32m     19\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpool(x)\n\u001b[1;32m     20\u001b[0m x \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mflatten(x, \u001b[38;5;241m1\u001b[39m) \u001b[38;5;66;03m# flatten all dimensions except batch\u001b[39;00m\n\u001b[0;32m---> 21\u001b[0m x \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39mrelu(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfc1\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m     22\u001b[0m x \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39mrelu(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfc2(x))\n\u001b[1;32m     23\u001b[0m x \u001b[38;5;241m=\u001b[39m F\u001b[38;5;241m.\u001b[39mlog_softmax(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfc3(x), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/module.py:1739\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1737\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)  \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m   1738\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1739\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/module.py:1750\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1745\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m   1746\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m   1747\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m   1748\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m   1749\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1750\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1752\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m   1753\u001b[0m called_always_called_hooks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m()\n",
+      "File \u001b[0;32m~/pyreason/env/lib/python3.9/site-packages/torch/nn/modules/linear.py:125\u001b[0m, in \u001b[0;36mLinear.forward\u001b[0;34m(self, input)\u001b[0m\n\u001b[1;32m    124\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mforward\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;28minput\u001b[39m: Tensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Tensor:\n\u001b[0;32m--> 125\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mF\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mlinear\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mweight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbias\u001b[49m\u001b[43m)\u001b[49m\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: linear(): input and weight.T shapes cannot be multiplied (128x36 and 4608x120)"
+     ]
+    }
+   ],
+   "source": [
+    "image = train_loader.dataset[i][0].to(device)  # Move the image to the same device as the model\n",
+    "logits, probabilities, classifier_facts = image_classifier(image)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/image_classifier_two/image_classifier_test.py b/examples/image_classifier_two/image_classifier_test.py
new file mode 100644
index 00000000..657ff1d9
--- /dev/null
+++ b/examples/image_classifier_two/image_classifier_test.py
@@ -0,0 +1,83 @@
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import torch
+import pyreason as pr
+import networkx as nx
+import torch.nn.functional as F
+
+# Step 1: Load a pre-trained model and image processor from Hugging Face
+model_name = "google/vit-base-patch16-224"  # Vision Transformer model
+processor = AutoImageProcessor.from_pretrained(model_name)
+model = AutoModelForImageClassification.from_pretrained(model_name)
+
+# Step 2: Load and preprocess an image
+image_path = "/Users/coltonpayne/pyreason/examples/image_classifier_two/goldfish.jpeg"
+image = Image.open(image_path)
+
+inputs = processor(images=image, return_tensors="pt")
+
+# Step 3: Run the image through the model
+with torch.no_grad():
+    outputs = model(**inputs)
+
+# Step 4: Get the logits and apply softmax
+logits = outputs.logits
+probs = F.softmax(logits, dim=-1)
+
+# --- NEW SECTION: Restrict predictions to a subset of labels ---
+# Define your allowed labels
+allowed_labels = ['goldfish', 'tiger shark', 'hammerhead', 'great white shark', 'tench']
+
+# Get the index-to-label mapping from the model config
+id2label = model.config.id2label
+
+# Get the indices of the allowed labels
+# Get the indices of the allowed labels, stripping everything after the comma
+allowed_indices = [
+    i for i, label in id2label.items()
+    if label.split(",")[0].strip().lower() in [name.lower() for name in allowed_labels]
+]
+
+
+# Filter and re-normalize probabilities
+filtered_probs = torch.zeros_like(probs)
+filtered_probs[0, allowed_indices] = probs[0, allowed_indices]
+filtered_probs = filtered_probs / filtered_probs.sum()
+
+# Get top prediction among allowed labels
+top_idx = filtered_probs.argmax(-1).item()
+top_label = id2label[top_idx].split(",")[0]
+top_prob = filtered_probs[0, top_idx].item()
+
+print(f"\nTop prediction (filtered): {top_label} ({top_prob:.4f})")
+
+# Optional: print top N from the filtered subset
+top_probs, top_indices = filtered_probs.topk(5)
+print("\nTop predictions from allowed subset:")
+for prob, idx in zip(top_probs[0], top_indices[0]):
+    label = id2label[idx.item()].split(",")[0]
+    print(f"{label}: {prob.item():.4f}")
+
+
+interface_options = pr.ModelInterfaceOptions(
+    threshold=0.5,       # Only process probabilities above 0.5
+    set_lower_bound=True,  # For high confidence, adjust the lower bound.
+    set_upper_bound=False, # Keep the upper bound unchanged.
+    snap_value=1.0      # Use 1.0 as the snap value.
+)
+
+fish_classifier = pr.LogicIntegratedClassifier(
+    model,
+    allowed_labels,
+    model_name="fish_classifier",
+    interface_options=interface_options
+)
+
+logits, probabilities, classifier_facts = fish_classifier(image)
+
+print("=== Fish Classifier Output ===")
+print("Logits:", logits)
+print("Probabilities:", probabilities)
+print("\nGenerated Classifier Facts:")
+for fact in classifier_facts:
+    print(fact)
diff --git a/examples/image_classifier_two/images/fish_1.jpeg b/examples/image_classifier_two/images/fish_1.jpeg
new file mode 100644
index 00000000..6413569e
Binary files /dev/null and b/examples/image_classifier_two/images/fish_1.jpeg differ
diff --git a/examples/image_classifier_two/images/fish_2.jpeg b/examples/image_classifier_two/images/fish_2.jpeg
new file mode 100644
index 00000000..581f1b17
Binary files /dev/null and b/examples/image_classifier_two/images/fish_2.jpeg differ
diff --git a/examples/image_classifier_two/images/shark_1.jpeg b/examples/image_classifier_two/images/shark_1.jpeg
new file mode 100644
index 00000000..e7ebb18f
Binary files /dev/null and b/examples/image_classifier_two/images/shark_1.jpeg differ
diff --git a/examples/image_classifier_two/images/shark_2.jpeg b/examples/image_classifier_two/images/shark_2.jpeg
new file mode 100644
index 00000000..037c53dd
Binary files /dev/null and b/examples/image_classifier_two/images/shark_2.jpeg differ
diff --git a/examples/image_classifier_two/images/shark_3.jpeg b/examples/image_classifier_two/images/shark_3.jpeg
new file mode 100644
index 00000000..640d01f2
Binary files /dev/null and b/examples/image_classifier_two/images/shark_3.jpeg differ
diff --git a/football_project/football_classes.py b/football_project/football_classes.py
new file mode 100644
index 00000000..13ffbd6a
--- /dev/null
+++ b/football_project/football_classes.py
@@ -0,0 +1,80 @@
+import enum
+import math
+
+# This graph will determine which free agents a team can sign based on their available cap space 
+# and which players they should sign based on their needs and other player factors
+
+class LeagueRules(enum.Enum):  # Fixed the base class
+    POSTION_LIST = ["QB", "RB", "WR", "TE"]
+    MIN_PLAYER_AT_POSITION = {
+            "QB": 1,
+            "RB": 1,
+            "WR": 2,
+            "TE": 1,
+        }
+    SALARY_CAP = 2000000
+
+class FootballPlayer:
+    def __init__(self, name, position, expected_salary, madden_rating, available=True):
+        self.name = name
+        self.position = position
+        self.expected_salary = expected_salary
+        self.madden_rating = madden_rating
+        self.available = available
+        self.player_value = (self.madden_rating / self.expected_salary) * 100000
+    
+    def get_availability(self):
+        return self.available
+    
+class FootballTeam:
+    def __init__(self, team_name):
+        self.team_name = team_name
+        self.roster = {}
+        for position in LeagueRules.POSTION_LIST.value:
+            self.roster[position] = []
+        self.cap_space = LeagueRules.SALARY_CAP.value
+    
+    def can_sign_player(self, player):
+        if player.expected_salary <= self.cap_space and player.get_availability():
+            return True
+        return False
+    
+    # A team wants to sign a player if the player can provide more value than the lowest value player at thier position
+    def check_if_team_wants_players(self, player):
+        lowest_rostered_value_at_pos = self.get_lowest_value_at_position(player.position)
+        if player.player_value > lowest_rostered_value_at_pos:
+            # print(f"Team {self.team_name} wants player {player.name} with value {player.player_value}. Lowest value is {lowest_rostered_value_at_pos}.")
+            return True
+        return False
+
+    def get_lowest_value_at_position(self, position):
+        min_value = math.inf
+        for player in self.roster[position]:
+            if player.player_value < min_value:
+                min_value = player.player_value
+        
+        return min_value
+    
+    def sign_player(self, player):
+        if self.can_sign_player(player):
+            #self.roster.append(player)
+            self.roster[player.position].append(player)
+            self.cap_space -= player.expected_salary
+            player.available = False
+            return True
+        return False
+    
+    def get_available_players(self):
+        return [player for player in self.roster if player.get_availability()]
+    
+    def get_cap_space(self):
+        return self.cap_space
+    
+    def get_num_player_needed(self, position):
+        current_qbs = [player for player in self.roster[position]]
+        num_players_needed = LeagueRules.MIN_PLAYER_AT_POSITION.value[position] - len(current_qbs)
+        return num_players_needed
+    
+    def get_remaining_cap_space(self):
+        total_salary = sum(player.expected_salary for player in self.roster)
+        return self.cap_space - total_salary
\ No newline at end of file
diff --git a/football_project/player_signings.py b/football_project/player_signings.py
new file mode 100644
index 00000000..c15f757c
--- /dev/null
+++ b/football_project/player_signings.py
@@ -0,0 +1,221 @@
+import numba
+import pyreason as pr
+import networkx as nx
+import football_classes as fc
+import random
+from pprint import pprint
+import matplotlib.pyplot as plt # type: ignore
+
+# Generates random names
+import names
+
+def generate_random_player_at_position(position):
+    full_name = names.get_full_name()
+    name_with_underscore = full_name.replace(" ", "_")
+    return fc.FootballPlayer(
+        name=name_with_underscore,
+        position=position,
+        expected_salary=random.randint(100000, 500000),
+        madden_rating=random.randint(60, 99),
+    )
+
+def add_rostered_fact(team, player):
+    fact_string = f"rostered({team.team_name} , {player.name})"
+    pr.add_fact(pr.Fact(fact_string, 'rostered_fact', 0, 1))
+
+def add_not_rostered_fact(team, player):
+    fact_string = f"~rostered({team.team_name} , {player.name})"
+    pr.add_fact(pr.Fact(fact_string, 'rostered_fact', 0, 1))
+
+def try_to_sign_player(team, player):
+    if team.can_sign_player(player):
+        team.sign_player(player)
+        add_rostered_fact(team, player)
+        print(f"{team.team_name} signed {player.name} for ${player.expected_salary}")
+    else:
+        add_not_rostered_fact(team, player)
+
+# Operating at timestep 1 
+def add_interested_fact(team, player):
+    fact_string = f"interested({team.team_name} , {player.name})"
+    pr.add_fact(pr.Fact(fact_string, 'interested_fact', 0, 1))
+
+def add_not_interested_fact(team, player):
+    fact_string = f"~interested({team.team_name} , {player.name})"
+    pr.add_fact(pr.Fact(fact_string, 'interested_fact', 0, 1))
+
+def determine_team_interest():
+    for team in team_list:
+        for player in all_player_list:
+            if team.check_if_team_wants_players(player):
+                add_interested_fact(team, player)
+            else:
+                add_not_interested_fact(team, player)
+
+def simulate_draft():
+    # print("Available Players:")
+    # for player in all_players:
+    #     print(f"Name: {player.name}, Position: {player.position}, "
+    #           f"Expected Salary: ${player.expected_salary:,}, Madden Rating: {player.madden_rating}")
+    for team in team_list:
+        # Loop through the available players and try to sign them
+        for player in qb_list:
+            if team.get_num_player_needed("QB") > 0:
+                try_to_sign_player(team, player)
+            else:
+                add_not_rostered_fact(team, player)
+        for player in rb_list:
+            if team.get_num_player_needed("RB") > 0:
+                try_to_sign_player(team, player)
+            else:
+                add_not_rostered_fact(team, player)
+        for player in wr_list:
+            if team.get_num_player_needed("WR") > 0:
+                try_to_sign_player(team, player)
+            else:
+                add_not_rostered_fact(team, player)
+        for player in te_list:
+            if team.get_num_player_needed("TE") > 0:
+                try_to_sign_player(team, player)
+            else:
+                add_not_rostered_fact(team, player)
+
+    # Print the final rosters and cap space for each team
+    print("\nFinal Rosters and Cap Space:")
+    for team in team_list:
+        print(f"\n{team.team_name} Roster:")
+        for position, players in team.roster.items():
+            for player in players:
+                print(f"  Name: {player.name}, Position: {player.position}, Value: {player.player_value}")
+        print(f"Cap Space Remaining: ${team.get_cap_space():,}")
+
+
+qb_list = []
+rb_list = []
+wr_list = []
+te_list = []
+all_player_list = []
+
+for val in range(20):
+    qb_list.append(generate_random_player_at_position("QB"))
+    rb_list.append(generate_random_player_at_position("RB"))
+    wr_list.append(generate_random_player_at_position("WR"))
+    te_list.append(generate_random_player_at_position("TE"))
+
+all_player_list.extend(qb_list)
+all_player_list.extend(rb_list)
+all_player_list.extend(wr_list)
+all_player_list.extend(te_list)
+
+team_list = []
+team_list.append(fc.FootballTeam("Pittsburgh_Steelers"))
+team_list.append(fc.FootballTeam("Baltamore_Ravens"))
+team_list.append(fc.FootballTeam("Dallas_Cowboys"))
+team_list.append(fc.FootballTeam("Chicago_Bears"))
+
+
+
+# Create a Directed graph
+g = nx.DiGraph()
+
+for player in all_player_list:
+    g.add_node(player.name, name=player.name, position=player.position, expected_salary=player.expected_salary, madden_rating=player.madden_rating, player_value=player.player_value)
+for team in team_list:
+    g.add_node(team.team_name)
+
+# Make a picture of the graph
+# nx.draw(g, with_labels=True)
+# plt.savefig("football_graph.png")
+# plt.show()
+
+pr.settings.verbose = True     # Print info to screen
+pr.settings.atom_trace = True  # Print the trace of the atoms
+
+# Load all the files into pyreason
+pr.load_graph(g)
+
+
+@numba.njit
+def demanded_player_annotation_fn(annotations, weights):
+    """
+    Calculate the value of a player based on their attributes.
+    """
+    # Calculate the value based on the weights
+    # print("Annotations: ", annotations)
+    # print("Annotations[0]: ", annotations[0])
+    num_interested_teams = len(annotations[0])
+    print("Interested Teams: ", num_interested_teams)
+    if num_interested_teams > 3:
+        upper_bound = 1
+        lower_bound = 1
+    else:
+        upper_bound = 0
+        lower_bound = 0
+    return lower_bound, upper_bound
+
+pr.add_annotation_function(demanded_player_annotation_fn)
+
+# These functions add facts about the players based on how they are drafted and the teams that want them
+simulate_draft()
+determine_team_interest()
+
+# Rule to check if a player is a free agent
+pr.add_rule(pr.Rule('rostered_player(x) <-1 rostered(y, x)', 'rostered_player_rule'))
+pr.add_rule(pr.Rule('free_agent(x) <-1 ~rostered(y,x)', 'free_agent_rule'))
+pr.add_rule(pr.Rule('make_offer(y,x) <-1 free_agent(x), interested(y,x)', 'make_offer_rule'))
+pr.add_rule(pr.Rule('demanded_player(x) : demanded_player_annotation_fn <-1 make_offer(a,x)', 'demanded_player(x)'))
+pr.add_rule(pr.Rule('highly_demanded_player(x) <-1 demanded_player(x): [1,1]', 'highly_demanded_player_rule'))
+
+#pr.add_rule(pr.Rule('team_interested_in_player(x, y) <-1 '))
+
+interpretation = pr.reason(timesteps=4)
+interpretation_dict = interpretation.get_dict()
+# print("Interpretation Dictionary:")
+# pprint(interpretation_dict)
+
+# Display the changes in the interpretation for each timestep
+print("========================== Rostered Players ==========================")
+rostered_player_df = pr.filter_and_sort_nodes(interpretation, ['rostered_player'])
+for t, df in enumerate(rostered_player_df):
+    print(f'TIMESTEP - {t}')
+    print(df)
+    print()
+
+print("========================== Free Agents ==========================")
+free_agent_df = pr.filter_and_sort_nodes(interpretation, ['free_agent'])
+for t, df in enumerate(free_agent_df):
+    print(f'TIMESTEP - {t}')
+    print(df)
+    print()
+
+
+print("========================== Team offers ==========================")
+team_offer_df = pr.filter_and_sort_edges(interpretation, ['make_offer'])
+for t, df in enumerate(team_offer_df):
+    print(f'TIMESTEP - {t}')
+    print(df)
+    print()
+
+print("========================== Demanded Player ==========================")
+team_offer_df = pr.filter_and_sort_nodes(interpretation, ['demanded_player'])
+for t, df in enumerate(team_offer_df):
+    print(f'TIMESTEP - {t}')
+    print(df)
+    print()
+
+print("========================== Hot Commodities ==========================")
+hot_commodity_df = pr.filter_and_sort_nodes(interpretation, ['highly_demanded_player'])
+for t, df in enumerate(hot_commodity_df):
+    print(f'TIMESTEP - {t}')
+    print(df)
+    for index, row in df.iterrows():
+        node_name = row['component']
+        player_value = g.nodes[node_name]["player_value"]
+        madden_rating = g.nodes[node_name]["madden_rating"]
+        expected_salary = g.nodes[node_name]["expected_salary"]
+        print(f"Node: {node_name}, Salary: {expected_salary}, Madden Rating: {madden_rating}, Value: {player_value}")
+
+
+# Iterate over the "component" column in hot_commodity_df and print everything we know about the corresponding node
+
+pr.save_rule_trace(interpretation)
diff --git a/pyreason/.cache_status.yaml b/pyreason/.cache_status.yaml
index 32458f5d..71173842 100644
--- a/pyreason/.cache_status.yaml
+++ b/pyreason/.cache_status.yaml
@@ -1 +1 @@
-initialized: false
+initialized: true
diff --git a/pyreason/scripts/learning/classification/classifier.py b/pyreason/scripts/learning/classification/classifier.py
index 06bc3ec9..f972f41a 100644
--- a/pyreason/scripts/learning/classification/classifier.py
+++ b/pyreason/scripts/learning/classification/classifier.py
@@ -39,7 +39,7 @@ def get_class_facts(self, t1: int, t2: int) -> List[Fact]:
             facts.append(fact)
         return facts
 
-    def forward(self, x, t1: int = 0, t2: int = 0) -> Tuple[torch.Tensor, torch.Tensor, List[Fact]]:
+    def forward(self, x, t1: int = 0, t2: int = 0, limit_classification_output_classes = False) -> Tuple[torch.Tensor, torch.Tensor, List[Fact]]:
         """
         Forward pass of the model
         :param x: Input tensor
@@ -47,10 +47,47 @@ def forward(self, x, t1: int = 0, t2: int = 0) -> Tuple[torch.Tensor, torch.Tens
         :param t2: End time for the facts
         :return: Output tensor
         """
-        output = self.model(x)
 
-        # Convert logits to probabilities assuming a multi-class classification.
+        try:
+            output = self.model(x)
+        except AttributeError as e:
+            print(f"Error during model forward pass: {e}")
+            try:
+                output = self.model(**x).logits
+            except Exception as e:
+                print(f"Error during model forward pass with kwargs: {e}")
+
         probabilities = F.softmax(output, dim=1).squeeze()
+
+        # A user may want to restrict the number of classe so that the classifier only returns facts for a subset of classes.  
+        # This is useful for large models like CLIP, where the model has 4000 classes. 
+        # If we only want to reason on a small number of these, it is useful to limit the output classes.
+        if limit_classification_output_classes:
+            # Get the index-to-label mapping from the model config
+            id2label = self.model.config.id2label
+
+            # Get the indices of the allowed labels, stripping everything after the comma
+            allowed_indices = [
+                i for i, label in id2label.items()
+                if label.split(",")[0].strip().lower() in [name.lower() for name in self.class_names]
+            ]
+
+            # Normalize the probabilities based only on the allowed classes
+            filtered_probs = torch.zeros_like(probabilities)
+            filtered_probs[allowed_indices] = probabilities[allowed_indices]
+            filtered_probs = filtered_probs / filtered_probs.sum()
+
+            # Because we are filtering the probabilities, we need to update the class names to only include the allowed classes.
+            top_labels = []
+            top_probs, top_indices = filtered_probs.topk(len(self.class_names))
+            for prob, idx in zip(top_probs, top_indices):
+                label = id2label[idx.item()].split(",")[0]
+                print(f"{label}: {prob.item():.4f}")
+                top_labels.append(label)
+            self.class_names = top_labels
+            probabilities = top_probs
+            
+        print("Probabilities:", probabilities)
         opts = self.interface_options
 
         # Prepare threshold tensor.
@@ -89,3 +126,5 @@ def forward(self, x, t1: int = 0, t2: int = 0) -> Tuple[torch.Tensor, torch.Tens
             facts.append(fact)
         return output, probabilities, facts
 
+
+
diff --git a/pyreason/tests/test_classifier.py b/pyreason/tests/test_classifier.py
new file mode 100644
index 00000000..21a0ca99
--- /dev/null
+++ b/pyreason/tests/test_classifier.py
@@ -0,0 +1,104 @@
+# import the logicIntegratedClassifier class
+
+import torch
+import torch.nn as nn
+import networkx as nx
+import numpy as np
+import random
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+from pyreason.scripts.learning.classification.classifier import LogicIntegratedClassifier
+from pyreason.scripts.facts.fact import Fact
+from pyreason.scripts.learning.utils.model_interface import ModelInterfaceOptions
+from pyreason.scripts.rules.rule import Rule
+from pyreason.pyreason import _Settings as Settings, reason, reset_settings, get_rule_trace, add_fact, add_rule, load_graph
+
+# seed_value = 41
+seed_value = 42
+random.seed(seed_value)
+np.random.seed(seed_value)
+torch.manual_seed(seed_value)
+
+
+# --- Part 1: Fraud Detector Model Integration ---
+
+# Create a dummy PyTorch model for transaction fraud detection.
+# Each transaction is represented by 5 features and is classified into "fraud" or "legitimate".
+model = nn.Linear(5, 2)
+class_names = ["fraud", "legitimate"]
+
+# Create a dummy transaction feature vector.
+transaction_features = torch.rand(1, 5)
+
+# Define integration options
+# Only probabilities above 0.5 are considered for adjustment.
+interface_options = ModelInterfaceOptions(
+    threshold=0.5,         # Only process probabilities above 0.5
+    set_lower_bound=True,  # For high confidence, adjust the lower bound.
+    set_upper_bound=False, # Keep the upper bound unchanged.
+    snap_value=1.0         # Use 1.0 as the snap value.
+)
+
+# Wrap the model using LogicIntegratedClassifier
+fraud_detector = LogicIntegratedClassifier(
+    model,
+    class_names,
+    identifier="fraud_detector",
+    interface_options=interface_options
+)
+
+# Run the model to obtain logits, probabilities, and generated PyReason facts.
+logits, probabilities, classifier_facts = fraud_detector(transaction_features)
+
+print("=== Fraud Detector Output ===")
+print("Logits:", logits)
+print("Probabilities:", probabilities)
+print("\nGenerated Classifier Facts:")
+for fact in classifier_facts:
+    print(fact)
+
+# Add the classifier-generated facts.
+for fact in classifier_facts:
+    add_fact(fact)
+
+# --- Part 2: Create and Load a Networkx Graph representing an account knowledge base ---
+
+# Create a networkx graph representing a network of accounts.
+G = nx.DiGraph()
+# Add account nodes.
+G.add_node("AccountA", account=1)
+G.add_node("AccountB", account=1)
+G.add_node("AccountC", account=1)
+# Add edges with an attribute "relationship" set to "associated".
+G.add_edge("AccountA", "AccountB", associated=1)
+G.add_edge("AccountB", "AccountC", associated=1)
+load_graph(G)
+
+# --- Part 3: Set Up Context and Reasoning Environment ---
+
+# Add additional contextual information:
+# 1. A fact indicating the transaction comes from a suspicious location. This could come from a separate fraud detection system.
+add_fact(Fact("suspicious_location(AccountA)", "transaction_fact"))
+
+# Define a rule: if the fraud detector flags a transaction as fraud and the transaction info is suspicious,
+# then mark the associated account (AccountA) as requiring investigation.
+add_rule(Rule("requires_investigation(acc) <- account(acc), fraud(fraud_detector), suspicious_location(acc)", "investigation_rule"))
+
+# Define a propagation rule:
+# If an account requires investigation and is connected (via the "associated" relationship) to another account,
+# then the connected account is also flagged for investigation.
+add_rule(Rule("requires_investigation(y) <- requires_investigation(x), associated(x,y)", "propagation_rule"))
+
+# --- Part 4: Run the Reasoning Engine ---
+
+# Reset settings before running reasoning
+reset_settings()
+
+# Run the reasoning engine to allow the investigation flag to propagate through the network.
+Settings.atom_trace = True
+interpretation = reason()
+
+trace = get_rule_trace(interpretation)
+print(f"RULE TRACE: \n\n{trace[0]}\n")
diff --git a/pyreason/tests/test_image_classifier.py b/pyreason/tests/test_image_classifier.py
new file mode 100644
index 00000000..080c8ff9
--- /dev/null
+++ b/pyreason/tests/test_image_classifier.py
@@ -0,0 +1,118 @@
+# import the logicIntegratedClassifier class
+
+from pathlib import Path
+import torch
+import torch.nn as nn
+import networkx as nx
+import numpy as np
+import random
+import sys
+import os
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import torch.nn.functional as F
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
+
+from pyreason.scripts.learning.classification.classifier import LogicIntegratedClassifier
+from pyreason.scripts.facts.fact import Fact
+from pyreason.scripts.learning.utils.model_interface import ModelInterfaceOptions
+from pyreason.scripts.rules.rule import Rule
+from pyreason.pyreason import _Settings as Settings, reason, reset_settings, get_rule_trace, add_fact, add_rule, load_graph, save_rule_trace
+
+
+# Step 1: Load a pre-trained model and image processor from Hugging Face
+model_name = "google/vit-base-patch16-224"  # Vision Transformer model
+processor = AutoImageProcessor.from_pretrained(model_name)
+model = AutoModelForImageClassification.from_pretrained(model_name)
+
+G = nx.DiGraph()
+## Make a complete graph between all the nodes
+load_graph(G)
+
+# Step 2: Load and preprocess images from the directory
+image_dir = "/Users/coltonpayne/pyreason/examples/image_classifier_two/images"
+image_paths = list(Path(image_dir).glob("*.jpeg"))  # Get all .jpeg files in the directory
+image_list = []
+allowed_labels = ['goldfish', 'tiger shark', 'hammerhead', 'great white shark', 'tench']
+
+# Get the index-to-label mapping from the model config
+id2label = model.config.id2label
+
+# Get the indices of the allowed labels, stripping everything after the comma
+allowed_indices = [
+    i for i, label in id2label.items()
+    if label.split(",")[0].strip().lower() in [name.lower() for name in allowed_labels]
+]
+
+# Add Rules to the knowlege base
+add_rule(Rule("is_fish(x) <-0 goldfish(x)", "is_fish_rule"))
+add_rule(Rule("is_fish(x) <-0 tench(x)", "is_fish_rule"))
+add_rule(Rule("is_shark(x) <-0 tigershark(x)", "is_shark_rule"))
+add_rule(Rule("is_shark(x) <-0 hammerhead(x)", "is_shark_rule"))
+add_rule(Rule("is_shark(x) <-0 greatwhiteshark(x)", "is_shark_rule"))
+add_rule(Rule("is_scary(x) <-0 is_shark(x)", "is_scary_rule"))
+add_rule(Rule("likes_to_eat(y,x) <-0 is_shark(y), is_fish(x)", "likes_to_eat_rule"))
+
+
+
+for image_path in image_paths:
+    print(f"Processing Image: {image_path.name}")
+    image = Image.open(image_path)
+    inputs = processor(images=image, return_tensors="pt")
+
+    interface_options = ModelInterfaceOptions(
+        threshold=0.5,       # Only process probabilities above 0.5
+        set_lower_bound=True,  # For high confidence, adjust the lower bound.
+        set_upper_bound=False, # Keep the upper bound unchanged.
+        snap_value=1.0      # Use 1.0 as the snap value.
+    )
+
+
+    classifier_name = image_path.name.split(".")[0]
+    # We use dynamic variable names to create a unique classifier for each image
+    # There's a better way to do this probably
+    globals()[classifier_name] = LogicIntegratedClassifier(
+        model,
+        allowed_labels,
+        identifier=classifier_name,
+        interface_options=interface_options
+    )
+
+    # print("Top Probs: ", filtered_probs)
+    logits, probabilities, classifier_facts = globals()[classifier_name](inputs, limit_classification_output_classes=True)
+    #logits, probabilities, classifier_facts = fish_classifier(inputs, output=logits, probabilities=top_probs)
+    #logits, probabilities, classifier_facts = fish_classifier(inputs)
+    #logits, probabilities, classifier_facts = fish_classifier(**inputs)
+
+    print("=== Fish Classifier Output ===")
+    #print("Probabilities:", probabilities)
+    print("\nGenerated Classifier Facts:")
+    for fact in classifier_facts:
+        print(fact)
+
+    for fact in classifier_facts:
+        add_fact(fact)
+
+    print("Done processing image ", image_path.name)
+
+# --- Part 4: Run the Reasoning Engine ---
+
+# Reset settings before running reasoning
+reset_settings()
+
+# Run the reasoning engine to allow the investigation flag to propagate hat through the network.
+Settings.atom_trace = True
+interpretation = reason()
+
+trace = get_rule_trace(interpretation)
+print(f"RULE TRACE: \n\n{trace[0]}\n")
+
+
+# First, make the knowlege base with all the hardcoded rules
+# Get the inputs, turn the images into FACTS in pyreason.  This completes our knowlege base
+# Then, run the inferences
+
+# TODO:
+# Re-write with non-grounded rules
+# Try to make a more general version of the LogicIntegratedClassifier that can load in a huggingface model and a set of classes
+# Ask Dyuman about how to connect all the edges of a graph within the LogicIntegratedClassifier
\ No newline at end of file