{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('../data/task4.json') as f:\n",
    "    data = json.load(f)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If use Together API\n",
    "from together import Together\n",
    "\n",
    "your_model_name = 'xxxxxxxxxxxxxxxxxxxxxxxx'\n",
    "your_api_key = 'xxxxxxxxxxxxxxxxxxxxxxxx'\n",
    "client = Together(api_key=your_api_key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for draft in data:\n",
    "    statements = draft['Statements']\n",
    "    for statement in statements:\n",
    "        country = statement['country']\n",
    "        system_prompt = f\"\"\"\n",
    "        Assume you are the representative of {country} in UNSC, given the content of a UNSC draft resolution, generate a statement that you would make in the meeting.\n",
    "        \"\"\"\n",
    "        user_prompt = f\"\"\"\n",
    "        Draft resolution: {draft['Content']}\n",
    "        Your statement:\n",
    "        \"\"\"\n",
    "        response = client.chat.completions.create(\n",
    "            model=your_model_name,\n",
    "            temperature=0.0,\n",
    "            messages=[\n",
    "                {\"role\": \"system\", \"content\": system_prompt},\n",
    "                {\"role\": \"user\", \"content\": user_prompt}\n",
    "            ]\n",
    "        )\n",
    "        statement['generation'] = response.choices[0].message.content\n",
    "    draft['Statements'] = statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "statements = []\n",
    "generations = []\n",
    "\n",
    "for draft in data:\n",
    "    for statement in draft['Statements']:\n",
    "        statements.append(statement['statement'])\n",
    "        generations.append(statement['generation'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# average ROUGE\n",
    "from rouge_score import rouge_scorer\n",
    "scorer = rouge_scorer.RougeScorer(['rougeL'], use_stemmer=True)\n",
    "\n",
    "rouge_scores = []\n",
    "for i in range(len(statements)):\n",
    "    scores = scorer.score(statements[i], generations[i])\n",
    "    rouge_scores.append(scores['rougeL'].fmeasure)\n",
    "\n",
    "print('Average ROUGE-L:', sum(rouge_scores) / len(rouge_scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# average Jaccard similarity\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.metrics import jaccard_score\n",
    "\n",
    "jaccard_scores = []\n",
    "vectorizer = CountVectorizer(binary=True)\n",
    "\n",
    "for i in range(len(statements)):\n",
    "    X = vectorizer.fit_transform([statements[i], generations[i]]).toarray()\n",
    "    jaccard_scores.append(jaccard_score(X[0], X[1]))\n",
    "\n",
    "print('Average Jaccard similarity:', sum(jaccard_scores) / len(jaccard_scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# average Cosing Similarity (TF-IDF)\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "\n",
    "tf_cosine_scores = []\n",
    "for i in range(len(statements)):\n",
    "    tfidf = TfidfVectorizer().fit_transform([statements[i], generations[i]])\n",
    "    tf_cosine_scores.append(cosine_similarity(tfidf[0], tfidf[1])[0][0])\n",
    "\n",
    "print('Average Cosine Similarity (TF-IDF):', sum(tf_cosine_scores) / len(tf_cosine_scores))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sentence_transformers import SentenceTransformer, util\n",
    "\n",
    "device = 'cuda:1'\n",
    "model = SentenceTransformer('stsb-roberta-large', device=device)\n",
    "cosine_scores = []\n",
    "for i in range(len(statements)):\n",
    "    embeddings = model.encode([statements[i], generations[i]])\n",
    "    cosine_scores.append(util.pytorch_cos_sim(embeddings[0], embeddings[1]).item())\n",
    "\n",
    "print('Average Cosine Similarity (BERT):', sum(cosine_scores) / len(cosine_scores))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm",
   "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.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}