{ "cells": [ { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from transformers import set_seed\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from collections import Counter\n", "import numpy as np\n", "import random\n", "import torch" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "three fields in each prompt: question, bot, task\n", "\n", "input to the model is:\n", "```\n", "human\n", "[question]\n", "bot\n", "[bot]\n", "```\n", "where a question is\n", "```\n", "[program]\n", "\n", "[question]\n", "```" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "debug = ''\n", "in_dir = f\"/Users/zzy/Documents/graph{debug}\"\n", "out_dir = f\"/Users/zzy/Documents/graph{debug}/instruction\"\n", "no_return_sample_num = 20 if len(debug) > 0 else 40000\n", "\n", "figsize = (24, 16)\n", "fontsize = 28\n", "fontsize_tick = 16\n", "\n", "def filter_df(df, n=None):\n", " try:\n", " n = n if n is not None else no_return_sample_num\n", " return pd.concat([df[df.source.apply(lambda x: 'return ' in x)], df[df.source.apply(lambda x: 'return ' not in x)].sample(n)]).reset_index(drop=True)\n", " except:\n", " return df\n", "\n", "def capitalize(s: str):\n", " return s[0].upper() + s[1:]\n", "\n", "def replace_digit(s: str):\n", " return s.replace('10', 'ten').replace('1', 'one').replace('2', 'two').replace('3', 'three').replace('4', 'four').replace('5', 'five').replace('6', 'six').replace('7', 'seven').replace('8', 'eight').replace('9', 'nine')\n", "\n", "def print_df(df, n=10):\n", " for i in range(n):\n", " print(df.loc[i].question)\n", " print(df.loc[i].bot)\n", " print('---'*10)\n", "\n", "graph_type_map = {'AST': 'abstract syntax tree', 'DFG': 'data flow graph'}\n", "NODE_TYPES = [\n", " 'assignment expression',\n", " 'basic block',\n", " 'binary expression',\n", " 'break statement',\n", " 'call expression',\n", " 'catch clause',\n", " 'class expression',\n", " 'compile unit',\n", " 'conditional expression',\n", " 'continue statement',\n", " 'export statement',\n", " 'for statement',\n", " 'function expression',\n", " 'identifier expression', \n", " 'if statement',\n", " 'import expression',\n", " 'key value parameter',\n", " 'literal expression',\n", " 'member access',\n", " 'new expression',\n", " 'new with type expression',\n", " 'object expression',\n", " 'object property',\n", " 'parameter',\n", " 'Python delete',\n", " 'Python with',\n", " 'Python with expression clause',\n", " 'Python yield expression',\n", " 'range statement',\n", " 'return statement',\n", " 'scope',\n", " 'spread collection expression',\n", " 'spread dictionary expression',\n", " 'super expression',\n", " 'switch case',\n", " 'switch statement',\n", " 'this expression',\n", " 'throw statement',\n", " 'try statement',\n", " 'tuple expression',\n", " 'unary expression',\n", " 'variable declaration',\n", " 'while statement'\n", "]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# ph stands for place holder\n", "ph1 = 'aohg981thgboir2bnjosi1839r8g9udnfv,mqwfo'\n", "ph2 = 'io12i3ru9ginal90109ja-efi1-3gasd130gn0wa9'\n", "ph3 = '2091rng09wegnb2p09jojmpzf,k[2e00-jmaa]'\n", "ph4 = '0391gnea-g0-jr0aegbm[afk0-249jgps]waeg0'\n", "ph5 = 'io1hngi0enriqgpgv]139gonpiamofj10onem;alf'\n", "ph_list = [ph1, ph2, ph3, ph4, ph5]\n", "punc_list = [\",\", \"?\", \".\", \";\", \"'s\"]\n", "\n", "def replace_place_holder(s, node_text, placeholder=\"{node}\"):\n", " # this function injects a multi-line code snippet into the template\n", "\n", " if placeholder not in s:\n", " return s\n", "\n", " # 1. remove the white spaces around {node} placeholder\n", " s = s.replace(f\"{placeholder} \", f\"{placeholder}\").replace(f\" {placeholder}\", f\"{placeholder}\")\n", " for punc in punc_list:\n", " s = s.replace(f\"{placeholder}{punc} \", f\"{placeholder}{punc}\")\n", " \n", " # 2. injects the code, but first replace patterns like '\\n.' in both the code and template (the template may contain previously injected code)\n", " for ph, punc in zip(ph_list, punc_list):\n", " node_text = node_text.replace(f\"\\n{punc}\", ph)\n", " s = s.replace(f\"\\n{punc}\", ph)\n", " s = s.replace(placeholder, node_text)\n", "\n", " # 3. replace patterns like \"\\n.\" caused by the template\n", " for punc in punc_list:\n", " s = s.replace(f\"\\n{punc}\", f\"{punc}\\n\")\n", "\n", " # 4. replace the placerholders inserted in step 2\n", " for ph, punc in zip(ph_list, punc_list):\n", " s = s.replace(ph, f\"\\n{punc}\")\n", " return s" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## node classification" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "questions = [\n", " 'In the {graph} of this {lang} program, what is the type of this node: {node}.',\n", " 'Tell me the node type of {node} in the {graph} of this {lang} program.',\n", " 'What is the node type of {node} in the {graph} of this {lang} program',\n", " \"In the {graph} of the provided {lang} program, could you identify the type of the node {node}?\",\n", " \"What kind of node is {node} in the {graph} of this {lang} program?\",\n", " \"Can you classify the node {node} in the {graph} of this {lang} program?\",\n", " \"What category does the node {node} fall under in the {graph} of this {lang} program?\",\n", " \"Regarding the {graph} of this {lang} program, what is the classification of the node {node}?\",\n", " \"In the context of the {graph} of this {lang} program, what is the nature of the node identified as {node}?\",\n", " \"Could you tell me what the node {node} represents in the {graph} of this {lang} program?\",\n", " \"I'm curious, what type of node is {node} in the {graph} of the {lang} program presented?\",\n", " \"What is the designation of the node {node} within the {graph} of this {lang} program?\",\n", " \"Could you specify the node type for {node} in the {graph} of this particular {lang} program?\",\n", " 'Determine the node type of {node} in the {graph} of this {lang} program.',\n", "]\n", "answers = [\n", " \"This node, {node}, is classified as a {answer}.\",\n", " \"The node {node} is a {answer}.\",\n", " \"This node is identified as a {answer}.\",\n", " \"It's a {answer}.\",\n", " \"Regarding the node {node}, it falls under the category of a {answer}.\",\n", " \"{node} is classified as a {answer} in the {graph} of this program.\",\n", " \"The classification of the node {node} is a {answer}.\",\n", " \"Within the {graph} of this program, {node} is a {answer} type of node.\",\n", " \"As for the node identified as {node}, it's considered a {answer}.\",\n", " \"The node {node} is of the {answer} variety.\",\n", " 'The type of this node is {answer}.',\n", " 'The given node is a {answer}.',\n", " \"{answer}.\",\n", " \"{answer}\",\n", "]\n", "print(len(questions), len(set(questions)))\n", "print(len(answers), len(set(answers)))\n", "assert all(a.count('{answer}') == 1 for a in answers)\n", "assert all(a.count('{graph}') == 1 for a in questions)\n", "assert all(a.count('{lang}') == 1 for a in questions)\n", "\n", "bots = [a for a in answers]\n", "prompts = [[q, b] for q in questions for b in bots]\n", "print(len(prompts))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "set_seed(0)\n", "results = {}\n", "for lang in ['Java', 'Python']:\n", " for graph in ['DFG', 'AST']:\n", " result = []\n", " df = pd.read_json(f\"{in_dir}/{lang}_{graph}.jsonl\", lines=True)\n", " if lang == 'Python':\n", " df = filter_df(df)\n", "\n", " question, bot = [], []\n", " for i in range(len(df)):\n", "\n", " # filter out nodes that occur multiple times in the source code\n", " node_texts = df.loc[i]['text']\n", " node_ids = df.loc[i]['node_ids']\n", " source = df.loc[i]['source']\n", " assert len(node_ids) == len(node_texts)\n", "\n", " occurrences = np.array([source.count(t) for t in node_texts])\n", " nodes_single_occurrence = np.where(occurrences == 1)[0]\n", "\n", " # we sample 1 node from each program\n", " nodes = np.random.choice(nodes_single_occurrence, 1)\n", " for node in nodes:\n", " node_text = node_texts[node]\n", " node_id = node_ids[node]\n", " node_type = NODE_TYPES[node_id]\n", "\n", " p = random.sample(prompts, 1)[0]\n", " p = [s.replace('{graph}', f\"{graph_type_map[graph]}\").replace('{lang}', f\"{lang}\") for s in p]\n", " \n", " response = p[1]\n", " # deal with answer first in the response before plugging in the node text to avoid replacing something in the code\n", " if any(node_type.startswith(l) for l in 'aeio'):\n", " response = response.replace(' a ', ' an ')\n", " response = response.replace('{answer}', node_type)\n", " response = capitalize(response)\n", " \n", " if '\\n' in node_text:\n", " node_text = f\"\\n```\\n{node_text}\\n```\\n\"\n", " assert ph1 not in node_text and ph2 not in node_text and ph3 not in node_text and ph4 not in node_text and ph5 not in node_text\n", " q = replace_place_holder(p[0], node_text)\n", " response = replace_place_holder(response, node_text)\n", " else:\n", " node_text = f\"`{node_text}`\"\n", " q = p[0].replace('{node}', node_text)\n", " response = response.replace('{node}', node_text)\n", "\n", " source = source.strip('\\n')\n", " q = f\"```\\n{source}\\n```\\n\\n{q}\"\n", " question.append(q)\n", " bot.append(response)\n", " result.append(node_id)\n", "\n", " df['question'] = question\n", " df['bot'] = bot\n", " df = df.drop(columns={'text', 'source', 'node_ids', 'edge_index'})\n", " df.to_json(f\"{out_dir}/Node_Classification_{lang}_{graph}.jsonl\", orient='records', lines=True)\n", " results[f\"{lang}-{graph}\"] = result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## parent node" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "questions = [\n", " 'In the {graph} of this {lang} program, what is the parent node of this {node_type}: {node}.',\n", " 'What is the parent of {node_type} {node} in the {graph} of this {lang} program?',\n", " 'What is the parent node of {node_type} {node} in the {graph} of this {lang} program?',\n", " 'Based on the {graph} of this {lang} program, identify the parent of {node_type} {node}.',\n", " 'Based on the {graph} of this {lang} program, identify the parent of this {node_type}: {node}.',\n", " 'Identify the parent of {node_type} {node} in the {graph} of this {lang} program.',\n", " \"In the {graph} of the {lang} program presented, what is the predecessor of {node_type} {node}?\",\n", " \"What node acts as the parent to {node_type} {node} in the {graph} of the displayed {lang} program?\",\n", " \"Can you determine the parent node of {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Which node is directly above {node_type} {node} in the hierarchy of the {graph} of the provided {lang} program?\",\n", " \"Whose child is {node_type} {node} within the {graph} of this {lang} program?\",\n", " \"What is the immediate ancestor of the {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Regarding the {graph} of this {lang} program, can you point out the parent of {node_type} {node}?\",\n", " \"In terms of graph theory, what is the parent of the {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Who has the parental role for {node_type} {node} in the {graph}'s topology of this {lang} program?\",\n", " \"For {node_type} {node} in the {graph} of the given {lang} program, which node supplies the incoming edge?\",\n", "]\n", "answers1 = [\n", " \"In the {graph} of the given {lang} program, the parent of the given {node_type} is {parent}, which is a {parent_type}.\",\n", " \"This {node_type}'s parent is the {parent_type} {parent}.\",\n", " \"The given {node_type}'s parent in the {graph} of this {lang} program is the {parent_type} {parent}.\",\n", " \"The parent of {node_type} {node} in the {graph} of this {lang} program is identified as {parent}, categorized as a {parent_type}.\",\n", " \"In the structure of the {graph} of this {lang} program, {node_type} {node} finds its parent in node {parent}, which is a {parent_type}.\",\n", " \"Node {parent}, a {parent_type}, serves as the parent to {node_type} {node} in the {graph} of this {lang} program.\",\n", " \"As per the hierarchy in the {graph}, the {parent_type} node {parent} is the direct predecessor to {node_type} {node}.\",\n", " \"Upon inspection, it is clear that the parent of {node_type} {node} is the {parent_type} {parent}.\",\n", " \"The {node_type} {node} is immediately descended from {parent}, a {parent_type} in the {graph} of this {lang} program.\",\n", " \"{node_type} {node}'s parental node is determined to be {parent}, which falls into the category of {parent_type}.\",\n", " \"For {node_type} {node}, its lineage traces back to the {parent_type} node {parent} as its parent.\",\n", " \"Within the nodal arrangement of the {graph}, {parent} is the progenitor to {node_type} {node}, having the classification of a {parent_type}.\",\n", " \"Tracing the edges leads to confirming {parent}, a {parent_type}, as the parent of {node_type} {node}.\"\n", "]\n", "answers2 = [\n", " 'This {node_type} has no parent in the {graph} of this {lang} program.',\n", " 'This {node_type} has no parent in the {graph} of the given {lang} program.',\n", " 'There is no edge pointing to this {node_type} in the {graph}. Therefore it does not have any parent.',\n", " 'There is no edge pointing to this {node_type} in the {graph} of the given {lang} program. Therefore it does not have any parent.',\n", " \"Within the confines of the {graph} of this {lang} program, {node_type} {node} does not have a parent node.\",\n", " \"{node_type} {node} stands without a parent in the {graph}'s structure.\",\n", " \"No parent node is associated with {node_type} {node} in the {graph} of the provided {lang} program.\",\n", " \"A review of the code establishes that there is no preceding node to {node_type} {node} in the {graph}; it has no parent.\",\n", " \"The {node_type} designated as {node} appears to lack a parental connection within the {graph} of this code.\",\n", " \"In terms of graph topology, {node_type} {node} is an orphan node with no parent.\",\n", " \"There is no edge incoming to {node_type} {node}, indicating the absence of a parent in the {graph} of this {lang} program.\",\n", " \"After analyzing the code, it becomes evident that {node_type} {node} lacks a directly linked parent node in the {graph}.\",\n", " \"The {graph} denotes that {node_type} {node} is disconnected from any parental lineage.\",\n", " \"As depicted in the code, {node_type} {node} exists without a parent node to claim in the {graph}.\",\n", "]\n", "answers3 = [\n", " \"There are multiple parents of this {node_type} in the {graph}:\\n\",\n", " \"This {node_type} has more than one parent in the {graph}:\\n\"\n", "]\n", "print(len(questions), len(set(questions)))\n", "print(len(answers1), len(set(answers1)))\n", "print(len(answers2), len(set(answers2)))\n", "print(len(answers3), len(set(answers3)))\n", "assert all(a.count('{graph}') == 1 for a in questions)\n", "assert all(a.count('{lang}') == 1 for a in questions)\n", "\n", "bots = [a for a in answers1]\n", "bots_none = [a for a in answers2]\n", "bots_multiple = [a for a in answers3]\n", "prompts = [[q, b] for q in questions for b in bots]\n", "print(len(prompts))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "set_seed(1)\n", "\n", "results = {}\n", "for lang in ['Java', 'Python']:\n", " for graph in ['DFG', 'AST']:\n", " result = []\n", " df = pd.read_json(f\"{in_dir}/{lang}_{graph}.jsonl\", lines=True)\n", " if lang == 'Python':\n", " df = filter_df(df)\n", " \n", " question, bot = [], []\n", " for i in range(len(df)):\n", "\n", " # filter out nodes that occur multiple times in the source code\n", " node_texts = df.loc[i]['text']\n", " node_ids = df.loc[i]['node_ids']\n", " source = df.loc[i]['source']\n", " edge_index = torch.tensor(df.loc[i]['edge_index'])\n", " assert len(node_ids) == len(node_texts)\n", "\n", " occurrences = np.array([source.count(t) for t in node_texts])\n", " nodes_single_occurrence = np.where(occurrences == 1)[0]\n", " nodes_with_parents = [n for n in nodes_single_occurrence if n in edge_index[:, 1]]\n", " nodes_without_parents = [n for n in nodes_single_occurrence if n not in edge_index[:, 1]]\n", " \n", " # we roughly maintain a balanced distribution\n", " if random.random() < 0.75 and len(nodes_with_parents) > 0:\n", " node = random.sample(nodes_with_parents, 1)[0]\n", " elif len(nodes_without_parents) > 0:\n", " node = random.sample(nodes_without_parents, 1)[0]\n", " else:\n", " node = np.random.choice(nodes_single_occurrence, 1)[0]\n", " \n", " node_text = node_texts[node]\n", " node_id = node_ids[node]\n", " node_type = NODE_TYPES[node_id]\n", " edge_to_node = [edge for edge in edge_index if edge[1] == node]\n", "\n", " p = (random.sample(prompts, 1)[0] + random.sample(bots_none, 1) + random.sample(bots_multiple, 1)).copy()\n", " assert p[2] in bots_none\n", " p = [s.replace('{graph}', f\"{graph_type_map[graph]}\").replace('{lang}', f\"{lang}\") for s in p]\n", "\n", " # deal with answer first in the response before plugging in the node text to avoid replacing something in the code\n", " num_parents = len(edge_to_node)\n", " response = p[2] if num_parents == 0 else (p[1] if num_parents == 1 else p[3])\n", " response = capitalize(response.replace('{node_type}', node_type))\n", "\n", " if num_parents > 1:\n", " # no problem here\n", " for j in range(num_parents):\n", " parent_node = edge_to_node[j][0]\n", " parent_text = node_texts[parent_node]\n", " parent_id = node_ids[parent_node]\n", " parent_type = NODE_TYPES[parent_id]\n", " if '\\n' in parent_text:\n", " parent_text = f\"\\n```\\n{parent_text}\\n```\\n\"\n", " response += f\"{parent_type}:{parent_text}\"\n", " else:\n", " parent_text = f\"`{parent_text}`\"\n", " response += f\"{parent_type}: {parent_text}\\n\"\n", " elif num_parents == 1:\n", " parent_node = edge_to_node[0][0]\n", " parent_text = node_texts[parent_node]\n", " parent_id = node_ids[parent_node]\n", " parent_type = NODE_TYPES[parent_id]\n", " if any(parent_type.startswith(l) for l in 'aeio'):\n", " response = response.replace(' a ', ' an ')\n", " if '\\n' in parent_text:\n", " parent_text = f\"\\n```\\n{parent_text}\\n```\\n\"\n", " response = replace_place_holder(response, parent_text, \"{parent}\")\n", " else:\n", " parent_text = f\"`{parent_text}`\"\n", " response = response.replace('{parent}', parent_text)\n", " response = response.replace('{parent_type}', parent_type) \n", " \n", " # now deal with node text\n", " assert response.count('{node}') <= 1\n", " if '\\n' in node_text:\n", " node_text = f\"\\n```\\n{node_text}\\n```\\n\"\n", " # note that now response may contain \"\\n,\" patterns\n", " q = replace_place_holder(p[0].replace('{node_type}', node_type), node_text)\n", " response = replace_place_holder(response, node_text)\n", " else:\n", " node_text = f\"`{node_text}`\"\n", " q = p[0].replace('{node_type}', node_type).replace('{node}', node_text)\n", " response = response.replace('{node}', node_text)\n", "\n", " source = source.strip('\\n')\n", " q = f\"```\\n{source}\\n```\\n\\n{q}\"\n", " question.append(q)\n", " bot.append(response)\n", " result.append(num_parents)\n", "\n", " df['question'] = question\n", " df['bot'] = bot\n", " df = df.drop(columns={'text', 'source', 'node_ids', 'edge_index'})\n", " df.to_json(f\"{out_dir}/Parent_{lang}_{graph}.jsonl\", orient='records', lines=True)\n", " results[f\"{lang}-{graph}\"] = result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Children" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "questions = [\n", " 'In the {graph} of this {lang} program, what are the children of this {node_type}: {node}.',\n", " 'Identify all children of {node_type} {node} in the {graph} of this {lang} program.',\n", " 'Find the child nodes of {node_type} {node} in the {graph} of this {lang} program.',\n", " 'In the {graph} of this {lang} program, how many children does the {node_type} {node} have? What are they?',\n", " \"How many children does {node_type} {node} have in the {graph} of this {lang} program? What are they?\",\n", " 'Please find all children of {node_type} {node} in the {graph} of this {lang} program.',\n", " 'Can you find all children of {node_type} {node} in the {graph} of this {lang} program?',\n", " \"List all the descendant nodes of {node_type} {node} in the {graph} of this {lang} program.\",\n", " \"What are the direct children of the {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Can you enumerate the offspring of {node_type} {node} within the {graph} of this {lang} program?\",\n", " \"Could you provide the list of child nodes attached to {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Please identify the child nodes emanating from {node_type} {node} in the {graph} of this {lang} program.\",\n", " \"Show me the child nodes of {node_type} {node} in the {graph} of this {lang} program.\",\n", " \"What nodes are directly connected to {node_type} {node} as its children in the {graph} of this {lang} program?\",\n", " \"I need to know all the child elements of {node_type} {node} in the {graph} of this {lang} program. Can you provide that?\",\n", " \"Are there any nodes that directly derive from {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Which nodes act as successors to the node tagged as {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"What are the adjacent nodes that are children of {node_type} {node} in the {graph} of this {lang} program?\",\n", " \"Identify the nodes that are immediate successors of {node_type} {node} in the {graph} of this {lang} program.\",\n", " \"Detail the nodes branching from {node_type} {node} in the {graph} of this {lang} program.\",\n", " \"Reveal all nodes that are directly beneath {node_type} {node} in the topology of the {graph} of this {lang} program.\",\n", "]\n", "answers1 = [\n", " \"The given {node_type} has {child_num} children in the {graph}, they are:\\n\",\n", " \"This {node_type} has {child_num} children:\\n\",\n", " \"{node_type} {node} has a total of {child_num} children in the {graph}, which are:\\n\",\n", " \"There are {child_num} child nodes of {node_type} {node}, specifically:\\n\",\n", " \"As for the children of {node_type} {node}, you will find {child_num} direct descendants:\\n\",\n", " \"The count of {node_type} {node}'s children amounts to {child_num}. They include:\\n\",\n", " \"Upon identification, {node_type} {node} appears to have {child_num} offspring, namely:\\n\",\n", " \"{node_type} {node} is parent to the following {child_num} nodes:\\n\",\n", " \"A list of the {child_num} children under {node_type} {node} is as follows:\\n\",\n", " \"Directly under {node_type} {node}, there are {child_num} children listed as:\\n\",\n", " \"{node_type} {node} holds the hierarchy over {child_num} child nodes, which are:\\n\",\n", " \"{child_num} children spring from {node_type} {node}, which are given below:\\n\",\n", "]\n", "answers2 = [\n", " \"This {node_type} does not have any child nodes in the {graph}.\",\n", " \"This {node_type} does not have any children in the {graph}.\",\n", " \"There are no children of this {node_type} in the {graph} of the given code.\",\n", " \"The given {node_type} does not have any children in the {graph}.\",\n", " \"After examining the code, it's determined that in the {graph} this {node_type} has no children.\",\n", " \"{node_type} {node} stands alone with zero child nodes descending from it.\",\n", " \"I've checked the {node_type} {node} and found it has no direct descendants.\",\n", " \"There are no child nodes attached to {node_type} {node} in the {graph} of this program.\",\n", " \"No descendants can be traced from this {node_type}.\",\n", " \"The {node_type} {node} is devoid of child nodes within the {graph} of the code.\",\n", " \"Upon inspection, no nodes emerge as children of {node_type} {node}.\",\n", " \"{node_type} {node} exists without progeny in the hierarchical layout.\",\n", " \"It appears {node_type} {node} has no children.\",\n", "]\n", "\n", "print(len(questions), len(set(questions)))\n", "print(len(answers1), len(set(answers1)))\n", "print(len(answers2), len(set(answers2)))\n", "assert all(a.count('{answer}') == 1 for a in answers)\n", "assert all(a.count('{graph}') == 1 for a in questions)\n", "assert all(a.count('{lang}') == 1 for a in questions)\n", "\n", "bots = [a for a in answers1]\n", "bots_none = [a for a in answers2]\n", "prompts = [[q, b] for q in questions for b in bots]\n", "print(len(prompts))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "set_seed(2)\n", "\n", "results = {}\n", "for lang in ['Java', 'Python']:\n", " for graph in ['DFG', 'AST']:\n", " result = []\n", " df = pd.read_json(f\"{in_dir}/{lang}_{graph}.jsonl\", lines=True)\n", " if lang == 'Python':\n", " df = filter_df(df)\n", " \n", " question, bot = [], []\n", " selected_idx = []\n", " for i in range(len(df)):\n", "\n", " # filter out nodes that occur multiple times in the source code\n", " node_texts = df.loc[i]['text']\n", " node_ids = df.loc[i]['node_ids']\n", " source = df.loc[i]['source']\n", " edge_index = torch.tensor(df.loc[i]['edge_index'])\n", "\n", " occurrences = np.array([source.count(t) for t in node_texts])\n", " nodes_single_occurrence = np.where(occurrences == 1)[0]\n", " nodes_with_children = [n for n in nodes_single_occurrence if n in edge_index[:, 0]]\n", " nodes_without_children = [n for n in nodes_single_occurrence if n not in edge_index[:, 0]]\n", " \n", " # we roughly maintain a balanced distribution\n", " if random.random() < 0.85 and len(nodes_with_children) > 0:\n", " node = random.sample(nodes_with_children, 1)[0]\n", " elif len(nodes_without_children) > 0:\n", " node = random.sample(nodes_without_children, 1)[0]\n", " else:\n", " node = np.random.choice(nodes_single_occurrence, 1)[0]\n", " \n", " node_text = node_texts[node]\n", " node_id = node_ids[node]\n", " node_type = NODE_TYPES[node_id]\n", " edge_from_node = [edge for edge in edge_index if edge[0] == node]\n", "\n", " p = (random.sample(prompts, 1)[0] + random.sample(bots_none, 1)).copy()\n", " assert p[1] in bots\n", " p = [s.replace('{graph}', f\"{graph_type_map[graph]}\").replace('{lang}', f\"{lang}\") for s in p]\n", "\n", " num_children = len(edge_from_node)\n", " if num_children > 10:\n", " continue\n", " else:\n", " selected_idx.append(i)\n", " response = p[2] if num_children == 0 else p[1]\n", " response = capitalize(response.replace('{node_type}', node_type))\n", " if num_children == 1:\n", " response = response.replace('{child_num}', \"1\").replace('children', 'child').replace('nodes', 'node').replace('they are', 'it is').replace(' are', ' is').replace('descendants', 'descendant').replace('They include', 'It is').replace(' spring ', ' springs ')\n", " else:\n", " response = response.replace('{child_num}', f\"{num_children}\")\n", " \n", " if '\\n' in node_text:\n", " node_text = f\"\\n```\\n{node_text}\\n```\\n\"\n", " q = replace_place_holder(p[0].replace('{node_type}', node_type), node_text)\n", " response = replace_place_holder(response, node_text)\n", " else:\n", " node_text = f\"`{node_text}`\"\n", " q = p[0].replace('{node_type}', node_type).replace('{node}', node_text)\n", " response = response.replace('{node}', node_text)\n", " \n", " for j in range(num_children):\n", " child_node = edge_from_node[j][1]\n", " child_text = node_texts[child_node]\n", " child_id = node_ids[child_node]\n", " child_type = NODE_TYPES[child_id]\n", "\n", " if '\\n' in child_text:\n", " child_text = f\"\\n```\\n{child_text}\\n```\\n\"\n", " response += f\"{child_type}:{child_text}\"\n", " else:\n", " child_text = f\"`{child_text}`\"\n", " response += f\"{child_type}: {child_text}\\n\"\n", " if num_children != len(set((node_ids[e[1]], node_texts[e[1]]) for e in edge_from_node)):\n", " response += \"Note that there are multiple children with the same node type and literal representation.\"\n", "\n", " source = source.strip('\\n')\n", " q = f\"```\\n{source}\\n```\\n\\n{q}\"\n", " question.append(q)\n", " bot.append(response)\n", " result.append(num_children)\n", "\n", " df = df.loc[selected_idx].reset_index(drop=True)\n", " df['question'] = question\n", " df['bot'] = bot\n", " df = df.drop(columns={'text', 'source', 'node_ids', 'edge_index'})\n", " df.to_json(f\"{out_dir}/Children_{lang}_{graph}.jsonl\", orient='records', lines=True)\n", " results[f\"{lang}-{graph}\"] = result" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Edge prediction" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "questions = [\n", " \"In the {graph} of this {lang} program, is there {edge_or_link} from {node_type1} {node1} to {node_type2} {node2}?\",\n", " 'In the {graph} of this {lang} program, is there {edge_or_link} pointing from {node_type1} {node1} to {node_type2} {node2}?',\n", " \"Please tell me if there is {edge_or_link} pointing from {node_type1} {node1} to {node_type2} {node2} in the {graph} of this {lang} program.\",\n", " 'Is there {edge_or_link} from {node_type1} {node1} to {node_type2} {node2} in the {graph} of this {lang} program?',\n", " \"Does a connection exist from {node_type1} {node1} to {node_type2} {node2} in the {graph} of this {lang} program?\",\n", " \"In the {graph} of this {lang} program, do we have an arrow leading from {node_type1} {node1} to {node_type2} {node2}?\",\n", " \"Is it true that {node_type1} {node1} is a predecessor of {node_type2} {node2} in the {graph} of this {lang} program?\",\n", "]\n", "answers1 = [\n", " \"Yes, that is the case.\",\n", " \"Yes, there is {edge_or_link} from {node_type1} {node1} to {node_type2} {node2}.\",\n", " \"Yes, there is {edge_or_link} from {node_type1} {node1} to {node_type2} {node2} in the {graph} of this code.\",\n", " \"Yes, there is {edge_or_link} pointing from {node_type1} {node1} to {node_type2} {node2} in the {graph}.\",\n", " \"Affirmative, there exists {edge_or_link} from {node_type1} {node1} to {node_type2} {node2}.\",\n", " \"Yes, that is the case. {node1} is directly connected to {node2}.\",\n", "]\n", "answers2 = [\n", " \"No, that is not the case.\",\n", " \"No, {node_type1} {node1} is not linked to {node_type2} {node2} by any edge in the {graph} of the given code.\",\n", " \"No, there is no {edge_or_link} from {node_type1} {node1} to {node_type2} {node2}.\",\n", " \"No, such {edge_or_link} is absent from the {graph}.\",\n", " \"The code does not show {node_type1} {node1} as a predecessor to {node_type2} {node2} in the {graph}.\",\n", "]\n", "\n", "print(len(questions), len(set(questions)))\n", "print(len(answers1), len(set(answers1)))\n", "print(len(answers2), len(set(answers2)))\n", "assert all(a.count('{graph}') == 1 for a in questions)\n", "assert all(a.count('{lang}') == 1 for a in questions)\n", "\n", "bots = [a for a in answers1]\n", "bots_none = [a for a in answers2]\n", "prompts = [[q, b] for q in questions for b in bots]\n", "print(len(prompts))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "set_seed(3)\n", "results = {}\n", "for lang in ['Java', 'Python']:\n", " for graph in ['DFG', 'AST']:\n", " result = []\n", " df = pd.read_json(f\"{in_dir}/{lang}_{graph}.jsonl\", lines=True)\n", " if lang == 'Python':\n", " df = filter_df(df)\n", " \n", " question, bot = [], []\n", " for i in range(len(df)):\n", "\n", " # filter out nodes that occur multiple times in the source code\n", " node_texts = df.loc[i]['text']\n", " node_ids = df.loc[i]['node_ids']\n", " source = df.loc[i]['source']\n", " edge_index = df.loc[i]['edge_index']\n", "\n", " occurrences = np.array([source.count(t) for t in node_texts])\n", " nodes_single_occurrence = np.where(occurrences == 1)[0]\n", " edge_index_elligible = [e for e in edge_index if (e[0] in nodes_single_occurrence and e[1] in nodes_single_occurrence)]\n", " if graph == 'AST' and random.random() > 0.1:\n", " edge_index_elligible = [e for e in edge_index_elligible if (node_texts[e[1]] not in node_texts[e[0]])]\n", " \n", " # we make sure at least half the problems have positive answer\n", " if random.random() < 0.75 and len(edge_index_elligible) > 0:\n", " n1, n2 = random.sample(edge_index_elligible, 1)[0]\n", " else:\n", " n1, n2 = np.random.choice(nodes_single_occurrence, 2)\n", " \n", " n1_text, n2_text = node_texts[n1], node_texts[n2]\n", " n1_type, n2_type = NODE_TYPES[node_ids[n1]], NODE_TYPES[node_ids[n2]]\n", "\n", " p = random.sample(prompts, 1)[0] + random.sample(bots_none, 1)\n", " p = [s.replace('{graph}', f\"{graph_type_map[graph]}\").replace('{lang}', f\"{lang}\") for s in p]\n", " edge_or_link = 'an edge' if random.random() < 0.5 else 'a link'\n", " p = [s.replace('{edge_or_link}', edge_or_link) for s in p[:-1]] + [p[-1].replace('such {edge_or_link}', f\"such {edge_or_link}\").replace('{edge_or_link}', edge_or_link.split()[-1])]\n", " \n", " q, b = '', ''\n", " b = p[1] if [n1, n2] in edge_index else p[2]\n", " b = b.replace('{node_type1}', n1_type).replace('{node_type2}', n2_type)\n", "\n", " if '\\n' in n1_text:\n", " n1_text = f\"\\n```\\n{n1_text}\\n```\\n\"\n", " q = replace_place_holder(p[0].replace('{node_type1}', n1_type).replace('{node_type2}', n2_type), n1_text, \"{node1}\")\n", " b = replace_place_holder(b, n1_text, \"{node1}\")\n", " else:\n", " n1_text = f\"`{n1_text}`\"\n", " q = p[0].replace('{node_type1}', n1_type).replace('{node_type2}', n2_type).replace('{node1}', n1_text)\n", " b = b.replace('{node1}', n1_text)\n", " \n", " if '\\n' in n2_text:\n", " n2_text = f\"\\n```\\n{n2_text}\\n```\\n\"\n", " q = replace_place_holder(q, n2_text, \"{node2}\")\n", " b = replace_place_holder(b, n2_text, \"{node2}\")\n", " else:\n", " n2_text = f\"`{n2_text}`\"\n", " q = q.replace('{node2}', n2_text)\n", " b = b.replace('{node2}', n2_text)\n", " \n", " source = source.strip('\\n')\n", " q = f\"```\\n{source}\\n```\\n\\n{q}\"\n", " question.append(q)\n", " bot.append(b)\n", " result.append(int([n1, n2] in edge_index))\n", "\n", " df['question'] = question\n", " df['bot'] = bot\n", " df = df.drop(columns={'text', 'source', 'node_ids', 'edge_index'})\n", " df.to_json(f\"{out_dir}/Edge_Prediction_{lang}_{graph}.jsonl\", orient='records', lines=True)\n", " results[f\"{lang}-{graph}\"] = result" ] } ], "metadata": { "kernelspec": { "display_name": "py39", "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.17" } }, "nbformat": 4, "nbformat_minor": 2 }