onnx_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# ONNX tutorial with PyTorch"
   ],
   "id": "0",
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Set up the environment and install TurboML's SDK.\n",
    "We use `turboml-installer` to set up the environment for TurboML's SDK."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "!pip install -q turboml-installer\n",
    "import turboml_installer ; turboml_installer.install_on_colab()"
   ],
   "execution_count": null,
   "metadata": {},
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "The kernel should now be restarted with TurboML's SDK installed."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Login to your TurboML instance\n",
    "\n",
    "Note that you can copy and replace this snippet with one from your TurboML homepage."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "import turboml as tb",
    "\ntb.init(backend_url=BACKEND_URL, api_key=API_KEY)"
   ],
   "execution_count": null,
   "id": "1",
   "metadata": {},
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "!pip install onnx==1.14.1"
   ],
   "execution_count": null,
   "id": "2",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "## PyTorch - Standard Model Training\n",
    "\n",
    "The following blocks of code define a standard pytorch dataloader, and model training code. This is completely independent of TurboML. "
   ],
   "id": "3",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "import pandas as pd\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import matplotlib.pyplot as plt\n",
    "import io"
   ],
   "execution_count": null,
   "id": "4",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "transactions = tb.datasets.FraudDetectionDatasetFeatures()\n",
    "labels = tb.datasets.FraudDetectionDatasetLabels()"
   ],
   "execution_count": null,
   "id": "5",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "joined_df = pd.merge(transactions.df, labels.df, on=\"transactionID\", how=\"right\")\n",
    "joined_df"
   ],
   "execution_count": null,
   "id": "6",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "X = joined_df.drop(\"is_fraud\", axis=1)\n",
    "numerical_fields = [\n",
    "    \"transactionAmount\",\n",
    "    \"localHour\",\n",
    "    \"isProxyIP\",\n",
    "    \"digitalItemCount\",\n",
    "    \"physicalItemCount\",\n",
    "]\n",
    "\n",
    "feats = X[numerical_fields]\n",
    "targets = joined_df[\"is_fraud\"].astype(int)"
   ],
   "execution_count": null,
   "id": "7",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class TransactionsDataset(Dataset):\n",
    "    def __init__(self, feats, targets):\n",
    "        self.feats = feats\n",
    "        self.targets = targets\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.feats)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return {\n",
    "            \"x\": torch.tensor(self.feats.iloc[idx], dtype=torch.float),\n",
    "            \"y\": torch.tensor(self.targets.iloc[idx], dtype=torch.float),\n",
    "        }"
   ],
   "execution_count": null,
   "id": "8",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "class NeuralNet(nn.Module):\n",
    "    def __init__(self, input_size):\n",
    "        super(NeuralNet, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_size, 64)\n",
    "        self.fc2 = nn.Linear(64, 64)\n",
    "        self.fc3 = nn.Linear(\n",
    "            64, 2\n",
    "        )  # Output size is 2 for binary classification (fraud or not fraud)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x --> (batch_size, input_size)\n",
    "        x = torch.relu(self.fc1(x))\n",
    "        # x --> (batch_size, 64)\n",
    "        x = torch.relu(self.fc2(x))\n",
    "        # x --> (batch_size, 64)\n",
    "        x = self.fc3(x)\n",
    "        # x --> (batch_size, 2)\n",
    "        return x"
   ],
   "execution_count": null,
   "id": "9",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "model = NeuralNet(input_size=feats.shape[1])\n",
    "model"
   ],
   "execution_count": null,
   "id": "10",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "ds = TransactionsDataset(feats, targets)\n",
    "ds[0]"
   ],
   "execution_count": null,
   "id": "11",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "train_size = int(0.8 * len(ds))\n",
    "test_size = len(ds) - train_size\n",
    "train_dataset, test_dataset = torch.utils.data.random_split(ds, [train_size, test_size])"
   ],
   "execution_count": null,
   "id": "12",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "batch_size = 64\n",
    "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)"
   ],
   "execution_count": null,
   "id": "13",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.001)"
   ],
   "execution_count": null,
   "id": "14",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)\n",
    "num_epochs = 10\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    running_loss = 0.0\n",
    "\n",
    "    for data in train_loader:\n",
    "        inputs = data[\"x\"].float().to(device)\n",
    "        tars = data[\"y\"].long().to(device)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, tars)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "\n",
    "    avg_loss = running_loss / len(train_loader)\n",
    "    print(f\"Epoch {epoch + 1}/{num_epochs}, Loss: {avg_loss:.4f}\")"
   ],
   "execution_count": null,
   "id": "15",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "model.eval()  # Set the model to evaluation mode\n",
    "total_correct = 0\n",
    "total_samples = 0\n",
    "\n",
    "with torch.no_grad():\n",
    "    for data in test_loader:\n",
    "        inputs = data[\"x\"].float()\n",
    "        tars = data[\"y\"].long()\n",
    "        outputs = model(inputs)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total_samples += tars.size(0)\n",
    "        total_correct += (predicted == tars).sum().item()\n",
    "\n",
    "accuracy = total_correct / total_samples\n",
    "print(\"Accuracy:\", accuracy)"
   ],
   "execution_count": null,
   "id": "16",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Export model to ONNX format\n",
    "\n",
    "Exporting a model to ONNX format depends on the framework. Tutorials for different frameworks can be found at https://github.com/onnx/tutorials#converting-to-onnx-format"
   ],
   "id": "17",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "model.eval()\n",
    "sample_input = torch.randn(1, len(numerical_fields))\n",
    "buffer = io.BytesIO()\n",
    "torch.onnx.export(model, sample_input, buffer, export_params=True, verbose=True)\n",
    "onnx_model_string = buffer.getvalue()"
   ],
   "execution_count": null,
   "id": "18",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Create an ONNX model with TurboML\n",
    "\n",
    "Now that we've converted the model to ONNX format, we can deploy it with TurboML. "
   ],
   "id": "19",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "transactions = transactions.to_online(id=\"transactions\", load_if_exists=True)\n",
    "labels = labels.to_online(id=\"transaction_labels\", load_if_exists=True)\n",
    "\n",
    "features = transactions.get_model_inputs(numerical_fields=numerical_fields)\n",
    "label = labels.get_model_labels(label_field=\"is_fraud\")"
   ],
   "execution_count": null,
   "id": "20",
   "metadata": {},
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "tb.set_onnx_model(\"torchmodel\", onnx_model_string)\n",
    "onnx_model = tb.ONNX(model_save_name=\"torchmodel\")"
   ],
   "execution_count": null,
   "id": "21",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "deployed_model = onnx_model.deploy(\"onnx_model_torch\", input=features, labels=label)"
   ],
   "execution_count": null,
   "id": "22",
   "metadata": {
    "tags": []
   },
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "deployed_model.add_metric(\"WindowedAUC\")"
   ],
   "execution_count": null,
   "id": "23",
   "metadata": {},
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "model_auc_scores = deployed_model.get_evaluation(\"WindowedAUC\")\n",
    "plt.plot([model_auc_score.metric for model_auc_score in model_auc_scores])"
   ],
   "execution_count": null,
   "id": "24",
   "metadata": {},
   "outputs": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}