granite-io hallucination demo example and notebook

Signed-off-by: Mandana Vaziri <[email protected]>

Author: vazirim

examples/granite-io/granite_io_hallucinations.pdl

@@ -47,5 +47,22 @@ text:
     controls:
       hallucinations: true
       citations: true
-  modelResponse: outputs
-- ${ outputs }
+  modelResponse: output
+- "\nHallucinations:\n"
+- for:  
+    hallucination: ${ output.results[0].next_message.hallucinations }
+  repeat:
+    text: 
+    - "Hallucination Risk: ${ hallucination.risk }"
+    - "\nSentence: ${ hallucination.response_text }"
+  join: 
+    with: "\n"
+- "\n\nCitations:\n"
+- for:
+    citation: ${ output.results[0].next_message.citations }
+  repeat:
+    text: 
+    - "Citation: ${ citation.context_text }"
+    - "\nSentence: ${ citation.response_text }"
+  join:
+    with: "\n"

examples/notebooks/granite_io_demo.ipynb

@@ -28,50 +28,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "e25a6874-54d9-4167-82ed-ab2f4fdc0a6f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "ERROR:root:Error in adding the context spans to citation:                             Cited text not found in corresponding document\n",
-      "ERROR:asyncio:Task exception was never retrieved\n",
-      "future: <Task finished name='Task-14' coro=<AsyncClient.aclose() done, defined at /Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpx/_client.py:2024> exception=RuntimeError('Event loop is closed')>\n",
-      "Traceback (most recent call last):\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpx/_client.py\", line 2031, in aclose\n",
-      "    await self._transport.aclose()\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpx/_transports/default.py\", line 389, in aclose\n",
-      "    await self._pool.aclose()\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpcore/_async/connection_pool.py\", line 353, in aclose\n",
-      "    await self._close_connections(closing_connections)\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpcore/_async/connection_pool.py\", line 345, in _close_connections\n",
-      "    await connection.aclose()\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpcore/_async/connection.py\", line 173, in aclose\n",
-      "    await self._connection.aclose()\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpcore/_async/http11.py\", line 258, in aclose\n",
-      "    await self._network_stream.aclose()\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/httpcore/_backends/anyio.py\", line 53, in aclose\n",
-      "    await self._stream.aclose()\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/envs/pdl-3.13/lib/python3.13/site-packages/anyio/_backends/_asyncio.py\", line 1306, in aclose\n",
-      "    self._transport.close()\n",
-      "    ~~~~~~~~~~~~~~~~~~~~~^^\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/lib/python3.13/asyncio/selector_events.py\", line 1202, in close\n",
-      "    super().close()\n",
-      "    ~~~~~~~~~~~~~^^\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/lib/python3.13/asyncio/selector_events.py\", line 865, in close\n",
-      "    self._loop.call_soon(self._call_connection_lost, None)\n",
-      "    ~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/lib/python3.13/asyncio/base_events.py\", line 829, in call_soon\n",
-      "    self._check_closed()\n",
-      "    ~~~~~~~~~~~~~~~~~~^^\n",
-      "  File \"/Users/lmandel/.pyenv/versions/3.13.0/lib/python3.13/asyncio/base_events.py\", line 552, in _check_closed\n",
-      "    raise RuntimeError('Event loop is closed')\n",
-      "RuntimeError: Event loop is closed\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%load_ext pdl.pdl_notebook_ext"
    ]
@@ -90,19 +50,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "f3c62df1-0347-4711-acd7-3892cfd5df30",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hello!\n",
-      "\u001b[32mHello! It seems like we're having a bit of an interruption in time due to the knowledge cutoff date being April 2024 and today's date being March 26, 2025. As Granite, I can still provide information based on knowledge up to that point, so go ahead with your question! How can I assist you within this context?\u001b[0m"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%pdl --reset-context\n",
     "text:\n",
@@ -124,76 +75,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "bb01f89d-afaa-409c-ad48-10cc50c3fbc5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Find the fastest way for a seller to visit all the cities in their region\n",
-      ">> Response:\n",
-      "\u001b[32mTo determine the fastest route for a seller to visit every city in their region, we employ solutions from advanced graph theory and optimization algorithms. Here’s how you could approach this problem using modern computational methods:\n",
-      "\n",
-      "1. **Data Representation**:\n",
-      "   - Begin by compiling all cities of interest that constitute your seller's region into a set of vertices or nodes in an undirected graph (G = (V, E)), where each vertex 'v' represents one city.\n",
-      "   - Assign weights to the edges (w(u, v)) based on a suitable metric relevant to your seller’s context – this could be driving distance between cities measured via GPS if vehicles are used for travel, or it might represent time estimations for business travelers if you're optimizing for operational efficiency.\n",
-      "\n",
-      "2. **Algorithm Selection**: For solving the complicated TSP problem of finding the shortest path through all these points while minimizing total cost (distance, time taken, etc.), consider one of the following proven methods:\n",
-      "   \n",
-      "   - **Exact Methods**:\n",
-      "     - **Christofides' Algorithm** – This is a widely accepted approximation algorithm with a guaranteed performance bound of 3/2 times the optimal solution. It converts the TSP into a combination of a near-optimal spanning tree and certain Hamiltonian cycles, making it computationally managed for most realistic scenarios.\n",
-      "     - **Genetic Algorithms**, Ant Colony Optimization, or other heuristics – These evolutionary methods are powerful approximators that draw on principles from biological processes to iteratively refine solutions until good quality is reached rapidly.\n",
-      "   \n",
-      "   - **Commercial and Open-Source TSP Solvers**: \n",
-      "     Tools like CPLEX (IBM's solvers) for complex optimization tasks can efficiently tackle larger TSP problems. For open-source solutions, GraphHopper or Google OR-Tools provide robust and scalable alternatives, though they might demand a more powerful computational platform than smartphone-level hardware would suggest.\n",
-      "\n",
-      "3. **Implementation Steps**:\n",
-      "   - **Data Preparation**: Compile the list of cities with associated cost data into the correct format for your chosen algorithm – typically, a matrix where w(cityi, cityj) equals the cost or distance between them.\n",
-      "   \n",
-      "   - **Execution**:\n",
-      "     - If using an exact method like Christofides', implement this process iteratively:\n",
-      "       1. Start with an initial spanning tree and two or more Hamiltonian cycles.\n",
-      "       2. At each step, replace a part of the minimum-weight alternating path from the tree with the edges from one of these cycles (to enhance the overall tour quality).\n",
-      "       3. When no further improvements are possible in this manner, you have an approximation to the optimum solution.\n",
-      "     - For heuristics or exact solvers like CPLEX:\n",
-      "       1. Load your dataset into the solver software.\n",
-      "       2. Set objective parameters to minimize \"total cost\" (e.g., time or distance).\n",
-      "       3. Run the solver and wait for the optimal (or near-optimal) route solution to present itself.\n",
-      "\n",
-      "4. **Analysis**:\n",
-      "   - Analyze outcomes from both exact and heuristic methods. Compare results to qualitatively assess which approach gives a more efficient route for your seller, considering tolerance levels for deviations from theoretical optima due to computational restrictions or other constraints on your data. Adjust parameters like the \"population size\" in genetic algorithms or solver settings like time limits if needed, recalculating until satisfactory performance is achieved.\n",
-      "\n",
-      "5. **Route Interpretation**:\n",
-      "   - Once a solution is secured:\n",
-      "     - Map out each city it includes.\n",
-      "     - Estimate travel times between them according to the weight function used (actual transit times, expected average driving speeds, business-optimal schedules). \n",
-      "     - Use this insight to plan trips efficiently, maximizing sales visits while minimizing operational downtime or travel expenses.\n",
-      "\n",
-      "Ultimately, leveraging these advanced analytical tools and following a structured procedure ensures that the seller not only completes all necessary city visits but also does so in the most efficient manner possible based on the constraints and objectives defined for this strategic route planning problem.\u001b[0m>> Thoughts:\n",
-      "1. **Understanding the Problem**: The goal is to find the most efficient route that allows a seller to visit every city in their defined region exactly once. This problem can be solved using strategies from graph theory, specifically, the Traveling Salesman Problem (TSP), a well-known type of optimization problem.\n",
-      "\n",
-      "2. **Representation**: Cities can be represented as vertices in a mathematical graph. Edges between these vertices would represent potential routes that connect cities, with weights possibly measuring distance, time, or cost depending on the context.\n",
-      "\n",
-      "3. **Optimal Solution**: The ideal solution for this problem is an optimal TSP tour – a route visiting each city exactly once and returning to the initial city, minimizing total travel distance, time, or cost.\n",
-      "\n",
-      "4. **Algorithms and Tools**: Several algorithms can solve TSP efficiently:\n",
-      "   - ** brute force method** – This could involve generating every possible permutation of city visits then selecting the one with the shortest cumulative distance or cost. Though practical for small numbers of cities due to exponential time complexity (O(n!)), it's impractical for larger problems like global routes.\n",
-      "   - **approximation algorithms** – Such as Christofides' algorithm or a variant of the nearest neighbor (NN) approach can quickly produce near-optimal solutions with provable performance bounds.\n",
-      "   - **Exact solvers** including commercial software packages (like CPLEX, Gurobi) and open-source tools (such as BranchAndCut in Python's PuLP library), which are capable of solving larger TSP problems to global optimality but at the cost of computational time proportional to 2^n or n log(n).\n",
-      "\n",
-      "5. **Implementation Considerations**:\n",
-      "   - **Input Data**: Necessary data should be provided including a list of all cities and their coordinates (if route calculations depend on geographical distance) along with connectivity information between these points.\n",
-      "   - **Software Tools** – Depending upon the city count, a laptop might suffice for exploring optimal routes with current techniques; professional TSP tools could be required for larger datasets or if global optima beyond approximations are needed.\n",
-      "\n",
-      "6. **Solution Outline**:\n",
-      "   1. Collect and record all cities in the seller's region as vertices of a graph.\n",
-      "   2. Weigh each city pair by its relevant metric (distance, time, cost), constituting edges or distances within this graph.\n",
-      "   3. Employ an optimal TSP solver tool/algorithm to compute the least aggregate distance path visiting all cities once and returning to the origin.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%pdl --reset-context\n",
     "text:\n",
@@ -222,18 +107,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "d7149b3f",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Did Faith Hill take a break from recording after releasing her second album, It Matters to Me?Error during 'granite3.2:2b' model call: PDLRuntimeError(\"Error during 'granite3.2:2b' model call: ValueError('Failed to parse citations, documents and hallucinations from model ouput.')\")\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%%pdl --reset-context\n",
     "defs:\n",
@@ -285,7 +162,25 @@
     "    controls:\n",
     "      hallucinations: true\n",
     "      citations: true\n",
-    " "
+    "  modelResponse: output\n",
+    "- \"\\nHallucinations:\\n\"\n",
+    "- for:  \n",
+    "    hallucination: ${ output.results[0].next_message.hallucinations }\n",
+    "  repeat:\n",
+    "    text: \n",
+    "    - \"Hallucination Risk: ${ hallucination.risk }\"\n",
+    "    - \"\\nSentence: ${ hallucination.response_text }\"\n",
+    "  join: \n",
+    "    with: \"\\n\"\n",
+    "- \"\\n\\nCitations:\\n\"\n",
+    "- for:\n",
+    "    citation: ${ output.results[0].next_message.citations }\n",
+    "  repeat:\n",
+    "    text: \n",
+    "    - \"Citation: ${ citation.context_text }\"\n",
+    "    - \"\\nSentence: ${ citation.response_text }\"\n",
+    "  join:\n",
+    "    with: \"\\n\""
    ]
   },
   {
@@ -311,7 +206,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "pdl-3.13",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -325,7 +220,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.13.0"
+   "version": "3.12.5"
   }
  },
  "nbformat": 4,