{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Model Deployment\n",
        "\n",
        "<!--\n",
        "Project: PyTorch Neural Networks\n",
        "Author: RSK World\n",
        "Website: https://rskworld.in\n",
        "Email: help@rskworld.in\n",
        "Phone: +91 93305 39277\n",
        "-->\n",
        "\n",
        "This notebook demonstrates how to save, load, and deploy PyTorch models for inference.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Model Deployment\n",
        "# Project: PyTorch Neural Networks\n",
        "# Author: RSK World\n",
        "# Website: https://rskworld.in\n",
        "# Email: help@rskworld.in\n",
        "# Phone: +91 93305 39277\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import sys\n",
        "import os\n",
        "\n",
        "sys.path.append('..')\n",
        "from models.basic_nn import BasicNeuralNetwork\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Save Model\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Create and train a simple model (or load a pre-trained one)\n",
        "model = BasicNeuralNetwork(input_size=20, hidden_size=64, output_size=3)\n",
        "\n",
        "# Method 1: Save entire model (not recommended for production)\n",
        "torch.save(model, '../saved_models/model_complete.pth')\n",
        "print(\"Complete model saved!\")\n",
        "\n",
        "# Method 2: Save only state dict (recommended)\n",
        "torch.save(model.state_dict(), '../saved_models/model_state_dict.pth')\n",
        "print(\"Model state dict saved!\")\n",
        "\n",
        "# Method 3: Save checkpoint with additional info\n",
        "checkpoint = {\n",
        "    'model_state_dict': model.state_dict(),\n",
        "    'input_size': 20,\n",
        "    'hidden_size': 64,\n",
        "    'output_size': 3\n",
        "}\n",
        "torch.save(checkpoint, '../saved_models/model_checkpoint.pth')\n",
        "print(\"Model checkpoint saved!\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Load Model\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Method 1: Load complete model\n",
        "loaded_model1 = torch.load('../saved_models/model_complete.pth')\n",
        "loaded_model1.eval()\n",
        "print(\"Complete model loaded!\")\n",
        "\n",
        "# Method 2: Load state dict\n",
        "model2 = BasicNeuralNetwork(input_size=20, hidden_size=64, output_size=3)\n",
        "model2.load_state_dict(torch.load('../saved_models/model_state_dict.pth'))\n",
        "model2.eval()\n",
        "print(\"Model from state dict loaded!\")\n",
        "\n",
        "# Method 3: Load from checkpoint\n",
        "checkpoint = torch.load('../saved_models/model_checkpoint.pth')\n",
        "model3 = BasicNeuralNetwork(\n",
        "    input_size=checkpoint['input_size'],\n",
        "    hidden_size=checkpoint['hidden_size'],\n",
        "    output_size=checkpoint['output_size']\n",
        ")\n",
        "model3.load_state_dict(checkpoint['model_state_dict'])\n",
        "model3.eval()\n",
        "print(\"Model from checkpoint loaded!\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Model Inference\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Example inference\n",
        "model.eval()\n",
        "\n",
        "# Create sample input\n",
        "sample_input = torch.randn(1, 20)  # batch_size=1, features=20\n",
        "\n",
        "# Make prediction\n",
        "with torch.no_grad():\n",
        "    output = model(sample_input)\n",
        "    probabilities = torch.softmax(output, dim=1)\n",
        "    predicted_class = torch.argmax(probabilities, dim=1)\n",
        "\n",
        "print(f\"Input shape: {sample_input.shape}\")\n",
        "print(f\"Output shape: {output.shape}\")\n",
        "print(f\"Probabilities: {probabilities}\")\n",
        "print(f\"Predicted class: {predicted_class.item()}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Export to ONNX (Optional)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Export model to ONNX format for deployment\n",
        "# Note: Requires onnx package: pip install onnx\n",
        "\n",
        "try:\n",
        "    import onnx\n",
        "    \n",
        "    # Create dummy input\n",
        "    dummy_input = torch.randn(1, 20)\n",
        "    \n",
        "    # Export to ONNX\n",
        "    onnx_path = '../saved_models/model.onnx'\n",
        "    torch.onnx.export(\n",
        "        model,\n",
        "        dummy_input,\n",
        "        onnx_path,\n",
        "        input_names=['input'],\n",
        "        output_names=['output'],\n",
        "        dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}\n",
        "    )\n",
        "    print(f\"Model exported to ONNX: {onnx_path}\")\n",
        "except ImportError:\n",
        "    print(\"ONNX not installed. Install with: pip install onnx\")\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}