demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ParamLogger\n",
    "ParamLogger is a library that helps you log inputs and outputs of any method, just by providing a decorator over that method.\n",
    "\n",
    "Here we demonstarte with example all the utility methods and decorator that library provides."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "from paramlogger import ParamLogger\n",
    "\n",
    "log_dir = \"\" # Path to directory where you want to store all log files\n",
    "paramlog = ParamLogger(base_path=log_dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1) log_io_params_for_method decorator\n",
    "\n",
    "Executes the method. After executing, logs the inputs and outputs of that method to jsonl file. Name of jsonl file would be the method name."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "@paramlog.log_io_params_for_method\n",
    "def compute_addition(operand1, operand2):\n",
    "    return operand1 + operand2\n",
    "\n",
    "for i in range(10):\n",
    "    compute_addition(i,10*i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2) log_io_params decorator\n",
    "Executes the method. After executing, logs the inputs and outputs of that method to jsonl file named \"io_logs.jsonl\". Here, inputs/outputs of different methods gets saved in the same file."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "@paramlog.log_io_params\n",
    "def compute_addition(operand1, operand2):\n",
    "    return operand1 + operand2\n",
    "\n",
    "@paramlog.log_io_params\n",
    "def compute_subtraction(operand1, operand2):\n",
    "    return operand2 - operand1\n",
    "\n",
    "@paramlog.log_io_params\n",
    "def compute_multiplication(operand1, operand2):\n",
    "    return operand2 * operand1\n",
    "\n",
    "for i in range(1, 10):\n",
    "    result1 = compute_addition(i,10*i)\n",
    "    result2 = compute_subtraction(result1, i)\n",
    "    result3 = compute_multiplication(result2, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3) append_to_chained_log decorator\n",
    "In `log_io_params` and `log_io_params_for_method` decorators, saving the inputs/optputs to file happens after every method call. This can increase the latency of  your program due to frequent file operations. This can be avoided via `append_to_chained_log`. Here, everything to be logged gets saved in main-memory in the form of a python-list. It'll get saved to file only when users asks to do so by calling `dump_chained_log_to_file` method."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "@paramlog.append_to_chained_log\n",
    "def compute_addition(operand1, operand2):\n",
    "    return operand1 + operand2\n",
    "\n",
    "\n",
    "for i in range(1, 100):\n",
    "    # inputs and outputs of this method call are \n",
    "    # present in main-memory but not saved to file (disk).\n",
    "    result1 = compute_addition(i,10*i)\n",
    "\n",
    "\n",
    "# Here we ask to save all the logs collected for compute_addition()\n",
    "# method call to file, with only 1 file access operation.\n",
    "# It'll get saved to file with name \"all_compute_addition_logs.jsonl\"\n",
    "paramlog.dump_chained_log_to_file(file_name=\"all_compute_addition_logs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4) clear_chained_log() method\n",
    "Deletes the logs collected so far (before saving to file). This can work only with logs collected via `append_to_chained_log` decorator."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "@paramlog.append_to_chained_log\n",
    "def compute_addition(operand1, operand2):\n",
    "    return operand1 + operand2\n",
    "\n",
    "\n",
    "for i in range(1, 100):\n",
    "    # inputs and outputs of this method call are \n",
    "    # present in main-memory but not saved to file (disk).\n",
    "    result1 = compute_addition(i,10*i)\n",
    "    if i==50:\n",
    "        # By this all logs collected for iteration 1 to 50, would be deleted and\n",
    "        # will not be present in the log file.\n",
    "        paramlog.clear_chained_log()\n",
    "\n",
    "\n",
    "# Here we ask to save all the logs collected for compute_addition()\n",
    "# method call to file, with only 1 file access operation.\n",
    "# It'll get saved to file with name \"all_compute_addition_logs.jsonl\"\n",
    "paramlog.dump_chained_log_to_file(file_name=\"part_compute_addition_logs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5) run_over_logs decorator\n",
    "Runs the method tagged by run_over_logs decorator over each entry in jsonl file that was created by any of the above methods.\n",
    "And save the result in a new `.jsonl` file, keeping the mapping."
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": [
    "@paramlog.log_io_params_for_method\n",
    "def prediction(x, gt):\n",
    "    # NOTE: we are passing gt (ground truth) as input, but its not getting\n",
    "    # used in method. We do this so that ground truth gets logged.\n",
    "    slope=10\n",
    "    bias=3\n",
    "    return slope*x + bias\n",
    "\n",
    "ground_truth = [i*0.1 for i in range(10)]\n",
    "for x, gt in zip(range(10), ground_truth):\n",
    "    y = prediction(x, gt)\n",
    "\n",
    "# After running above code, inputs and outputs of prediction() method would have been logged in prediction.jsonl file\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "We are using run_over_logs decorator to run absolute_accuracy() method over each record in prediction.jsonl file.\n",
    "`id`, `inputs`, `outputs` fields in prediction.jsonl can be accessed via `dummy_id`, `dummy_input`, `dummy_output` parameters respectively. \n",
    "These fields have to be initialized to None, when defining absolute_difference() method. \n",
    "dummy_input would always be dictionary, so that you can send any number of parameters of any datatype.\n",
    "Data type of `dummy_output` would be same as datatype of output of prediction() method above.\n",
    "`file_path` parameter takes path to prediction.jsonl file.\n",
    "\"\"\"\n",
    "@paramlog.run_over_logs\n",
    "def absolute_difference(file_path, dummy_id=None, dummy_input=None, dummy_output=None, dummy_meta=None, **kwargs):\n",
    "    # This method computes absolute difference between ground truth and prediction. \n",
    "    gt = float(dummy_input[\"gt\"])\n",
    "    y = dummy_output\n",
    "    return abs(y-gt)\n",
    "\n",
    "\n",
    "absolute_accuracy(file_path=\"prediction.jsonl\")"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}