Linear WP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cd1e67a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#-*- coding: utf-8 -*-\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sympy import *\n",
    "import openai\n",
    "import itertools\n",
    "import re\n",
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "867be9e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = symbols(\"x\")\n",
    "y = symbols(\"y\")\n",
    "sym = \" -> \""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8db14660",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b57ae15e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data\n",
    "data = pd.read_excel('math_data.xlsx', sheet_name=\"L30\",usecols=\"A,B\", header=None, names=['Q','A'])\n",
    "\n",
    "# shuffle the rows\n",
    "df = data.sample(frac=1, random_state=925)\n",
    "\n",
    "# split dataset\n",
    "train = df.iloc[0:5]\n",
    "cv = df.iloc[5:17]\n",
    "test = df.iloc[17:]\n",
    "\n",
    "# list used to iterate through all permutations\n",
    "ls = list(itertools.combinations(list(range(0,5)),3))\n",
    "temp_cv = pd.DataFrame(columns = [\"Examples\",\"T9\"])\n",
    "temp_test = pd.DataFrame(columns = [\"Examples\",\"T9\"])\n",
    "results = pd.DataFrame(columns = [\"Examples\",\"Question\",\"Right Answer\",\"Generated Answer\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fedb51ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "openai.api_key = \"\"\n",
    "\n",
    "\n",
    "def generate_res(s):\n",
    "    response = openai.Completion.create(\n",
    "        model=\"text-davinci-002\",\n",
    "        prompt=s,\n",
    "        temperature=0.9,\n",
    "        max_tokens=50,\n",
    "        top_p=1,\n",
    "        frequency_penalty=0,\n",
    "        presence_penalty=0)\n",
    "    return response[\"choices\"][0][\"text\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cba960a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def acc_calculation(ans_df):\n",
    "    corr_num = 0\n",
    "    for i in range(len(ans_df)):\n",
    "        # check if generated answer contains 2 equations and no characters other than x, y, digits and operators\n",
    "        ans = ans_df.iloc[i, 1].replace(\" \",\"\")\n",
    "        ans = ans.replace(\"^\",\"**\").split(\";\")\n",
    "        invalid_char = re.findall(r'[^\\^xy0-9=+-/\\*;\\(\\) ]+', ans_df.iloc[i, 1])\n",
    "        if \",\" in ans_df.iloc[i, 1]:\n",
    "            continue\n",
    "        elif len(ans)!=2 or len(invalid_char)!=0:\n",
    "            continue \n",
    "        elif ans[1] == \"\":\n",
    "            continue\n",
    "\n",
    "        # proceed with valid answers\n",
    "        # filling in asterisks\n",
    "        temp = re.findall(r'[xy]|\\d|[=+-/\\*\\(\\)]', ans[0])\n",
    "        j = 1\n",
    "        while j<len(temp):\n",
    "            if temp[j] == \"x\" or temp[j] == \"y\" or temp[j] == \"(\":\n",
    "                if temp[j-1].isdigit() or temp[j-1] == \")\" or temp[j-1] == \"x\" or temp[j-1] == \"y\":\n",
    "                    temp.insert(j,\"*\")\n",
    "                if temp[j-1] == \".\":\n",
    "                    temp.insert(j,\"0*\")\n",
    "            elif temp[j].isdigit() and temp[j-1] == \")\":\n",
    "                temp.insert(j,\"*\")\n",
    "            if temp[j] == \".\" and j+1 == len(temp):\n",
    "                temp.pop(j)\n",
    "            j +=1\n",
    "        first = \"\".join(temp).split(\"=\")\n",
    "        j = 1\n",
    "        temp = re.findall(r'[xy]|\\d|[=+-/\\*\\(\\)]', ans[1])\n",
    "        while j<len(temp):\n",
    "            if temp[j] == \"x\" or temp[j] == \"y\" or temp[j] == \"(\":\n",
    "                if temp[j-1].isdigit() or temp[j-1] == \")\" or temp[j-1] == \"x\" or temp[j-1] == \"y\":\n",
    "                    temp.insert(j,\"*\")\n",
    "                if temp[j-1] == \".\":\n",
    "                    temp.insert(j,\"0*\")\n",
    "            elif temp[j].isdigit() and temp[j-1] == \")\":\n",
    "                temp.insert(j,\"*\")\n",
    "            if temp[j] == \".\" and j+1 == len(temp):\n",
    "                temp.pop(j)\n",
    "            j +=1\n",
    "        second = \"\".join(temp).split(\"=\")\n",
    "        if \"\" in first or \"\" in second:\n",
    "            continue\n",
    "\n",
    "        # create equations\n",
    "        eq1 = Eq(eval(first[0]),eval(first[1]),evaluate=False)\n",
    "        eq2 = Eq(eval(second[0]),eval(second[1]),evaluate=False)\n",
    "        reference = ans_df.iloc[i, 0].split(\";\")\n",
    "        one = reference[0].split(\"=\")\n",
    "        two = reference[1].split(\"=\")\n",
    "        ref1 = Eq(eval(one[0]),eval(one[1]),evaluate=False)\n",
    "        ref2 = Eq(eval(two[0]),eval(two[1]),evaluate=False)\n",
    "        \n",
    "        # check if the model switched variables for representation\n",
    "        temp = re.findall(r'[xy]|\\d|[=+-/\\*\\(\\)]', \"=\".join([first[0],first[1]]))\n",
    "        k=0\n",
    "        while k<len(temp):\n",
    "            if temp[k] == \"x\":\n",
    "                temp[k] = \"y\"\n",
    "            elif temp[k] == \"y\":\n",
    "                temp[k] = \"x\"\n",
    "            k += 1\n",
    "        sub1 = \"\".join(temp).split(\"=\")\n",
    "        temp = re.findall(r'[xy]|\\d|[=+-/\\*\\(\\)]', \"=\".join([second[0],second[1]]))\n",
    "        k=0\n",
    "        while k<len(temp):\n",
    "            if temp[k] == \"x\":\n",
    "                temp[k] = \"y\"\n",
    "            elif temp[k] == \"y\":\n",
    "                temp[k] = \"x\"\n",
    "            k += 1\n",
    "        sub2 = \"\".join(temp).split(\"=\")\n",
    "        se1 = Eq(eval(sub1[0]),eval(sub1[1]),evaluate=False)\n",
    "        se2 = Eq(eval(sub2[0]),eval(sub2[1]),evaluate=False)\n",
    "        # compare equations\n",
    "        if solve(eq1)==solve(ref1) and solve(eq2)==solve(ref2):\n",
    "            corr_num += 1\n",
    "        elif solve(eq1)==solve(ref2) and solve(eq2)==solve(ref1):\n",
    "            corr_num += 1\n",
    "        elif solve(se1)==solve(ref1) and solve(se2)==solve(ref2):\n",
    "            corr_num += 1\n",
    "        elif solve(se1)==solve(ref2) and solve(se2)==solve(ref1):\n",
    "            corr_num += 1\n",
    "    # return ratio\n",
    "    return(corr_num/len(ans_df))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "993008b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# zero-shot learning\n",
    "for i in range(len(df)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon.\\n\"+df.iloc[i,0]\n",
    "    resp = generate_res(s).replace(\" \", \"\")\n",
    "    resp = resp.replace(\"\\n\", \"\")\n",
    "    results.loc[len(results)] = [\"None\", df.iloc[i,0], df.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b5ff9a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# one-shot learning\n",
    "for i in range(len(train)):\n",
    "    for j in range(len(cv)):\n",
    "        s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the example:\\n1.\"\\\n",
    "            +train.iloc[i,0]+sym+train.iloc[i,1]+\"\\n2.\"+cv.iloc[j,0]+sym\n",
    "        resp = generate_res(s).replace(\" \", \"\")\n",
    "        resp = resp.replace(\"\\n\", \"\")\n",
    "        results.loc[len(results)] = [train.iloc[i].name, cv.iloc[j,0], cv.iloc[j,1], resp]\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b61c6ca3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# two-shot learning\n",
    "combs = list(itertools.combinations(list(range(0,5)),2))\n",
    "for x,y in combs:\n",
    "    for i in range(len(cv)):\n",
    "        s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +train.iloc[x,0]+sym+train.iloc[x,1]+\"\\n2.\"\\\n",
    "            +train.iloc[y,0]+sym+train.iloc[y,1]+\"\\n3.\"+cv.iloc[i,0]+sym\n",
    "        resp = generate_res(s)\n",
    "        resp = resp.replace(\"\\n\",\"\")\n",
    "        results.loc[len(results)] = [(train.iloc[x].name, train.iloc[y].name), cv.iloc[i,0], cv.iloc[i,1], resp]\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "714a8728",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# three-shot learning\n",
    "for x,y,z in ls:\n",
    "    for i in range(len(cv)):\n",
    "        s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +train.iloc[x,0]+sym+train.iloc[x,1]+\"\\n2.\"\\\n",
    "            +train.iloc[y,0]+sym+train.iloc[y,1]+\"\\n3.\"\\\n",
    "            +train.iloc[z,0]+sym+train.iloc[z,1]+\"\\n4.\"+cv.iloc[i,0]+sym\n",
    "        resp = generate_res(s)\n",
    "        resp = resp.replace(\"\\n\",\"\")\n",
    "        results.loc[len(results)] = [(train.iloc[x].name, train.iloc[y].name, train.iloc[z].name), cv.iloc[i,0], cv.iloc[i,1], resp]\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aecfa35a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# zero-shot prediction accuracy on whole dataset\n",
    "temp_cv.loc[len(temp_cv)] = [\"None\", acc_calculation(results.iloc[0:30,2:])]\n",
    "\n",
    "# one-shot prediction accuracy on cv\n",
    "gp = results.iloc[30:90].groupby(\"Examples\")\n",
    "for gp_name, group in gp:\n",
    "    temp_cv.loc[len(temp_cv)] = [str(gp_name), acc_calculation(group.iloc[:,2:])]\n",
    "    \n",
    "# two-shot prediction accuracy on cv\n",
    "gp = results.iloc[90:210].groupby(\"Examples\")\n",
    "for gp_name, group in gp:\n",
    "    temp_cv.loc[len(temp_cv)] = [str(gp_name), acc_calculation(group.iloc[:,2:])]\n",
    "\n",
    "# three-shot prediction accuracy on cv\n",
    "gp = results.iloc[210:].groupby(\"Examples\")\n",
    "for gp_name, group in gp:\n",
    "    temp_cv.loc[len(temp_cv)] = [str(gp_name), acc_calculation(group.iloc[:,2:])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa12fecf",
   "metadata": {},
   "outputs": [],
   "source": [
    "temp_cv"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e552e8",
   "metadata": {},
   "source": [
    "# Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02803a37",
   "metadata": {},
   "outputs": [],
   "source": [
    "# one-shot learning with example 17\n",
    "one_shot_1 = pd.DataFrame(columns=[\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "        s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the example:\\n1.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n2.\"+test.iloc[i,0]+sym\n",
    "        resp = generate_res(s).replace(\" \", \"\")\n",
    "        resp = resp.replace(\"\\n\", \"\")\n",
    "        one_shot_1.loc[len(one_shot_1)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0157117",
   "metadata": {},
   "outputs": [],
   "source": [
    "# one-shot learning with example 14\n",
    "one_shot_2 = pd.DataFrame(columns=[\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "        s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the example:\\n1.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n2.\"+test.iloc[i,0]+sym\n",
    "        resp = generate_res(s).replace(\" \", \"\")\n",
    "        resp = resp.replace(\"\\n\", \"\")\n",
    "        one_shot_2.loc[len(one_shot_2)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e2d9cc4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# two-shot using examples 12 and 14\n",
    "two_shot_1 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[12]['Q']+sym+data.loc[12]['A']+\"\\n2.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n3.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s).replace(\" \", \"\")\n",
    "    resp = resp.replace(\"\\n\", \"\")\n",
    "    two_shot_1.loc[len(two_shot_1)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b8a8fcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# two-shot using examples 17 and 5\n",
    "two_shot_2 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n2.\"\\\n",
    "            +data.loc[5]['Q']+sym+data.loc[5]['A']+\"\\n3.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s).replace(\" \", \"\")\n",
    "    resp = resp.replace(\"\\n\", \"\")\n",
    "    two_shot_2.loc[len(two_shot_2)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "355c255c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# two-shot using examples 17 and 12\n",
    "two_shot_3 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n2.\"\\\n",
    "            +data.loc[12]['Q']+sym+data.loc[12]['A']+\"\\n3.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s).replace(\" \", \"\")\n",
    "    resp = resp.replace(\"\\n\", \"\")\n",
    "    two_shot_3.loc[len(two_shot_3)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9933735b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# three-shot using examples (25,12,14)\n",
    "few_shot_1 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[25]['Q']+sym+data.loc[25]['A']+\"\\n2.\"\\\n",
    "            +data.loc[12]['Q']+sym+data.loc[12]['A']+\"\\n3.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n4.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    few_shot_1.loc[len(few_shot_1)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb0ec56e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# three-shot using examples (17,5,14)\n",
    "few_shot_2 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n2.\"\\\n",
    "            +data.loc[5]['Q']+sym+data.loc[5]['A']+\"\\n3.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n4.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    few_shot_2.loc[len(few_shot_2)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b44c9fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# three-shot using examples (17,12,14)\n",
    "few_shot_3 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n2.\"\\\n",
    "            +data.loc[12]['Q']+sym+data.loc[12]['A']+\"\\n3.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n4.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    few_shot_3.loc[len(few_shot_3)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fba2f09e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# three-shot using examples (25,5,14)\n",
    "few_shot_4 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[25]['Q']+sym+data.loc[25]['A']+\"\\n2.\"\\\n",
    "            +data.loc[5]['Q']+sym+data.loc[5]['A']+\"\\n3.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n4.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    few_shot_4.loc[len(few_shot_4)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a601e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# accuracy calculation\n",
    "\n",
    "#temp_test.loc[len(temp_test)] = [\"17\", acc_calculation(one_shot_1.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"14\", acc_calculation(one_shot_2.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(12, 14)\", acc_calculation(two_shot_1.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(17, 5)\", acc_calculation(two_shot_2.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(17, 12)\", acc_calculation(two_shot_3.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(25, 12, 14)\", acc_calculation(few_shot_1.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(17, 5, 14)\", acc_calculation(few_shot_2.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(17, 12, 14)\", acc_calculation(few_shot_3.iloc[:,1:])]\n",
    "#temp_test.loc[len(temp_test)] = [\"(25, 5, 14)\", acc_calculation(few_shot_4.iloc[:,1:])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cc55b0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# four-shot\n",
    "few_shot_5 = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(test)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n2.\"\\\n",
    "            +data.loc[5]['Q']+sym+data.loc[5]['A']+\"\\n3.\"\\\n",
    "            +data.loc[12]['Q']+sym+data.loc[12]['A']+\"\\n4.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n5.\"+test.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    few_shot_5.loc[len(few_shot_5)] = [test.iloc[i,0], test.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "122a6f4c",
   "metadata": {},
   "source": [
    "# More generations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4aefdf7",
   "metadata": {},
   "source": [
    "### Four and five shot learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98657a05",
   "metadata": {},
   "outputs": [],
   "source": [
    "# four-shot learning\n",
    "combs = list(itertools.combinations(list(range(0,5)),4))\n",
    "for x,y,z,k in combs:\n",
    "    for i in range(len(cv)):\n",
    "        s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +train.iloc[x,0]+sym+train.iloc[x,1]+\"\\n2.\"\\\n",
    "            +train.iloc[y,0]+sym+train.iloc[y,1]+\"\\n3.\"\\\n",
    "            +train.iloc[z,0]+sym+train.iloc[z,1]+\"\\n4.\"\\\n",
    "            +train.iloc[k,0]+sym+train.iloc[k,1]+\"\\n5.\"+cv.iloc[i,0]+sym\n",
    "        resp = generate_res(s)\n",
    "        resp = resp.replace(\"\\n\",\"\")\n",
    "        results.loc[len(results)] = [(train.iloc[x].name, train.iloc[y].name, train.iloc[z].name, train.iloc[k].name), cv.iloc[i,0], cv.iloc[i,1], resp]\n",
    "        time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d30ccd16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# five-shot\n",
    "results = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(rest)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +data.loc[25]['Q']+sym+data.loc[25]['A']+\"\\n2.\"\\\n",
    "            +data.loc[17]['Q']+sym+data.loc[17]['A']+\"\\n3.\"\\\n",
    "            +data.loc[5]['Q']+sym+data.loc[5]['A']+\"\\n4.\"\\\n",
    "            +data.loc[12]['Q']+sym+data.loc[12]['A']+\"\\n5.\"\\\n",
    "            +data.loc[14]['Q']+sym+data.loc[14]['A']+\"\\n6.\"+rest.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    results.loc[len(results)] = [rest.iloc[i,0], rest.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26cdd6ff",
   "metadata": {},
   "source": [
    "### three-shot learning with examples from S&D, POR, MO categories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "905e99c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "q1 = \"Tom and Jerry drove 271 total miles in 6 hours. Tom always drives 38 mph and Jerry always drives 59 mph. It's a wonder they can manage to remain friends. How many hours did Tom drive and how many hours did Jerry drive?\"\n",
    "a1 = \"x+y=6;38*x+59*y=271\"\n",
    "q2 = \"A class of 35 consists of students who either have red or yellow shirts. If there are 15 more people with red shirts than there are people with yellow shirts, how many of the students have red shirts?\"\n",
    "a2 = \"x+y=35;x=y+15\"\n",
    "q3 = \"The length of a rectangle is 7 units more than the width, and the perimeter is 35 units more than the length. What are the rectangle's dimensions?\"\n",
    "a3 = \"2*x+2*y-35=x;x-7=y\"\n",
    "q4 = \"The price, x, of an entertainment system at Extreme Electronics is $220 less than twice the price, y, of the same system at Ultra Electronics. The difference in price between the system at Extreme Electronics and Ultra Electronics is $175. Which system of linear equations can be used to determine the price of the system at each store?\"\n",
    "a4 = \"x+220=2*y;x-y=175\"\n",
    "q5 = \"Shana invests some money in an account that earns 5% simple interest and three times that amount in an account that earns 7% simple interest. If the total interest is $390 at the end of one year, find the amount invested in each account. \"\n",
    "a5 = \"3*x=y;0.05*x+0.07*y=390\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab588537",
   "metadata": {},
   "outputs": [],
   "source": [
    "results = pd.DataFrame(columns = [\"Question\",\"Right Answer\",\"Generated Answer\"])\n",
    "for i in range(len(d)):\n",
    "    s = \"Extract a system of two linear equations in terms of x and y from the question. Separate the equations with semicolon like given in the examples:\\n1.\"\\\n",
    "            +q1+sym+a1+\"\\n2.\"\\\n",
    "            +q2+sym+a2+\"\\n3.\"\\\n",
    "            +q3+sym+a3+\"\\n4.\"\\\n",
    "            +q4+sym+a4+\"\\n5.\"\\\n",
    "            +q5+sym+a5+\"\\n6.\"+d.iloc[i,0]+sym\n",
    "    resp = generate_res(s)\n",
    "    resp = resp.replace(\"\\n\",\"\")\n",
    "    results.loc[len(results)] = [d.iloc[i,0], d.iloc[i,1], resp]\n",
    "    time.sleep(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b77ae04c",
   "metadata": {},
   "source": [
    "# Traning set (for fine-tuning) preparation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36bc3c1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel(\"FTSet.xlsx\", sheet_name=\"T20\", header=None, usecols=\"A,B\", names=[\"Q\",\"A\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88666187",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_float(ele):\n",
    "    try:\n",
    "        float(ele)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09fb4938",
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate 4 copies for each pair of Q&A\n",
    "for index, row in df.iterrows():\n",
    "    # dataframe to store original and generated question and answer pairs\n",
    "    odf.loc[len(odf)]=[row[\"Q\"],row[\"A\"]]\n",
    "    \n",
    "    # numbers (including numerical words) need to be manually replaced by placeholders\n",
    "    # values need to be input separately\n",
    "    print(row[\"Q\"])\n",
    "    print(row[\"A\"])\n",
    "    q = input(\"Q template:\\n\")\n",
    "    a = input(\"A template:\\n\")\n",
    "    vals = input(\"Values:\\n\")\n",
    "    ls = vals.split(\"//\")\n",
    "    combs = [tuple(ls)]\n",
    "    \n",
    "    i=0\n",
    "    while i<4:\n",
    "        t = list()\n",
    "        tq = q\n",
    "        ta = a\n",
    "        for j in range(len(ls)):\n",
    "            # handles integers\n",
    "            if ls[j].isdigit():\n",
    "                temp = random.randint(int(ls[j])-2, int(ls[j])+3)\n",
    "                temp = str(temp)\n",
    "                ta = ta.replace(\"[\"+str(j)+\"]\",temp)\n",
    "            # handles floats\n",
    "            elif is_float(ls[j]):\n",
    "                dig = ls[j].split(\".\")[1]\n",
    "                temp = round(random.uniform(float(ls[j])-0.7, float(ls[j])+0.5),len(dig))\n",
    "                temp = str(temp)\n",
    "                ta = ta.replace(\"[\"+str(j)+\"]\",temp)\n",
    "            # handles percentages\n",
    "            elif \"%\" in ls[j]:\n",
    "                num = ls[j][:-1]\n",
    "                if num.isdigit():\n",
    "                    newnum = random.randint(int(num)-2, int(num)+3)\n",
    "                elif is_float(num):\n",
    "                    dig = num.split(\".\")[1]\n",
    "                    newnum = round(random.uniform(float(num)-0.7, float(num)+0.5),len(dig))\n",
    "                if newnum<0:\n",
    "                    newnum = (-1)*newnum\n",
    "                ta = ta.replace(\"[\"+str(j)+\"]\",str(newnum/100))\n",
    "                temp = str(newnum)+\"%\"\n",
    "            # handles numerical texts\n",
    "            else:\n",
    "                num = w2n.word_to_num(ls[j])\n",
    "                if isinstance(num, int):\n",
    "                    newnum = random.randint(num-2, num+3)\n",
    "                elif isinstance(num, float):\n",
    "                    dig = ls[j].split(\".\")[1]\n",
    "                    newnum = round(random.uniform(num-0.7, num+0.5),len(dig))\n",
    "                ta = ta.replace(\"[\"+str(j)+\"]\",str(newnum))\n",
    "                temp = num2words(newnum)\n",
    "                if ls[j][0].isupper():\n",
    "                    temp = temp.capitalize()\n",
    "            t.append(temp)\n",
    "            tq = tq.replace(\"[\"+str(j)+\"]\",temp)\n",
    "        # check for duplicates\n",
    "        if tuple(t) not in combs:\n",
    "            odf.loc[len(odf)]=[tq,ta]\n",
    "            combs.append(tuple(t))\n",
    "            i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5fe96a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "odf.to_excel()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}