CompilingGoogle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Google Hashcode 2019 Final Round: Compiling Google"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import io\n",
    "import os\n",
    "import pathlib\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "import statistics\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "config InlineBackend.figure_format = 'retina'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def open_input(filename):\n",
    "    \n",
    "    path = str(pathlib.Path().absolute()) + \"/dataset/\" + filename + \".in\"\n",
    "\n",
    "    # Read file\n",
    "    input_file = io.open(path, mode='r')\n",
    "    # read all the lines \n",
    "    lines = input_file.readlines()\n",
    "    input_file.close()\n",
    "\n",
    "    # Parsing file information\n",
    "    # save number of file, target and server \n",
    "    [num_file,num_target,num_server] = np.fromstring(lines[0], dtype=int, sep=' ')\n",
    "\n",
    "    # conversion of read lines from list of string to list of lists \n",
    "    lines = [i.strip(\"[]\\n\").split(\" \") for i in lines]\n",
    "\n",
    "    # blank dicts\n",
    "    time = {}\n",
    "    dep = {}\n",
    "    target = {}\n",
    "\n",
    "    # build time and dep dicts\n",
    "    row=1\n",
    "\n",
    "    while row <= num_file*2:\n",
    "        # save compilation and replication time\n",
    "        time.update({lines[row][0] : [lines[row][1], lines[row][2]]})\n",
    "        row_dep=row+1\n",
    "        # check file dependencies\n",
    "        if lines[row_dep][0]== \"0\":\n",
    "            # no dependencies\n",
    "            dep.update({lines[row][0]: []})\n",
    "        else:\n",
    "            # save file dependencies\n",
    "            num_dep=int(lines[row_dep][0])\n",
    "            dep.update({lines[row][0]: lines[row_dep][-num_dep:]})\n",
    "\n",
    "        row+=2\n",
    "\n",
    "    # build target dict     \n",
    "    row=1+num_file*2\n",
    "\n",
    "    while row <= num_target+(num_file*2):\n",
    "        # save deadline and score\n",
    "        target.update({lines[row][0] : [lines[row][1], lines[row][2]]})\n",
    "        row+=1;\n",
    "\n",
    "    # conversion dicts lists from string to int\n",
    "    time = dict((k,list(map(int,v))) for k,v in time.items())\n",
    "    target = dict((k,list(map(int,v))) for k,v in target.items())\n",
    "\n",
    "    # generate file list\n",
    "    file = list(time.keys())\n",
    "\n",
    "    return num_file, num_target, num_server, file, time, dep, target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_dep_graph(dep, real_target):\n",
    "    # Build the dependencies graph\n",
    "    # ------------------------------------------------------\n",
    "    # INPUT\n",
    "    # dep = dependencies of all files\n",
    "    # real_target = target files with compile time < deadline\n",
    "    \n",
    "    # OUTPUT\n",
    "    # dep_graph = dependencies graph\n",
    "    # ------------------------------------------------------\n",
    "    \n",
    "    # Define a directed graph\n",
    "    dep_graph = nx.DiGraph()\n",
    "    \n",
    "    # Add the nodes of the graph and initialized attributes\n",
    "    dep_graph.add_nodes_from(list(dep.keys()), target=False, priority=0)\n",
    "    \n",
    "    # Add the edges of the graph\n",
    "    for file, dep_list in dep.items():\n",
    "        for d in dep_list:\n",
    "            dep_graph.add_edge(d, file)\n",
    "    \n",
    "    # Set target attribute\n",
    "    for t in real_target:        \n",
    "        dep_graph.nodes[t]['target'] = True\n",
    "        # Compute priority dividing score by deadline\n",
    "        dep_graph.nodes[t]['priority'] = target[t][1]/target[t][0] \n",
    "    \n",
    "    return dep_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def place_files(files, server_time, sequence):\n",
    "    # Assign the given files to the server with minimum time\n",
    "    # ------------------------------------------------------\n",
    "    # INPUT\n",
    "    # files = files to place on a server\n",
    "    # server_time = estimated execution time on each server\n",
    "    # sequence = list of files assigned to each server\n",
    "    \n",
    "    # OUTPUT\n",
    "    # sequence\n",
    "    # ------------------------------------------------------\n",
    "\n",
    "    # Get the index of the server with the minumum estimated execution time\n",
    "    min_ind = server_time.index(min(server_time)) \n",
    "    \n",
    "    # Place all the file on the server\n",
    "    for f in files:\n",
    "        # update the estimated execution time\n",
    "        server_time[min_ind] = server_time[min_ind] + time[f][0]\n",
    "        sequence[min_ind].append(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_predecessors(graph, source):\n",
    "    # Compute the predecessors of the given node in the graph\n",
    "    # -------------------------------------------------------\n",
    "    # INPUT\n",
    "    # graph\n",
    "    # source = node of the graph\n",
    "    \n",
    "    # OUTPUT\n",
    "    # pred = predecessors of the source\n",
    "    # ------------------------------------------------------\n",
    "    \n",
    "    if not graph.has_node(source):\n",
    "        raise nx.NetworkXError(\"The node %s is not in the graph.\" % source)\n",
    "    pred = list(n for n, d in nx.shortest_path_length(graph, target=source).items())\n",
    "    pred.remove(source)\n",
    "    pred.reverse()\n",
    "    return pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compile_greedy(num_server, dep_graph, real_target, technique):\n",
    "    # Greedy heuristic that build a possible solution\n",
    "    # ------------------------------------------------------\n",
    "    # INPUT\n",
    "    # num_server = number of servers\n",
    "    # dep_graph = dependencies graph\n",
    "    # real_target = target files with compile time < deadline\n",
    "    # technique = identifier of technique used for scheduling files on servers\n",
    "    \n",
    "    # OUTPUT\n",
    "    # sequence = list of files assigned to each server\n",
    "    # ------------------------------------------------------\n",
    "    \n",
    "    # Empty list for estimated execution time on each server\n",
    "    server_time = [0]*num_server\n",
    "    sequence = [[] for _ in range(num_server)]\n",
    "\n",
    "    # Temporary dependencies graph\n",
    "    temp_graph = dep_graph\n",
    "  \n",
    "    toggle = True\n",
    "    while toggle:\n",
    "        # Get all target files with no target in their dependencies list\n",
    "        potential_target = []\n",
    "        for t in real_target:\n",
    "            # check if t is still in the graph\n",
    "            if t in temp_graph:\n",
    "                # get the predecessors of the target\n",
    "                pred = get_predecessors(temp_graph, t)\n",
    "                # check if t has target in his dependencies list\n",
    "                no_target = True\n",
    "                for p in pred:\n",
    "                    if p in real_target:\n",
    "                        no_target = False\n",
    "                        break\n",
    "                # if t has no target in his dependencies list append t to potential targets\n",
    "                if no_target:\n",
    "                    potential_target.append(t)\n",
    "        \n",
    "        # check if there are potential targets\n",
    "        if potential_target:\n",
    "            toggle = True\n",
    "            \n",
    "            # get the target with maximum priority among the potential targets\n",
    "            max_priority = dep_graph.nodes[potential_target[0]]['priority']\n",
    "            best_target = potential_target[0]\n",
    "            \n",
    "            for t in potential_target:\n",
    "                if dep_graph.nodes[t]['priority'] > max_priority:\n",
    "                    max_priority = dep_graph.nodes[t]['priority']\n",
    "                    best_target = t        \n",
    "            \n",
    "            # get the predecessors of the best target\n",
    "            pred = get_predecessors(temp_graph, best_target)\n",
    "            \n",
    "            if pred:\n",
    "                # check the technique to use comparing median compilation and replication time\n",
    "                if technique == 1:\n",
    "                    # Technique 1: assign the target with all his predecessors to the same server \n",
    "                    pred.append(best_target)\n",
    "                    place_files(pred, server_time, sequence)\n",
    "                    # remove all the placed files\n",
    "                    temp_graph.remove_nodes_from([n for n in temp_graph if n in set(pred)])\n",
    "                \n",
    "                elif technique == 2:\n",
    "                    # Technique 2: assign predecessors file to different servers\n",
    "                    for d in dep[best_target]:\n",
    "                        if d in temp_graph:\n",
    "                            # compute the predecessors of each file in the target dependencies list\n",
    "                            pred = get_predecessors(temp_graph, d)\n",
    "                            pred.append(d)\n",
    "                            # assign the file with all his predecessors to the same server \n",
    "                            place_files(pred, server_time, sequence)\n",
    "                            # remove all the placed files\n",
    "                            temp_graph.remove_nodes_from([n for n in temp_graph if n in set(pred)])\n",
    "                    \n",
    "                    # place the target and remove it from the graph\n",
    "                    place_files([best_target], server_time, sequence)\n",
    "                    temp_graph.remove_node(best_target)\n",
    "                    \n",
    "            else:\n",
    "                # if the target has no predecessors, place the target and remove it from the graph\n",
    "                place_files([best_target], server_time, sequence)\n",
    "                temp_graph.remove_node(best_target)\n",
    "               \n",
    "        else: \n",
    "            # if there are not potential target, end the algorithm\n",
    "            toggle = False    \n",
    "            \n",
    "    return sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_graph(time, dep, sequence):\n",
    "    # Build the execution graph\n",
    "    # -------------------------------------------------\n",
    "    # INPUT\n",
    "    # time = times dictionary\n",
    "    # dep = dependencies dictionary\n",
    "    # sequence = list of files assigned to each server\n",
    "\n",
    "    # OUTPUT\n",
    "    # execution_graph = execution graph\n",
    "    # -------------------------------------------------\n",
    "    \n",
    "    # Define the directed graph of the files\n",
    "    execution_graph = nx.DiGraph()\n",
    "\n",
    "    # Add the nodes of the graph\n",
    "    for i,s in enumerate(sequence):\n",
    "        execution_graph.add_nodes_from(s, server=i+1)\n",
    "\n",
    "    # Add the edges of the graph\n",
    "    for s in sequence:    \n",
    "        # add an edge between files on the same server\n",
    "        for i in range(len(s)-1):\n",
    "            w = time[s[i]][0]\n",
    "            execution_graph.add_edge(s[i], s[i+1], weight=w, n_weight=-w, color=\"black\")\n",
    "        # add dipendencies edges for each file on a server\n",
    "        for i in range(len(s)):       \n",
    "            dep_files = dep[s[i]]\n",
    "            # check that the files has dipendencies\n",
    "            if dep_files: \n",
    "                for f in dep_files:\n",
    "                    # check that the file is on another server\n",
    "                    if f not in s:\n",
    "                        w = time[f][0] + time[f][1]\n",
    "                        execution_graph.add_edge(f, s[i], weight=w, n_weight=-w, color=\"black\")\n",
    "\n",
    "    # Add two fake nodes\n",
    "    execution_graph.add_node(\"s\", server=-1)\n",
    "    execution_graph.add_node(\"t\", server=-1)\n",
    "\n",
    "    for node in list(execution_graph.nodes):\n",
    "        if (node!=\"s\" and node!=\"t\"):\n",
    "            # if node doesn't have in-edges, add edge s -> node\n",
    "            if not execution_graph.in_edges(node):\n",
    "                execution_graph.add_edge(\"s\", node, weight=0, n_weight=0, color=\"black\")\n",
    "            # if node doesn't have out-edges, add edge node -> t\n",
    "            elif not execution_graph.out_edges(node):\n",
    "                w = time[node][0]\n",
    "                execution_graph.add_edge(node, \"t\", weight=w, n_weight=-w, color=\"black\")    \n",
    "    \n",
    "    return execution_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_longest_path(graph):\n",
    "    # Get the longest path using negative weights and Bellman-Ford algorithm\n",
    "    # ------------------------------------------------------------------------\n",
    "    # INPUT\n",
    "    # graph = execution graph\n",
    "\n",
    "    # OUTPUT\n",
    "    # graph = execution graph \n",
    "    # distance = execution times\n",
    "    # ------------------------------------------------------------------------\n",
    "    \n",
    "    distance, path = nx.algorithms.shortest_paths.weighted.single_source_bellman_ford(graph, \"s\", weight=\"n_weight\")\n",
    "    # change the color of the edge on the path\n",
    "    for key,value in path.items():\n",
    "        if len(value)>1:\n",
    "            for i in range(len(value)-1):\n",
    "                graph[value[i]][value[i+1]][\"color\"] = \"red\"\n",
    "    \n",
    "    return graph, distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_score(distance, target, time):\n",
    "    # Compute the score of the solution\n",
    "    # --------------------------------------------\n",
    "    # INPUT\n",
    "    # distance = dictionary of execution times\n",
    "    # real_target = target files with compile time < deadline\n",
    "    # time = times dictionary\n",
    "    \n",
    "    # OUTPUT\n",
    "    # score = score of the solution\n",
    "    # good_target = target with score > 0\n",
    "    # bad_target = target with score = 0\n",
    "    # --------------------------------------------\n",
    "\n",
    "    # Compute the score of the solution\n",
    "    score = 0\n",
    "    good_target=[]\n",
    "    bad_target=[]\n",
    "    \n",
    "    for file in target:\n",
    "        # check if the file target is in the given solution\n",
    "        if file in distance:\n",
    "            d = target[file][0]\n",
    "            x = -distance[file]+time[file][0]\n",
    "            # check if the file is compiled before the deadline\n",
    "            if x<=d:\n",
    "                g = target[file][1]\n",
    "                score = score + (d-x + g)\n",
    "                good_target.append(file)\n",
    "            else:\n",
    "                bad_target.append(file)\n",
    "            \n",
    "    return score, good_target, bad_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compile_improve(num_server, file, time, dep, target, max_iter):\n",
    "    # Improvement heuristic that try to improve the solution given by compile_greedy\n",
    "    # ------------------------------------------------------------------------------\n",
    "    # INPUT\n",
    "    # num_server = number of servers\n",
    "    # file = all files to compile\n",
    "    # time = times dictionary with compilation and replication time for each file\n",
    "    # dep = dependencies dictionary\n",
    "    # target = targets list\n",
    "    # max_iter = maximum number of non improving iteration\n",
    "\n",
    "    # OUTPUT\n",
    "    # best_graph = best execution graph\n",
    "    # best_score = best score obtained    \n",
    "    # best_sequence = best solution given by compile_greedy\n",
    "    # best_distance = best execution times\n",
    "    # ------------------------------------------------------------------------------\n",
    "    \n",
    "    # Temporary target\n",
    "    temp_target = target\n",
    "        \n",
    "    best_score = 0\n",
    "    best_sequence = [[]]    \n",
    "    best_graph = nx.DiGraph()\n",
    "    best_distance = {}\n",
    "    \n",
    "    # Compute compilation and replication time for each non-target file \n",
    "    t_comp = []\n",
    "    t_rep = []\n",
    "    for f in file:\n",
    "        if f not in temp_target:\n",
    "            t_comp.append(time[f][0])\n",
    "            t_rep.append(time[f][1])\n",
    "\n",
    "    # compute the median of times\n",
    "    t_comp_med = statistics.median(t_comp)\n",
    "    t_rep_med = statistics.median(t_rep) \n",
    "    \n",
    "    # check the technique to use comparing median compilation and replication time\n",
    "    if t_rep_med > t_comp_med:\n",
    "        technique = 1\n",
    "    else:\n",
    "        technique = 2\n",
    "    \n",
    "    print(\"Technique: \", technique)\n",
    "    \n",
    "    print(\"Score \\t Good Target \\t Bad Target\")\n",
    "    print(\"------------------------------------\")        \n",
    "    i = 0\n",
    "    while True:\n",
    "        \n",
    "        # Remove target files with compilation time > deadline\n",
    "        real_target = [t for t in temp_target if target[t][0]>time[t][0]]\n",
    "        \n",
    "        # Build dependencies graph\n",
    "        dep_graph = build_dep_graph(dep, real_target)\n",
    "\n",
    "        # Get possible execution sequences\n",
    "        sequence = compile_greedy(num_server, dep_graph, real_target, technique)\n",
    "        \n",
    "        # Build execution graph\n",
    "        execution_graph = build_graph(time, dep, sequence)\n",
    "\n",
    "        # Compute execution times by tracing the longest path\n",
    "        execution_graph, distance = get_longest_path(execution_graph)\n",
    "        # Compute the score of the solution\n",
    "        score, good_target, bad_target = get_score(distance, target, time)\n",
    "        \n",
    "        print(score, '\\t', len(good_target), '\\t', len(bad_target))    \n",
    "                \n",
    "        # if the last score is better then best score\n",
    "        if(score>=best_score):\n",
    "            # save the solution as best solution\n",
    "            i = 0\n",
    "            best_score = score\n",
    "            best_sequence = sequence\n",
    "            best_graph = execution_graph\n",
    "            best_distance = distance\n",
    "        else:\n",
    "            i = i+1\n",
    "            \n",
    "        # if not bad target or too not-improving iteration, end the algorithm\n",
    "        if not bad_target or i > max_iter:\n",
    "            break\n",
    "\n",
    "        # get execution times of bad target\n",
    "        target_distance = {t:d for t,d in distance.items() if t in bad_target}\n",
    "        # remove the bad target with minimum initial time\n",
    "        target_tabu = max(target_distance, key=target_distance.get)\n",
    "        temp_target.pop(target_tabu)\n",
    "        \n",
    "    return best_graph, best_score, best_sequence, best_distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_file(distance, graph, filename):\n",
    "    # Write the output file\n",
    "    # -------------------------------------------------------------------------\n",
    "    # INPUT\n",
    "    # distance: dictionary of distances for current execution sequence\n",
    "    # graph: graph of current execution sequence\n",
    "    \n",
    "    # OUTPUT\n",
    "    # creates/overwrites file in path \"./output/submission_file.txt\"\n",
    "    # -------------------------------------------------------------------------\n",
    "\n",
    "    # convert distances in positive values\n",
    "    distance = dict((k,abs(v)) for k,v in distance.items())\n",
    "    #convert distance dictionary to list\n",
    "    distance_list = sorted(distance.items(), key=lambda x: x[1])\n",
    "    \n",
    "    # checking wheater output's folder exists\n",
    "    path_dir=str(pathlib.Path().absolute())+ \"/output\"\n",
    "    if not os.path.exists(path_dir):\n",
    "        os.mkdir(path_dir)  \n",
    "    \n",
    "    # opening file\n",
    "    path = path_dir + '/' + filename + '_submission_file.txt'\n",
    "    file_object = open(path, 'w')\n",
    "    \n",
    "    # writing file\n",
    "    file_object.write(str(len(distance_list)-2)+ '\\n')\n",
    "#     print(str(len(distance_list)-2))\n",
    "    \n",
    "    for i in distance_list:\n",
    "        if(i[0] != 's' and i[0] != 't'):\n",
    "            file = i[0]\n",
    "            time = i[1]\n",
    "            server = graph.nodes[file]['server']\n",
    "            file_object.write(file + \" \" + str(server) + '\\n')\n",
    "#             print(file + \" \" + str(time) + \" \" + str(server))\n",
    "\n",
    "    file_object.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_graph(graph, sequence):   \n",
    "    \n",
    "    # Draw the given graph\n",
    "    fig = plt.figure(figsize=(10,6))\n",
    "    ax = plt.axes()\n",
    "    \n",
    "    # graph layout\n",
    "    pos = nx.planar_layout(graph)\n",
    "    \n",
    "    # draw nodes\n",
    "    cmap = plt.get_cmap('Pastel1')\n",
    "    # https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html <----- visit here for others color maps\n",
    "    colors = [cmap(i) for i in np.linspace(0, 1, len(sequence)+1)]\n",
    "    for i,server in enumerate(sequence):\n",
    "        nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=server, node_color=[colors[i]], alpha=1, edgecolors=\"black\")\n",
    "    nx.draw_networkx_nodes(graph, pos, ax=ax, nodelist=[\"s\",\"t\"], node_color=[colors[len(sequence)]], alpha=1, edgecolors=\"black\")\n",
    "    nx.draw_networkx_labels(graph, pos, ax=ax);\n",
    "    \n",
    "    # draw edges\n",
    "    color = nx.get_edge_attributes(graph,'color')\n",
    "    nx.draw_networkx_edges(graph, pos, ax=ax, width=1.0, alpha=0.8, edge_color=color.values())\n",
    "    edge_labels = nx.get_edge_attributes(graph,'weight')\n",
    "    nx.draw_networkx_edge_labels(graph, pos, ax=ax, edge_labels=edge_labels, label_pos=0.5)\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "    return graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_dep_graph(dep_graph):\n",
    "    \n",
    "    # Draw the dependencies graph\n",
    "    fig = plt.figure(figsize=(10,6))\n",
    "    ax = plt.axes()\n",
    "    # graph layout\n",
    "    pos = nx.planar_layout(dep_graph)\n",
    "    # draw nodes\n",
    "    cmap = plt.get_cmap('Pastel1')\n",
    "    nx.draw_networkx_nodes(dep_graph, pos, ax=ax, nodelist=[n for n in dep_graph if n not in target], node_color=[cmap(1)], alpha=1, edgecolors=\"black\")\n",
    "    nx.draw_networkx_nodes(dep_graph, pos, ax=ax, nodelist=[n for n in dep_graph if n in target], node_color=[cmap(0)], alpha=1, edgecolors=\"black\")\n",
    "    nx.draw_networkx_labels(dep_graph, pos, ax=ax);\n",
    "    # draw edges\n",
    "    nx.draw_networkx_edges(dep_graph, pos, ax=ax, width=1.0, alpha=0.8, edge_color=\"black\")\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Main Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset: a_example\n",
      "------------------------------------\n",
      "Technique:  1\n",
      "Score \t Good Target \t Bad Target\n",
      "------------------------------------\n",
      "0 \t 0 \t 3\n",
      "25 \t 1 \t 1\n",
      "25 \t 1 \t 0\n",
      "------------------------------------\n",
      "Best score: 25 \n",
      "\n",
      "Dataset: b_narrow\n",
      "------------------------------------\n",
      "Technique:  1\n",
      "Score \t Good Target \t Bad Target\n",
      "------------------------------------\n",
      "992418 \t 50 \t 0\n",
      "------------------------------------\n",
      "Best score: 992418 \n",
      "\n",
      "Dataset: c_urgent\n",
      "------------------------------------\n",
      "Technique:  2\n",
      "Score \t Good Target \t Bad Target\n",
      "------------------------------------\n",
      "1063647 \t 5 \t 15\n",
      "1084257 \t 5 \t 14\n",
      "1109863 \t 5 \t 13\n",
      "1128129 \t 5 \t 12\n",
      "1191158 \t 8 \t 8\n",
      "1232221 \t 14 \t 1\n",
      "1238841 \t 14 \t 0\n",
      "------------------------------------\n",
      "Best score: 1238841 \n",
      "\n",
      "Dataset: d_typical\n",
      "------------------------------------\n",
      "Technique:  2\n",
      "Score \t Good Target \t Bad Target\n",
      "------------------------------------\n",
      "3242 \t 2 \t 97\n",
      "2378 \t 1 \t 97\n",
      "4060 \t 3 \t 94\n",
      "3146 \t 2 \t 94\n",
      "3423 \t 2 \t 93\n",
      "5846 \t 3 \t 91\n",
      "5846 \t 3 \t 90\n",
      "5846 \t 3 \t 89\n",
      "5846 \t 3 \t 88\n",
      "5846 \t 3 \t 87\n",
      "5846 \t 3 \t 86\n",
      "5846 \t 3 \t 85\n",
      "10499 \t 4 \t 83\n",
      "8218 \t 4 \t 82\n",
      "8218 \t 4 \t 81\n",
      "11695 \t 5 \t 79\n",
      "12224 \t 5 \t 78\n",
      "15054 \t 6 \t 76\n",
      "17511 \t 7 \t 74\n",
      "11615 \t 6 \t 74\n",
      "16800 \t 7 \t 72\n",
      "19331 \t 7 \t 71\n",
      "19331 \t 7 \t 70\n",
      "23308 \t 8 \t 68\n",
      "23308 \t 8 \t 67\n",
      "23308 \t 8 \t 66\n",
      "23308 \t 8 \t 65\n",
      "23308 \t 8 \t 64\n",
      "41028 \t 9 \t 62\n",
      "41028 \t 9 \t 61\n",
      "41028 \t 9 \t 60\n",
      "41028 \t 9 \t 59\n",
      "44366 \t 10 \t 57\n",
      "48860 \t 11 \t 55\n",
      "48860 \t 11 \t 54\n",
      "48860 \t 11 \t 53\n",
      "48860 \t 11 \t 52\n",
      "48860 \t 11 \t 51\n",
      "48860 \t 11 \t 50\n",
      "48860 \t 11 \t 49\n",
      "48860 \t 11 \t 48\n",
      "48860 \t 11 \t 47\n",
      "48860 \t 11 \t 46\n",
      "48860 \t 11 \t 45\n",
      "48860 \t 11 \t 44\n",
      "48860 \t 11 \t 43\n",
      "48860 \t 11 \t 42\n",
      "48860 \t 11 \t 41\n",
      "48860 \t 11 \t 40\n",
      "48860 \t 11 \t 39\n",
      "48860 \t 11 \t 38\n",
      "64576 \t 12 \t 36\n",
      "64576 \t 12 \t 35\n",
      "64576 \t 12 \t 34\n",
      "64576 \t 12 \t 33\n",
      "64576 \t 12 \t 32\n",
      "64576 \t 12 \t 31\n",
      "64576 \t 12 \t 30\n",
      "64576 \t 12 \t 29\n",
      "65877 \t 13 \t 27\n",
      "64576 \t 12 \t 27\n",
      "64576 \t 12 \t 26\n",
      "64576 \t 12 \t 25\n",
      "78568 \t 13 \t 23\n",
      "78568 \t 13 \t 22\n",
      "78568 \t 13 \t 21\n",
      "78568 \t 13 \t 20\n",
      "78568 \t 13 \t 19\n",
      "78568 \t 13 \t 18\n",
      "78568 \t 13 \t 17\n",
      "78568 \t 13 \t 16\n",
      "78901 \t 14 \t 14\n",
      "78568 \t 13 \t 14\n",
      "78568 \t 13 \t 13\n",
      "78568 \t 13 \t 12\n",
      "78568 \t 13 \t 11\n",
      "110665 \t 15 \t 8\n",
      "110665 \t 15 \t 7\n",
      "110665 \t 15 \t 6\n",
      "110665 \t 15 \t 5\n",
      "110665 \t 15 \t 4\n",
      "110665 \t 15 \t 3\n",
      "136652 \t 17 \t 0\n",
      "------------------------------------\n",
      "Best score: 136652 \n",
      "\n",
      "Dataset: e_intriguing\n",
      "------------------------------------\n",
      "Technique:  2\n",
      "Score \t Good Target \t Bad Target\n",
      "------------------------------------\n",
      "0 \t 0 \t 11\n",
      "0 \t 0 \t 10\n",
      "0 \t 0 \t 9\n",
      "0 \t 0 \t 8\n",
      "0 \t 0 \t 7\n",
      "0 \t 0 \t 6\n",
      "0 \t 0 \t 5\n",
      "0 \t 0 \t 4\n",
      "0 \t 0 \t 3\n",
      "0 \t 0 \t 2\n",
      "1 \t 1 \t 0\n",
      "------------------------------------\n",
      "Best score: 1 \n",
      "\n",
      "Dataset: f_big\n",
      "------------------------------------\n",
      "Technique:  1\n",
      "Score \t Good Target \t Bad Target\n",
      "------------------------------------\n",
      "11547 \t 2 \t 73\n",
      "11547 \t 2 \t 72\n",
      "11547 \t 2 \t 71\n",
      "11547 \t 2 \t 70\n",
      "11547 \t 2 \t 69\n",
      "11547 \t 2 \t 68\n",
      "11547 \t 2 \t 67\n",
      "11547 \t 2 \t 66\n",
      "11547 \t 2 \t 65\n",
      "11547 \t 2 \t 64\n",
      "11547 \t 2 \t 63\n",
      "11547 \t 2 \t 62\n",
      "11547 \t 2 \t 61\n",
      "11547 \t 2 \t 60\n",
      "11547 \t 2 \t 59\n",
      "11547 \t 2 \t 58\n",
      "11547 \t 2 \t 57\n",
      "11547 \t 2 \t 56\n",
      "11547 \t 2 \t 55\n",
      "11547 \t 2 \t 54\n",
      "11547 \t 2 \t 53\n",
      "11547 \t 2 \t 52\n",
      "11547 \t 2 \t 51\n",
      "11547 \t 2 \t 50\n",
      "11547 \t 2 \t 49\n",
      "11547 \t 2 \t 48\n",
      "11547 \t 2 \t 47\n",
      "11547 \t 2 \t 46\n",
      "11547 \t 2 \t 45\n",
      "11547 \t 2 \t 44\n",
      "11547 \t 2 \t 43\n",
      "11547 \t 2 \t 42\n",
      "11547 \t 2 \t 41\n",
      "11547 \t 2 \t 40\n",
      "11547 \t 2 \t 39\n",
      "11547 \t 2 \t 38\n",
      "11547 \t 2 \t 37\n",
      "11547 \t 2 \t 36\n",
      "11547 \t 2 \t 35\n",
      "11547 \t 2 \t 34\n",
      "11547 \t 2 \t 33\n",
      "11547 \t 2 \t 32\n",
      "11547 \t 2 \t 31\n",
      "11547 \t 2 \t 30\n",
      "11547 \t 2 \t 29\n",
      "11547 \t 2 \t 28\n",
      "11547 \t 2 \t 27\n",
      "11547 \t 2 \t 26\n",
      "11547 \t 2 \t 25\n",
      "11547 \t 2 \t 24\n",
      "11547 \t 2 \t 23\n",
      "11547 \t 2 \t 22\n",
      "11547 \t 2 \t 21\n",
      "11547 \t 2 \t 20\n",
      "11547 \t 2 \t 19\n",
      "11547 \t 2 \t 18\n",
      "11547 \t 2 \t 17\n",
      "11547 \t 2 \t 16\n",
      "11547 \t 2 \t 15\n",
      "11547 \t 2 \t 14\n",
      "11547 \t 2 \t 13\n",
      "11547 \t 2 \t 12\n",
      "11547 \t 2 \t 11\n",
      "11547 \t 2 \t 10\n",
      "11547 \t 2 \t 9\n",
      "11547 \t 2 \t 8\n",
      "11547 \t 2 \t 7\n",
      "11547 \t 2 \t 6\n",
      "11547 \t 2 \t 5\n",
      "11547 \t 2 \t 4\n",
      "11547 \t 2 \t 3\n",
      "11547 \t 2 \t 2\n",
      "11547 \t 2 \t 1\n",
      "11547 \t 2 \t 0\n",
      "------------------------------------\n",
      "Best score: 11547 \n",
      "\n",
      "Total Score: 2379484\n"
     ]
    }
   ],
   "source": [
    "dataset = [\"a_example\",\"b_narrow\",\"c_urgent\",\"d_typical\",\"e_intriguing\",\"f_big\"]\n",
    "max_iter = 5\n",
    "tot_score = 0\n",
    "\n",
    "\n",
    "\n",
    "for d in dataset:\n",
    "    num_file, num_target, num_server, file, time, dep, target = open_input(d)\n",
    "    \n",
    "    print(\"Dataset:\", d)\n",
    "    print(\"------------------------------------\")\n",
    "    best_graph, best_score, best_sequence, best_distance = compile_improve(num_server, file, time, dep, target, max_iter)\n",
    "    \n",
    "    write_file(best_distance, best_graph, d)\n",
    "    \n",
    "    tot_score = tot_score + best_score\n",
    "\n",
    "    print(\"------------------------------------\")\n",
    "    print(\"Best score:\", best_score, \"\\n\")    \n",
    "    \n",
    "    if(d == \"a_example\"):\n",
    "        a_graph = best_graph  \n",
    "        a_sequence = best_sequence\n",
    "        \n",
    "print(\"Total Score:\", tot_score)\n",
    "\n",
    "# Total Score: 2379484"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\networkx\\drawing\\layout.py:950: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
      "  pos = np.row_stack((pos[x] for x in node_list))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 344,
       "width": 575
      }
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<networkx.classes.digraph.DiGraph at 0x21719a1c7b8>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "draw_graph(a_graph, a_sequence)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}