visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "HPRwsi0Nk84I",
   "metadata": {
    "id": "HPRwsi0Nk84I"
   },
   "source": [
    "# Explainable Neural Binary Analysis\n",
    "\n",
    "CS7295 Visualization for Machine Learning\n",
    "\n",
    "Jane Adams and Michael Davinroy\n",
    "\n",
    "\n",
    "**IMPORTANT**: This notebook will not work in Google Drive. Please download and run locally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "roAkvUzZaDZn",
   "metadata": {
    "id": "roAkvUzZaDZn"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "!pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2f6a726",
   "metadata": {
    "id": "f2f6a726"
   },
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import json\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from EoN import hierarchy_pos\n",
    "import plotly.express as px\n",
    "import plotly.graph_objects as go\n",
    "import itertools\n",
    "from urllib.request import urlopen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "60e6b7ca",
   "metadata": {
    "id": "60e6b7ca"
   },
   "outputs": [],
   "source": [
    "# Data: https://github.com/Cisco-Talos/binary_function_similarity\n",
    "# GNN: https://github.com/deepmind/deepmind-research/tree/master/graph_matching_networks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "73511de2",
   "metadata": {
    "id": "73511de2"
   },
   "outputs": [],
   "source": [
    "data_dict = {\n",
    "    'node':'Function Address',\n",
    "    'bb_len': 'Length of Basic Blocks',\n",
    "    'instruction_count': 'Number of Instructions',\n",
    "    'bb_mnems': 'Instruction Mnemonics',\n",
    "    'source_count': 'Departures from this function', \n",
    "    'target_count': 'Arrivals to this function'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "64dd740c",
   "metadata": {
    "id": "64dd740c"
   },
   "outputs": [],
   "source": [
    "debug=True\n",
    "dataset = 'Dataset-1'\n",
    "testtrain = 'testing'\n",
    "cutoff = 50\n",
    "rel_path = 'http://dev.universalities.com/nba/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "896c2437",
   "metadata": {
    "id": "896c2437"
   },
   "outputs": [],
   "source": [
    "def get_simDF(dataset=dataset, testtrain=testtrain, cutoff=cutoff, rank=True, subset='OPC-200'):\n",
    "    sim_dfs = []\n",
    "    for posneg in ['pos','neg']:\n",
    "        path = f'{rel_path}sim_scores/{posneg}{\"_rank\" if rank else \"\"}_{testtrain}_{dataset}_GGSNN_{subset}_e10.csv'\n",
    "        print(f'Accessing similarity data path {path}...')\n",
    "        df = pd.read_csv(path)\n",
    "        df['class'] = posneg\n",
    "        df['distance']=[-s for s in df['sim']]\n",
    "        df = df.sample(n=cutoff).sort_values(by='distance').reset_index().drop(columns='index')\n",
    "        sim_dfs.append(df)\n",
    "    simDF = pd.concat(sim_dfs).sort_index(kind='merge').reset_index().drop(columns='index')\n",
    "    return simDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "075d83bb",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 424
    },
    "id": "075d83bb",
    "outputId": "395ceebb-e1a7-4e5d-9668-e7f8d8e1d39f"
   },
   "outputs": [],
   "source": [
    "#simDF = get_simDF(rank=False)\n",
    "simDF = pd.read_csv(f'{rel_path}sample_sim.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "98f1faa5",
   "metadata": {
    "id": "98f1faa5"
   },
   "outputs": [],
   "source": [
    "def visualize_simDF(simDF):\n",
    "    fig = px.histogram(simDF, x='distance', color='class', range_x=[0,100])\n",
    "    fig.update_layout(\n",
    "        template='plotly_white',\n",
    "        title=f'Histogram of {dataset} Euclidean Distance by Classification',\n",
    "        #width=600,\n",
    "        #height=400\n",
    "    )\n",
    "    fig.update_xaxes(title='Euclidean Distance')\n",
    "    fig.update_yaxes(title='Count')\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d872b94b",
   "metadata": {
    "id": "d872b94b"
   },
   "outputs": [],
   "source": [
    "model_explorer = visualize_simDF(simDF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c163e31e",
   "metadata": {
    "id": "c163e31e"
   },
   "outputs": [],
   "source": [
    "def get_feature_paths(idb, t='acfg_disasm', db=dataset, testtrain='testing'):\n",
    "    stripped = idb.split('/')[-1][:-4]\n",
    "    if 'acfg' in t:\n",
    "        return f'{rel_path}DBs/{db}/features/{testtrain}/{t}_{db}_{testtrain}/{stripped}_{t}.json'\n",
    "    if t == 'fss':\n",
    "        return f'{rel_path}DBs/{db}/features/{testtrain}/{t}_{db}_{testtrain}/{stripped}_Capstone_True_fss.json'\n",
    "    else: return 'ERR'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8cd1fc70",
   "metadata": {
    "id": "8cd1fc70"
   },
   "outputs": [],
   "source": [
    "def get_full_binary(filepath):\n",
    "    print(f'Accessing similarity data path {filepath}...')\n",
    "    response = urlopen(filepath)\n",
    "    o = json.loads(response.read())\n",
    "    l = len(list(o.keys()))\n",
    "    if (l > 1):\n",
    "        print(f'Warning! Code contains {l} keys')\n",
    "    code = o[list(o.keys())[0]]\n",
    "    #print(f'Binary contains {len(list(code.keys()))} functions')\n",
    "    return code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7a58a814",
   "metadata": {
    "id": "7a58a814"
   },
   "outputs": [],
   "source": [
    "def filter_edges(function):\n",
    "    problem_targets = []\n",
    "    for e_item in list(itertools.chain(*function['edges'])):\n",
    "        if e_item not in function['nodes']:\n",
    "            print()\n",
    "            print(\"*** WARNING ****\")\n",
    "            print(f'{e_item} not in node list')\n",
    "            problem_targets.append(e_item)\n",
    "            print()\n",
    "    new_edges = []\n",
    "    for edge in function['edges']:\n",
    "        for problem in problem_targets:\n",
    "            if problem in edge:\n",
    "                if debug: print(f'Removed {edge} from network')\n",
    "            else:\n",
    "                new_edges.append(edge)\n",
    "    function['edges']=new_edges\n",
    "    return function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b7fd788c",
   "metadata": {
    "id": "b7fd788c"
   },
   "outputs": [],
   "source": [
    "def extract_network(address, binary, filter_e=False):\n",
    "    function = binary[address]\n",
    "    if filter_e:\n",
    "        function = filter_edges(function)\n",
    "    return function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "319e4a95",
   "metadata": {
    "id": "319e4a95"
   },
   "outputs": [],
   "source": [
    "def remove_components(G, nodeDF, edgeDF):\n",
    "    components = list(nx.connected_components(G))\n",
    "    if debug:\n",
    "        print(f'Found {len(list(components))} components in the graph')\n",
    "    if len(list(components))>1:\n",
    "        if debug: print(f'Filtering graph of size {len(list(G.nodes()))}...')\n",
    "        trees = []\n",
    "        subgraphs = []\n",
    "        for i, node_list in enumerate(components):\n",
    "            if debug:\n",
    "                #print(f'node_list: {list(node_list)}')\n",
    "                print(f'Component #{i} has {len(node_list)} nodes')\n",
    "            Gc = G.subgraph(list(node_list))\n",
    "            if nx.is_tree(Gc):\n",
    "                if debug: print(f'...and is tree')\n",
    "                trees.append(Gc)\n",
    "            else:\n",
    "                if debug: print(f'...and is NOT a tree')\n",
    "                subgraphs.append(Gc)\n",
    "            if debug: print()\n",
    "        if debug:\n",
    "            print(f'Found {len(trees)} tree(s) and {len(subgraphs)} non-tree subgraphs')\n",
    "        if len(trees)>0:\n",
    "            G = trees[0].copy()\n",
    "        else:\n",
    "            G = subgraphs[0].copy()\n",
    "        if debug: print(f'Filtered graph to size {len(list(G.nodes()))}')\n",
    "        nodeDF = nodeDF.filter(items = list(G.nodes()), axis=0)\n",
    "        for i in nodeDF.index:\n",
    "            if i not in list(G.nodes()):\n",
    "                if debug: print(f'Removing {i} from nodeDF')\n",
    "        edgeDF = edgeDF[edgeDF[['source','target']].isin(list(G.nodes())).any(1)]\n",
    "    return G, nodeDF, edgeDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "da02c1d9",
   "metadata": {
    "id": "da02c1d9"
   },
   "outputs": [],
   "source": [
    "def parse_network(network, debug=True, remove_c=False):\n",
    "    data_cols = ['node','bb_len', 'bb_mnems', 'bb_norm', 'bb_disasm', 'b64_bytes', 'bb_heads', 'source_count', 'target_count']\n",
    "    edgeDF = pd.DataFrame(network[\"edges\"], columns=['source','target'])\n",
    "    nodeDF = pd.DataFrame(columns=data_cols)\n",
    "    for n in network[\"nodes\"]:\n",
    "        metadata = network['basic_blocks'][str(n)].copy()\n",
    "        metadata['node'] = n\n",
    "        metadata['source_count'] = list(edgeDF['source']).count(n)\n",
    "        metadata['target_count'] = list(edgeDF['target']).count(n)\n",
    "        nodeDF = pd.concat([nodeDF, pd.DataFrame.from_records([metadata])])\n",
    "    nodeDF['instruction_count'] = [len(m) for m in nodeDF['bb_mnems']]\n",
    "    nodeDF = nodeDF.sort_values(by='target_count').set_index('node')\n",
    "    G = nx.from_pandas_edgelist(edgeDF)\n",
    "    if remove_c:\n",
    "        G, nodeDF, edgeDF = remove_components(G, nodeDF, edgeDF)\n",
    "    root = nodeDF.sort_values(by='source_count').index[0]\n",
    "    if debug: print(f'Root node: {root}')\n",
    "    try:\n",
    "        pos = hierarchy_pos(G, root=root)\n",
    "        if debug: print('Hierarchical positioning worked!')\n",
    "    except:\n",
    "        pos=nx.kamada_kawai_layout(G)\n",
    "        if debug: print('Hierarchical positioning failed; using spring layout instead')\n",
    "    \n",
    "    def get_pos(node):\n",
    "        try:\n",
    "            return pos[node]\n",
    "        except:\n",
    "            return (-1,-1)\n",
    "    \n",
    "    nodeDF[['y','x']] = [get_pos(n) for n in nodeDF.index]\n",
    "    nodeLookup = nodeDF.to_dict(orient='index')\n",
    "    \n",
    "    def get_xy(s, t, xy, debug=True):\n",
    "        x = None\n",
    "        y = None\n",
    "        try:\n",
    "            x = nodeLookup[s][xy]\n",
    "        except:\n",
    "            if debug: print(f'Failed to find source {s} in node list!')\n",
    "            x = x\n",
    "        try:\n",
    "            y = nodeLookup[t][xy]\n",
    "        except:\n",
    "            if debug: print(f'Failed to find target {t} in node list!')\n",
    "            y = y\n",
    "        return [x, y]\n",
    "    \n",
    "    edgeDF['x'] = [get_xy(s,t,'x') for s,t in zip(edgeDF['source'], edgeDF['target'])]\n",
    "    edgeDF['y'] = [get_xy(s,t,'y') for s,t in zip(edgeDF['source'], edgeDF['target'])]\n",
    "    edges = {'x':[], 'y':[]}\n",
    "    for i,e in edgeDF.iterrows():\n",
    "        edges['x'].extend(e['x'])\n",
    "        edges['x'].append(None)\n",
    "        edges['y'].extend(e['y'])\n",
    "        edges['y'].append(None)\n",
    "    return nodeDF, edgeDF, edges"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2c2c3015",
   "metadata": {
    "id": "2c2c3015"
   },
   "outputs": [],
   "source": [
    "def make_network_fig(nodeDF, edges, meta=None):\n",
    "    root = nodeDF.sort_values(by='source_count').index[0]\n",
    "    fig = go.Figure(layout=go.Layout(\n",
    "                    title='Network graph made with Python',\n",
    "                    titlefont_size=16,\n",
    "                    showlegend=False,\n",
    "                    hovermode='closest',\n",
    "                    margin=dict(b=20,l=5,r=5,t=40),\n",
    "                    xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
    "                    yaxis=dict(showgrid=False, zeroline=False, showticklabels=False))\n",
    "                    )\n",
    "    fig.add_trace(\n",
    "        go.Scatter(x=edges['x'], y=edges['y'], mode='lines',\n",
    "                   line=dict(width=2, color='#888'),\n",
    "                   hoverinfo='none'\n",
    "                  )\n",
    "    )\n",
    "    fig.add_trace(\n",
    "        go.Scatter(x=nodeDF['x'], y=nodeDF['y'], text=[str(m) for m in nodeDF['bb_mnems']], mode='markers',\n",
    "                   marker=dict(\n",
    "                        showscale=True,\n",
    "                        colorscale='YlGnBu',\n",
    "                        reversescale=False,\n",
    "                        color=nodeDF['instruction_count'],\n",
    "                        size=20,\n",
    "                        colorbar=dict(\n",
    "                            thickness=15,\n",
    "                            title='Instruction Count',\n",
    "                            xanchor='left',\n",
    "                            titleside='right'\n",
    "                        ),\n",
    "                        line=dict(\n",
    "                            color=['red' if c==0 else 'black' for c  in nodeDF['target_count']],\n",
    "                            width=4\n",
    "                        ))\n",
    "                ))\n",
    "    fig.update_layout(showlegend=False,\n",
    "        hovermode='closest',\n",
    "        margin=dict(b=20,l=5,r=5,t=40),\n",
    "        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
    "        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),\n",
    "        template='plotly_white'\n",
    "    )\n",
    "    if meta is not None:\n",
    "        fig.update_layout(title=f\"Function: {meta['function']}<br>IDB Path: {meta['path']}<br>Arch: {meta['arch']}\")\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b77279c5",
   "metadata": {
    "id": "b77279c5"
   },
   "outputs": [],
   "source": [
    "def compare_plot(node_set, col='bb_len'):\n",
    "    label = data_dict[col]\n",
    "    fig = px.histogram(node_set, y=col, x='function', color=col, title=label, barmode='group')\n",
    "    fig.update_xaxes(title='Function')\n",
    "    fig.update_yaxes(title=label)\n",
    "    fig.update_layout(template='plotly_white')\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "bdedc344",
   "metadata": {
    "id": "bdedc344"
   },
   "outputs": [],
   "source": [
    "def setup(i, feature='bb_len', debug=True):\n",
    "    row = simDF.iloc[i]\n",
    "    networks = []\n",
    "    node_sets = []\n",
    "    for i in range(1,3):\n",
    "        meta = {'function': row[f'fva_{i}'], 'path':row[f'idb_path_{i}']}\n",
    "        meta['arch'] = meta['path'].split('/')[-1][:-4]\n",
    "        if debug:\n",
    "            print(meta)\n",
    "            print(f\"---- Looking up function {meta['function']} ----\")\n",
    "        binary = get_full_binary(get_feature_paths(meta['path']))\n",
    "        network = extract_network(meta['function'], binary)\n",
    "        nodeDF, edgeDF, edges = parse_network(network, debug=debug)\n",
    "        networks.append(make_network_fig(nodeDF, edges, meta=meta))\n",
    "        nodeDF['function'] = meta['function']\n",
    "        node_sets.append(nodeDF)\n",
    "    compare = compare_plot(pd.concat(node_sets), col=feature)\n",
    "    return networks, compare"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "627132b6",
   "metadata": {
    "id": "627132b6"
   },
   "outputs": [],
   "source": [
    "map_class = {\n",
    "    'pos': 'MATCH',\n",
    "    'neg': 'NOT MATCH'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9d8416ec",
   "metadata": {
    "id": "9d8416ec"
   },
   "outputs": [],
   "source": [
    "def format_pair(i):\n",
    "    label = f\"{list(simDF['fva_1'])[i]} vs. {list(simDF['fva_2'])[i]} ({map_class[list(simDF['class'])[i]]}, {np.round(list(simDF['distance'])[i],2)})\"\n",
    "    return {'label': label, 'value': i}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f27be8dc",
   "metadata": {
    "id": "f27be8dc"
   },
   "outputs": [],
   "source": [
    "feature_options = []\n",
    "for var_name, explanation in data_dict.items():\n",
    "    if var_name in ['bb_len', 'instruction_count','source_count','target_count']:\n",
    "        feature_options.append({'label': explanation, 'value': var_name})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c294d509",
   "metadata": {
    "id": "c294d509"
   },
   "outputs": [],
   "source": [
    "from jupyter_dash import JupyterDash\n",
    "from dash import Dash, dash_table, html, dcc, Input, Output\n",
    "import dash_daq as daq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "7efd940a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 53
    },
    "id": "7efd940a",
    "outputId": "608515fe-d687-4efd-960e-d8ba65b414e9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dash app running on http://127.0.0.1:8050/\n",
      "{'function': '0x11a1f90', 'path': 'IDBs/Dataset-1/z3/mips32-gcc-4.8-O2_z3.i64', 'arch': 'mips32-gcc-4.8-O2_z3'}\n",
      "---- Looking up function 0x11a1f90 ----\n",
      "Accessing similarity data path http://dev.universalities.com/nba/DBs/Dataset-1/features/testing/acfg_disasm_Dataset-1_testing/mips32-gcc-4.8-O2_z3_acfg_disasm.json...\n",
      "Root node: 18489880\n",
      "Hierarchical positioning failed; using spring layout instead\n",
      "Failed to find target 18491080 in node list!\n",
      "Failed to find target 18491080 in node list!\n",
      "{'function': '0x472f6c', 'path': 'IDBs/Dataset-1/nmap/mips32-gcc-4.8-O2_nmap.i64', 'arch': 'mips32-gcc-4.8-O2_nmap'}\n",
      "---- Looking up function 0x472f6c ----\n",
      "Accessing similarity data path http://dev.universalities.com/nba/DBs/Dataset-1/features/testing/acfg_disasm_Dataset-1_testing/mips32-gcc-4.8-O2_nmap_acfg_disasm.json...\n",
      "Root node: 4665564\n",
      "Hierarchical positioning failed; using spring layout instead\n"
     ]
    }
   ],
   "source": [
    "app = JupyterDash(__name__)\n",
    "\n",
    "app.layout = html.Div([\n",
    "    html.Div([\n",
    "        html.H1('Function Similarity Explorer'),\n",
    "        html.P('by Jane Adams & Michael Davinroy'),\n",
    "        dcc.Dropdown([format_pair(i) for i in simDF.index], 1, id='sim_index')\n",
    "    ]),\n",
    "    html.Div([\n",
    "        html.Div([\n",
    "            html.H1('Function #1'),\n",
    "            dcc.Graph(id='network_1'), \n",
    "        ], style={'width': '45%', 'display': 'block', 'float':'left'}),\n",
    "        html.Div([\n",
    "            html.H1('Function #2'),\n",
    "            dcc.Graph(id='network_2'), \n",
    "        ], style={'width': '45%', 'display': 'block', 'float':'right'})\n",
    "    ], style={'width': '100%', 'display': 'block'}),\n",
    "    html.Div([\n",
    "        html.Div([\n",
    "            html.H1('Feature Explorer'),\n",
    "            dcc.Dropdown(feature_options, 'bb_len', id='feature'),\n",
    "            dcc.Graph(id='importance'),\n",
    "        ], style={'width': '45%', 'display': 'block', 'float':'left'}),\n",
    "        html.Div([\n",
    "            html.H1('Model Explorer'),\n",
    "            dcc.Graph(id='model-explorer', figure=model_explorer),\n",
    "            #html.Div(id='table-container')\n",
    "        ], style={'width': '45%', 'display': 'block', 'float':'right'})\n",
    "    ], style={'width': '100%', 'display': 'block'})\n",
    "             \n",
    "], style={'marginBottom': 50, 'marginTop': 25, 'marginLeft': 50, 'marginRight':50})\n",
    "\n",
    "@app.callback(\n",
    "    [Output(component_id='network_1', component_property='figure'),\n",
    "     Output(component_id='network_2', component_property='figure'),\n",
    "     Output(component_id='importance', component_property='figure'),\n",
    "    ],\n",
    "    [Input(component_id='sim_index', component_property='value'),\n",
    "     Input(component_id='feature', component_property='value')\n",
    "    ]\n",
    ")\n",
    "def update_outputs(sim_index, feature):\n",
    "    \n",
    "    networks, importance = setup(sim_index, debug=debug, feature=feature)\n",
    "    \n",
    "    network_1, network_2 = networks[0], networks[1]\n",
    "    \n",
    "    table = dash_table.DataTable(\n",
    "        data=simDF.astype(str).to_dict('records'), # data\n",
    "        sort_action='native',\n",
    "        columns = [{\"name\": i, \"id\": i} for i in list(simDF.columns)], # columns\n",
    "        id='table',\n",
    "        style_data={\n",
    "            'whiteSpace': 'normal',\n",
    "            'height': 'auto',\n",
    "        },\n",
    "        style_table={'overflowX': 'auto'},\n",
    "        style_data_conditional=[\n",
    "        {\n",
    "            'if': {\n",
    "                'column_id': 'index',\n",
    "            },\n",
    "            'backgroundColor': 'yellow',\n",
    "            'color': 'black'\n",
    "        }]\n",
    "    )\n",
    "    \n",
    "    return network_1, network_2, importance\n",
    "\n",
    "app.run_server(debug=debug)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e848813",
   "metadata": {
    "id": "7QJLYVidtoln"
   },
   "source": [
    "# By default, dashboard will be available at [http://127.0.0.1:8050/](http://127.0.0.1:8050/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea842e3d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}