Upload sgcp (1).ipynb

sgcp (1).ipynb

@@ -0,0 +1,849 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c456b0f8-4c68-495d-b2e1-7cffc10728e2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict, deque\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from tqdm.notebook import tqdm\n",
+    "from sklearn.metrics.pairwise import cosine_similarity\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.pydantic_v1 import BaseModel, Field\n",
+    "from multiprocessing import Pool\n",
+    "import pickle\n",
+    "import faiss\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ca0f819-3674-4add-ba3b-c793b79e6ed2",
+   "metadata": {},
+   "source": [
+    "# LLM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3eacd9d7-6978-4ac4-92f2-ed64689483ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoTokenizer\n",
+    "from langchain_community.llms import VLLMOpenAI\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "\n",
+    "inference_server_url = \"http://localhost:8100/v1\"\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"meta-llama/Meta-Llama-3.1-8B-Instruct\")\n",
+    "\n",
+    "### For Chat OpenAI template\n",
+    "llm = ChatOpenAI(\n",
+    "    model=\"Llama-3.1-8B-Instruct\",\n",
+    "    openai_api_key=\"EMPTY\",\n",
+    "    openai_api_base=inference_server_url,\n",
+    "    temperature=0,\n",
+    "    streaming= False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "454db217-6968-4373-8b7c-76e7ee164031",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "llm.invoke(\"Hello\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f32f7238-f817-4fad-b261-0d99bc752365",
+   "metadata": {},
+   "source": [
+    "# Embedding"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22c0f930-a871-4f59-a22a-19da9e0c9d4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import requests\n",
+    "from typing import List\n",
+    "from langchain_core.embeddings import Embeddings\n",
+    "from tqdm.notebook import tqdm\n",
+    "\n",
+    "class CustomAPIEmbeddings(Embeddings):\n",
+    "    def __init__(self, api_url: str, show_progress: bool):\n",
+    "        self.api_url = api_url\n",
+    "        self.show_progress = show_progress\n",
+    "\n",
+    "    def embed_documents(self, texts: List[str]) -> List[List[float]]:\n",
+    "        lst_embedding = []\n",
+    "        if self.show_progress:  # for tqdm embedding\n",
+    "            for query in tqdm(texts):\n",
+    "                payload = json.dumps({\n",
+    "                    \"inputs\": query\n",
+    "                })\n",
+    "                headers = {\n",
+    "                    'Content-Type': 'application/json'\n",
+    "                }\n",
+    "                try:\n",
+    "                    response = json.loads(\n",
+    "                        requests.request(\"POST\", self.api_url, headers=headers, data=payload).text\n",
+    "                    )\n",
+    "                    lst_embedding.append(response)\n",
+    "                except Exception as e:\n",
+    "                    print(e)\n",
+    "                    print(requests.request(\"POST\", self.api_url, headers=headers, data=payload).text)\n",
+    "        else:\n",
+    "            for query in texts:\n",
+    "                payload = json.dumps({\n",
+    "                    \"inputs\": query\n",
+    "                })\n",
+    "                headers = {\n",
+    "                    'Content-Type': 'application/json'\n",
+    "                }\n",
+    "                try:\n",
+    "                    response = json.loads(\n",
+    "                        requests.request(\"POST\", self.api_url, headers=headers, data=payload).text\n",
+    "                    )\n",
+    "                    lst_embedding.append(response)\n",
+    "                except Exception as e:\n",
+    "                    print(e)\n",
+    "                    # print(requests.request(\"POST\", self.api_url, headers=headers, data=payload).text)\n",
+    "\n",
+    "        return lst_embedding\n",
+    "\n",
+    "    def embed_query(self, text: str) -> List[float]:\n",
+    "        return self.embed_documents([text])[0]\n",
+    "\n",
+    "# Instantiate\n",
+    "embeddings = CustomAPIEmbeddings(api_url='http://localhost:8081/embed', show_progress=False)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d521cc3-1289-4989-829e-f27cd6bcde05",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers import AutoTokenizer\n",
+    "\n",
+    "tokenizer = AutoTokenizer.from_pretrained(\"BAAI/bge-large-en-v1.5\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f5269674-4496-45ad-81f5-5fcfb7665362",
+   "metadata": {},
+   "source": [
+    "# Load data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "27ab0473-ad8e-4070-a972-ef4eb003f55c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"final_data.csv\")\n",
+    "questions = df[\"question\"].to_list()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80852f40-af74-42fd-af20-de3aa4bca33c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df['question'].duplicated().sum()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "adc6c054-5370-4aee-821d-f615c7acc791",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "df[df['question'].duplicated()]['question'].value_counts()\n",
+    "df[df[\"question\"]==\"What does the table show?\"]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3675ffaa-1606-4f51-86b3-19baa58b797e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"map_triplet_rb.pkl\",'rb') as f:\n",
+    "    dct_mapping_triplet = pickle.load(f)\n",
+    "with open(\"embedded_ragbench_clean.pkl\",'rb') as f:\n",
+    "    lst_embedding = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23313f6c-300f-4e12-b883-fc6df677a4ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lst_embedding.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1c867ac2-14a4-4eb8-8af9-4cfdbf4c42fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "faiss_embeddings = lst_embedding.astype('float32')\n",
+    "d = faiss_embeddings.shape[1]  # dimension\n",
+    "index = faiss.IndexFlatL2(d)   # L2 distance index\n",
+    "index.add(faiss_embeddings)    # add embeddings"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d38bd5e9-bed9-4213-9b84-d36f44df6064",
+   "metadata": {},
+   "source": [
+    "# Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4b251e36-6567-40f7-bb32-334e5b342317",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def faiss_cosine(query_vector, k=10):\n",
+    "    query_vector = query_vector.astype('float32')\n",
+    "    distances, indices = index.search(query_vector, k)\n",
+    "    return indices.flatten()\n",
+    "\t\n",
+    "def query_triplet_topk(query, k=10):\n",
+    "\tt = tokenizer.encode(query)\n",
+    "\tif len(t) > 512:\n",
+    "\t\tt = t[:500]\n",
+    "\t\tquery = tokenizer.decode(t)\n",
+    "\tquery_emb = np.array(embeddings.embed_query(query)).reshape(1,-1)\n",
+    "\ttopk_indices_sorted = faiss_cosine(query_emb).tolist()\n",
+    "\treturn [dct_mapping_triplet[x] for x in topk_indices_sorted]\n",
+    "\n",
+    "def format_claim(relations):\n",
+    "    for rel in relations:\n",
+    "        rel['r.summary'] = rel['r.summary'].split(\"\\n\\n\")[-1]\n",
+    "    # return \"\\n\\n\".join(f\"[{i+1}] {doc.page_content}\" for i, doc in enumerate(docs))\n",
+    "    return \"\\n\\n\".join(f\"{idx+1}. {rel['r.summary']}\" for idx, rel in enumerate(relations))\n",
+    "\n",
+    "class GradeRelationList(BaseModel):\n",
+    "    \"\"\"List passage index check on retrieved text.\"\"\"\n",
+    "    passage_idx: str = Field(\n",
+    "        description=\"The passage index of relevant chunks, seperated by a comma\"\n",
+    "    )\n",
+    "\t\n",
+    "def check_grade_lst(question, text):\n",
+    "    prompt_text_grader = PromptTemplate(template=\"\"\"<|begin_of_text|><|start_header_id|>system<|end_header_id|> You are a grader assessing relevance \n",
+    "        of a list of retrieved passages to a user question. The goal is to filter out erroneous retrievals. \\n\n",
+    "        Return only the passage index whether the passage is relevant to the question. \\n\n",
+    "        Provide the output as a JSON with passage index seperated by a comma and no premable or explaination.\n",
+    "         <|eot_id|><|start_header_id|>user<|end_header_id|>\n",
+    "        Here is the list of retrieved text: \\n\\n {text} \\n\\n\n",
+    "        Here is the user question: {question} \\n <|eot_id|><|start_header_id|>assistant<|end_header_id|>\n",
+    "        \"\"\",\n",
+    "        input_variables=[\"question\", \"text\"]\n",
+    "    )\n",
+    "    structured_llm_grader = llm.with_structured_output(GradeRelationList)\n",
+    "    relation_grader = prompt_text_grader | structured_llm_grader \n",
+    "    result = relation_grader.invoke({\"question\": question, \"text\": text})\n",
+    "    # print(result)\n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "82f27027-7a59-4321-a2ec-40fb20304476",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "query_emb = np.array(embeddings.embed_query(questions[1])).reshape(1,-1)\n",
+    "topk_indices_sorted = faiss_cosine(query_emb).tolist()\n",
+    "topk_indices_sorted"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "521d7e93-71df-48e2-9fbc-387053845ab2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dct_mapping_triplet[36542]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a9ce274-24af-4b33-aca5-58b3d9c5d905",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Query top 10 triplet\n",
+    "# lst_triplet_top_k_cos = []\n",
+    "# for i in tqdm(questions):\n",
+    "#     lst_triplet_top_k_cos.append(query_triplet_topk(i))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cceb5693-5c83-4175-8362-1b7a2ab442f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# with open(\"top10_rb.pkl\", \"wb\") as f:\n",
+    "# \tpickle.dump(lst_triplet_top_k_cos, f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "34a972ea-a23b-41c1-a80b-8be47247fac0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"top10_rb.pkl\", \"rb\") as f:\n",
+    "\tlst_triplet_top_k_cos = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d5651de-27a3-430c-865b-a0c8d54dfdbb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "map_triplet = {}\n",
+    "for i,j in zip(lst_triplet_top_k_cos, questions):\n",
+    "    map_triplet[j] = i"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "16c6f900-a8f2-473a-9629-bdbd565cf6ce",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(questions)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e7e7dfd6-983a-4fb8-91b1-34b23b8faa14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Filter triplet\n",
+    "# f_triplet = []\n",
+    "# for q in tqdm(questions, total=len(questions)):\n",
+    "# \trelations = map_triplet[q]\n",
+    "# \tcontext = check_grade_lst(q, format_claim(relations)).passage_idx\n",
+    "# \tcontext = [int(x) for x in context.split(\",\")]\n",
+    "# \tcheck_rels = [relations[x-1] for x in context]\n",
+    "# \tf_triplet.append(check_rels)\n",
+    "# \tif len(f_triplet) % 10 == 0:\n",
+    "# \t\twith open(\"top10_filtered_rb.pkl\", \"wb\") as f:\n",
+    "# \t\t\tpickle.dump(f_triplet, f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "51dde469-38a2-4268-87ea-429b8b2b5c61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "os.getcwd()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2955959b-54e1-4c49-bef8-42afa30c6e85",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import uuid\n",
+    "def filter_triplet(q):\n",
+    "\tglobal map_triplet\n",
+    "\trelations = map_triplet[q]\n",
+    "\ttry:\n",
+    "\t\tcontext = check_grade_lst(q, format_claim(relations)).passage_idx\n",
+    "\t\tcontext = [int(x) for x in context.split(\",\")]\n",
+    "\t\t# Validate context indices\n",
+    "\t\t# if any(x <= 0 or x > len(relations) for x in context):\n",
+    "\t\t#     raise ValueError(\"Invalid index in context\")\n",
+    "\t\tf = [relations[x - 1] for x in context]\n",
+    "\texcept Exception as e:\n",
+    "\t\tprint(f\"Error processing {q}: {e}\")\n",
+    "\t\tf = relations  # fallback: use all relations\n",
+    "\n",
+    "\tfile_name = uuid.uuid4()\n",
+    "\tto_save = (q, f)\n",
+    "\twith open(f\"/home/ubuntu/work/minhbc/doan/ftriplet_318b/{file_name}.pkl\", \"wb\") as file:\n",
+    "\t\tpickle.dump(to_save, file)\n",
+    "\treturn f"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "416ae401-edf4-4c0c-b992-d4f3b0127e7e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# with Pool(5) as pool:\n",
+    "#     f_triplets = list(tqdm(pool.imap(filter_triplet, questions), total=len(questions)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "90dd9f7d-873d-4188-948c-69e3a108e650",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# with open(\"top10_filtered_rb.pkl\", \"wb\") as f:\n",
+    "# \tpickle.dump(f_triplets, f)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5fb4a21-17f2-4c33-9e73-7843c9f878df",
+   "metadata": {},
+   "source": [
+    "# KG completion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "272dbecd-b6aa-4d66-b153-630c1660d08a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from collections import defaultdict, deque"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "965d77e0-062c-4d53-8e14-4424f51c7950",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import copy\n",
+    "\n",
+    "def build_undirected_graph(triplets):\n",
+    "\t\"\"\"\n",
+    "\tXây đồ thị vô hướng:\n",
+    "\t- Mỗi cạnh (m -r-> n) được thêm cả (m->n) và (n->m với r_rev).\n",
+    "\t\"\"\"\n",
+    "\tgraph = defaultdict(list)\n",
+    "\tfor t in triplets:\n",
+    "\t\tm_id = t['m']['id']\n",
+    "\t\tn_id = t['n']['id']\n",
+    "\t\trel  = t['r']['id']\n",
+    "\t\tsummary = t['r']['summary']\n",
+    "\t\t\n",
+    "\t\t# chiều xuôi\n",
+    "\t\tgraph[m_id].append({\n",
+    "\t\t\t'm': {'id': m_id},\n",
+    "\t\t\t'r': {'id': rel, 'summary': summary},\n",
+    "\t\t\t'n': {'id': n_id}\n",
+    "\t\t})\n",
+    "\t\t# chiều ngược\n",
+    "\t\tgraph[n_id].append({\n",
+    "\t\t\t'm': {'id': n_id},\n",
+    "\t\t\t'r': {'id': f\"{rel}_rev\", 'summary': summary},\n",
+    "\t\t\t'n': {'id': m_id}\n",
+    "\t\t})\n",
+    "\treturn graph\n",
+    "def bfs_all_paths(KG, start, end, max_length):\n",
+    "\t\"\"\"\n",
+    "\tTrả về list các đường đi (mỗi đường là list các triplet-dicts)\n",
+    "\ttừ start -> end với số bước < max_length.\n",
+    "\t\"\"\"\n",
+    "\tif start not in KG or end not in KG:\n",
+    "\t\treturn []\n",
+    "\n",
+    "\tall_paths = []\n",
+    "\tqueue = deque([(start, [])])  # (node hiện tại, path_so_far)\n",
+    "\n",
+    "\twhile queue:\n",
+    "\t\tcurrent, path = queue.popleft()\n",
+    "\t\t# print(f\"Cur: {current}\")\n",
+    "\t\t# print(f\"Path: {path}\")\n",
+    "\t\t# print(f\"KG curr: {KG[current]}\")\n",
+    "\t\t\n",
+    "\t\tif len(path) >= max_length:\n",
+    "\t\t\tcontinue\n",
+    "\n",
+    "\t\tfor triplet in KG[current]:\n",
+    "\t\t\tneighbor = triplet['n']['id']\n",
+    "\t\t\t# print(f\"Neigbor: {neighbor}\")\n",
+    "\t\t\tnew_path = path + [triplet]\n",
+    "\t\t\tif neighbor == end:\n",
+    "\t\t\t\tall_paths.append(new_path)\n",
+    "\t\t\telse:\n",
+    "\t\t\t\tvisited = {t['m']['id'] for t in path} | {t['n']['id'] for t in path}\n",
+    "\t\t\t\t# print(f\"visited: {visited}\")\n",
+    "\t\t\t\tif neighbor not in visited:\n",
+    "\t\t\t\t\tqueue.append((neighbor, new_path))\n",
+    "\t\t# print(\"*\"*50)\n",
+    "\t# final = []\n",
+    "\t# if all_paths is not None:\n",
+    "\t# \tfor p in all_paths:\n",
+    "\t# \t\tif p not in final:\n",
+    "\t# \t\t\tfinal.append(p)\n",
+    "\t# \tall_paths = final\n",
+    "\treturn all_paths\n",
+    "\n",
+    "# ----------------------------------------\n",
+    "# Step 5: Hàm mở rộng subgraph theo độ liên quan\n",
+    "# ----------------------------------------\n",
+    "def normalize_triplet(t):\n",
+    "\t\"\"\"Convert triplet into normalized form (no _rev, consistent direction)\"\"\"\n",
+    "\tm_id, r_id, n_id = t[\"m\"][\"id\"], t[\"r\"][\"id\"], t[\"n\"][\"id\"]\n",
+    "\tsummary = t[\"r\"][\"summary\"]\n",
+    "\tif \"_rev\" in r_id:\n",
+    "\t\tr_id = r_id.split(\"_rev\")[0]\n",
+    "\t\tm_id, n_id = n_id, m_id  # swap direction\n",
+    "\treturn {\n",
+    "\t\t\"m\": {\"id\": m_id},\n",
+    "\t\t\"r\": {\"id\": r_id, \"summary\": summary},\n",
+    "\t\t\"n\": {\"id\": n_id}\n",
+    "\t}\n",
+    "\t\n",
+    "def relevance_guided_path_addition(KG, T, question, model, K=100, max_path_length=5):\n",
+    "\t\"\"\"\n",
+    "\tKG: dict[node_id] -> list of triplet-dicts {'m':{'id'}, 'r':{'id','summary'}, 'n':{'id'}}\n",
+    "\tT: list of triplet-dicts (subgraph gốc)\n",
+    "\tquestion: str hoặc None\n",
+    "\tmodel: object có .embed_query(str) và .encode(list_of_str)\n",
+    "\tK: số triplet mới tối đa thêm vào\n",
+    "\tmax_path_length: độ dài tối đa mỗi path\n",
+    "\tTrả về H = T + selected_triplets\n",
+    "\t\"\"\"\n",
+    "\t# Step 1: Tập entity từ T\n",
+    "\tE_T = {t['m']['id'] for t in T} | {t['n']['id'] for t in T}\n",
+    "\tprint(E_T)\n",
+    "\n",
+    "\t# Step 2: Embedding câu hỏi (nếu có)\n",
+    "\tquestion_emb = np.array(model.embed_query(question)) if question else None\n",
+    "\n",
+    "\t# Step 3: Tạo set key của T để kiểm tra nhanh\n",
+    "\tT_keys = {(t['m']['id'], t['r'][\"id\"], t['n']['id']) for t in T}\n",
+    "\n",
+    "\t# Step 4: Tìm tất cả đường đi giữa mọi cặp trong E_T\n",
+    "\tall_paths = []\n",
+    "\tfor start in E_T:\n",
+    "\t\tfor end in E_T:\n",
+    "\t\t\tif start == end:\n",
+    "\t\t\t\tcontinue\n",
+    "\t\t\tall_paths.extend(bfs_all_paths(KG, start, end, max_path_length))\n",
+    "\n",
+    "\tif not all_paths:\n",
+    "\t\tprint(\"H\")\n",
+    "\t\treturn T\n",
+    "\tprint(len(all_paths))\n",
+    "\n",
+    "\t# all_paths = all_paths[(len(T)*2 - 1):]\n",
+    "\t# print(all_paths)\n",
+    "\tfilterp = []\n",
+    "\tfor path in all_paths:\n",
+    "\t\tseen_keys = set()\n",
+    "\t\tnew_path = []\n",
+    "\t\tfor t in path:\n",
+    "\t\t\tnorm_t = normalize_triplet(t)\n",
+    "\t\t\tkey = (norm_t[\"m\"][\"id\"], norm_t[\"r\"][\"id\"], norm_t[\"n\"][\"id\"])\n",
+    "\t\t\tif key not in seen_keys:\n",
+    "\t\t\t\tnew_path.append(norm_t)\n",
+    "\t\t\t\tseen_keys.add(key)\n",
+    "\t\tfilterp.append(new_path)\n",
+    "\tall_paths = filterp\n",
+    "\n",
+    "\n",
+    "\t# Step 6: Score từng đường đi\n",
+    "\tpath_scores = []\n",
+    "\tfor path in all_paths:\n",
+    "\t\t# print(path)\n",
+    "\t\tsummaries = [triplet['r']['summary'] for triplet in path]\n",
+    "\t\tembs = model.embed_query(summaries)\n",
+    "\t\tembs = np.array(embs)\n",
+    "\t\tif question_emb is not None:\n",
+    "\t\t\tsims = cosine_similarity(embs, question_emb.reshape(1, -1)).flatten()\n",
+    "\t\t\tscore = float(np.mean(sims)) if sims.size else 0.0\n",
+    "\t\telse:\n",
+    "\t\t\tscore = 0.0\n",
+    "\t\tpath_scores.append((path, score))\n",
+    "\n",
+    "\t# Step 7: Chọn K triplet mới theo thứ tự score giảm dần\n",
+    "\tpath_scores.sort(key=lambda x: x[1], reverse=True)\n",
+    "\t# for ps in path_scores:\n",
+    "\t\t\n",
+    "\tprint(f\"len ps:{len(path_scores)}\")\n",
+    "\tpath_scores = path_scores[(len(T)*2-1):]\n",
+    "\tselected = []\n",
+    "\tselected_keys = set()\n",
+    "\tfor path, _ in path_scores:\n",
+    "\t\tfor triplet in path:\n",
+    "\t\t\tkey = (triplet['m']['id'], triplet['r']['id'], triplet['n']['id'])\n",
+    "\t\t\tif key not in T_keys and key not in selected_keys:\n",
+    "\t\t\t\tselected.append(triplet)\n",
+    "\t\t\t\tselected_keys.add(key)\n",
+    "\t\t\t\tif len(selected) >= K:\n",
+    "\t\t\t\t\tbreak\n",
+    "\t\tif len(selected) >= K:\n",
+    "\t\t\tbreak\n",
+    "\n",
+    "\t# Step 8: Trả về subgraph hoàn chỉnh\n",
+    "\tH = T + selected\n",
+    "\t# t = []\n",
+    "\t# for t in H\n",
+    "\treturn H\n",
+    "\n",
+    "\n",
+    "def subgraph_completion(task):\n",
+    "\tglobal KG\n",
+    "\tglobal model\n",
+    "\tT, ques, K, max_path_length = task[0], task[1], task[2], task[3]\n",
+    "\tresult = relevance_guided_path_addition(KG, T, ques, model, K, max_path_length)\n",
+    "\tto_save = (ques, result)\n",
+    "\tfile_name = uuid.uuid4()\n",
+    "\twith open(f\"/home/ubuntu/work/minhbc/doan/sgcp_318b/{file_name}.pkl\", \"wb\") as file:\n",
+    "\t\tpickle.dump(to_save, file)\n",
+    "\treturn result\n",
+    "\t\n",
+    "\t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fdbdacc7-2cfb-4168-ac2c-9a816cb9cbae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"runned.pkl\", \"rb\") as f:\n",
+    "\trunned = pickle.load(f)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2f4d12a-1b1d-4852-80c2-e15ae603f043",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"rb_filtered_318b.pkl\", \"rb\") as file:\n",
+    "\tftriplets = pickle.load(file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4bd3a65d-0cb6-4379-9b67-d6bd0c1df340",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_questions, n_ftriplets = [], []\n",
+    "for i in tqdm(range(len(questions))):\n",
+    "\tif questions[i] not in runned:\n",
+    "\t\tn_questions.append(questions[i])\n",
+    "\t\tn_ftriplets.append(ftriplets[i])\n",
+    "\t\t"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0d6a9178-4516-4a79-ad72-9116035eaaea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(n_questions), len(n_ftriplets)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ae5afc14-e79e-4ca3-b3da-238a5a751c3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Format filter triplet\n",
+    "\n",
+    "# len(ftriplets)\n",
+    "\n",
+    "formatted_ftriplets = []\n",
+    "for recs in tqdm(n_ftriplets, total=len(n_ftriplets)):\n",
+    "\tformatted_rec = []\n",
+    "\tfor rec in recs:\n",
+    "\t\tsubj = rec['r'][0]['id']\n",
+    "\t\trel  = rec['r'][1]\n",
+    "\t\tobj  = rec['r'][2]['id']\n",
+    "\t\tsummary = rec['r.summary']\n",
+    "\t\tformatted_rec.append({\n",
+    "\t\t\t'm': {'id': subj},\n",
+    "\t\t\t'r': {'id': rel, 'summary': summary},\n",
+    "\t\t\t'n': {'id': obj}\n",
+    "\t\t})\n",
+    "\tformatted_ftriplets.append(formatted_rec)\n",
+    "len(formatted_ftriplets)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e05057b6-b363-4a4c-bfcb-fec3e94b5330",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "KG_data = []\n",
+    "for rec in tqdm(dct_mapping_triplet, total=len(dct_mapping_triplet)):\n",
+    "    subj = rec['r'][0]['id']\n",
+    "    rel  = rec['r'][1]\n",
+    "    obj  = rec['r'][2]['id']\n",
+    "    summary = rec['r.summary']\n",
+    "    KG_data.append({\n",
+    "        'm': {'id': subj},\n",
+    "        'r': {'id': rel, 'summary': summary},\n",
+    "        'n': {'id': obj}\n",
+    "    })\n",
+    "KG = build_undirected_graph(KG_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a5bc5d2a-c67b-4877-823c-1609e046056b",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "model = embeddings\n",
+    "\n",
+    "tasks = [(formatted_ftriplets[i], n_questions[i], 10, 2) for i in range(len(n_questions))]\n",
+    "with Pool(20) as pool:\n",
+    "\tsgcp = list(tqdm(pool.imap(subgraph_completion, tasks), total =len(tasks)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "03a2650f-638d-4812-abe5-794634232462",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"sgcp_318b.pkl\", \"wb\") as file:\n",
+    "\tpickle.dump(sgcp, file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ed560d4d-8caf-49d3-a913-15874b953209",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "T = formatted_ftriplets[0]\n",
+    "ques = questions[0]\n",
+    "T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8461606b-69ec-474a-9682-27b5022a12df",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80728aa1-7870-45f4-84ef-359bd08963aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "relevance_guided_path_addition(KG, T, ques, embeddings, 10, 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2945c9ce-4c42-402d-a1c4-452f5f52a78c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}