Graph_generator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMpVZeazUg+f2XJpL3bQmdv",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Ricardo50-dev/Graph_generator/blob/main/Graph_generator.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w43UmsHWU6Qe"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "from sklearn.metrics import pairwise\n",
        "from sklearn.neighbors import DistanceMetric\n",
        "import igraph as ig"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def Assortativity(graph):\n",
        "    return ig.Graph.assortativity_degree(graph)\n",
        "\n",
        "\n",
        "def ClustCoefficient(graph):\n",
        "    return ig.Graph.transitivity_avglocal_undirected(graph)\n",
        "\n",
        "\n",
        "def AvgDegree(graph):\n",
        "    return np.mean(ig.Graph.degree(graph))\n",
        "\n",
        "\n",
        "def Betweenness(graph):\n",
        "    return np.mean(ig.Graph.betweenness(graph))\n",
        "\n",
        "\n",
        "def AvgPathLength(graph):\n",
        "    return ig.Graph.average_path_length(graph)\n",
        "\n",
        "\n",
        "def Closeness(graph):\n",
        "    return np.mean(ig.Graph.closeness(graph))"
      ],
      "metadata": {
        "id": "U64XOENtWd8Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def eN_Graph(raio, X, y):\n",
        "\n",
        "    # pega o num de classes\n",
        "    numclasses = len(np.unique(y))\n",
        "\n",
        "    # X = gauss_spline(X, len(X))\n",
        "    euclidean_dist = pairwise.cosine_similarity(X)\n",
        "    #dist = DistanceMetric.get_metric('euclidian')\n",
        "    #euclidean_dist = dist.pairwise(X)\n",
        "\n",
        "\n",
        "    # preenche a diagonal principal com valor infinito\n",
        "    np.fill_diagonal(euclidean_dist, np.inf)\n",
        "\n",
        "\n",
        "    # ordena as distancias por objeto em ordem ascendente\n",
        "    ind_ranking = np.argsort(euclidean_dist, axis=1)[:, :]\n",
        "    #print(euclidean_dist)\n",
        "    # inicializa uma mascara com False, num de objetos x k\n",
        "    mask = np.zeros((len(X), len(X))).astype(int)\n",
        "\n",
        "    # preenche os campos True da mascara, vizinho mais proximos que sao da mesma clase\n",
        "    lista_grafos = []\n",
        "    for i in range(len(ind_ranking)):\n",
        "        for j in range(len(ind_ranking)):\n",
        "            if y[ind_ranking[i][j]] == y[i] and euclidean_dist[i][j] <= raio:\n",
        "                mask[i][j] = True\n",
        "\n",
        "    # captura os indices True da mascara, linha e coluna\n",
        "    links = mask.nonzero()\n",
        "\n",
        "    # atribui os indices das linhas\n",
        "    sources = links[0]\n",
        "\n",
        "    # atribui o indice real dos objetos das colunas\n",
        "    targets = ind_ranking[links]\n",
        "\n",
        "    # inicializa funcao para mapeamento dos vertices\n",
        "    map_vertices = np.zeros(len(ind_ranking)).astype(int) - 1\n",
        "\n",
        "    # inicializa variavel para guardar o calculo das medidas\n",
        "    measures = np.zeros((numclasses, 6))\n",
        "    for l in range(numclasses):\n",
        "\n",
        "        # captura todos os objetos em sources que pertencem a classe l\n",
        "        lsources = np.where(y[sources] == l)[0]\n",
        "\n",
        "        # captura todos os objetos da base que pertencem a classe l\n",
        "        all_vertices = np.where(y == l)[0]\n",
        "\n",
        "        # recebe todos os objetos da classe l que estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(sources[lsources], targets[lsources])).astype(int)\n",
        "\n",
        "        # recebe os demais objetos da classe l que nao estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(unique_vertices, all_vertices)).astype(int)\n",
        "\n",
        "        # popula a funcao de mapeamento dos vertices com os objetos da classe l\n",
        "        map_vertices[unique_vertices] = np.arange(\n",
        "            len(unique_vertices)).astype(int)\n",
        "\n",
        "        # print(len(unique_vertices), unique_vertices)\n",
        "\n",
        "        # cria o grafo para classe l\n",
        "        subg = ig.Graph(len(unique_vertices), list(zip(map_vertices[sources[lsources]].astype(\n",
        "            int), map_vertices[targets[lsources]].astype(int))))\n",
        "\n",
        "        #print(subg.vcount())\n",
        "\n",
        "        # popula a lista de grafos\n",
        "        lista_grafos.append(subg)\n",
        "\n",
        "        # calcula as medidas de rede associadas ao grafo l\n",
        "        measures[l, 0] = Assortativity(subg)\n",
        "        measures[l, 1] = ClustCoefficient(subg)\n",
        "        measures[l, 2] = AvgDegree(subg)\n",
        "        measures[l, 3] = Betweenness(subg)\n",
        "        measures[l, 4] = AvgPathLength(subg)\n",
        "        measures[l, 5] = Closeness(subg)\n",
        "\n",
        "\n",
        "    return lista_grafos, map_vertices, measures"
      ],
      "metadata": {
        "id": "0f635em-VnMx"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def kNN_Graph(k, X, y):\n",
        "\n",
        "    # pega o num de classes\n",
        "    numclasses = len(np.unique(y))\n",
        "\n",
        "    # X = gauss_spline(X, len(X))\n",
        "    euclidean_dist = pairwise.cosine_similarity(X)\n",
        "    #dist = DistanceMetric.get_metric('euclidian')\n",
        "    #euclidean_dist = dist.pairwise(X)\n",
        "\n",
        "\n",
        "    # preenche a diagonal principal com valor infinito\n",
        "    np.fill_diagonal(euclidean_dist, np.inf)\n",
        "\n",
        "    # ordena as distancias por objeto em ordem ascendente\n",
        "    ind_ranking = np.argsort(euclidean_dist, axis=1)[:, :k]\n",
        "\n",
        "    # inicializa uma mascara com False, num de objetos x k\n",
        "    mask = np.zeros((len(X), k)).astype(int)\n",
        "\n",
        "    # preenche os campos True da mascara, vizinho mais proximos que sao da mesma clase\n",
        "    lista_grafos = []\n",
        "    for i in range(len(ind_ranking)):\n",
        "        mask[i] = (y[ind_ranking[i]] == y[i])\n",
        "\n",
        "    # captura os indices True da mascara, linha e coluna\n",
        "    links = mask.nonzero()\n",
        "\n",
        "    # atribui os indices das linhas\n",
        "    sources = links[0]\n",
        "\n",
        "    # atribui o indice real dos objetos das colunas\n",
        "    targets = ind_ranking[links]\n",
        "\n",
        "    # inicializa funcao para mapeamento dos vertices\n",
        "    map_vertices = np.zeros(len(ind_ranking)).astype(int) - 1\n",
        "\n",
        "    # inicializa variavel para guardar o calculo das medidas\n",
        "    measures = np.zeros((numclasses, 6))\n",
        "    for l in range(numclasses):\n",
        "\n",
        "        # captura todos os objetos em sources que pertencem a classe l\n",
        "        lsources = np.where(y[sources] == l)[0]\n",
        "\n",
        "        # captura todos os objetos da base que pertencem a classe l\n",
        "        all_vertices = np.where(y == l)[0]\n",
        "\n",
        "        # recebe todos os objetos da classe l que estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(sources[lsources], targets[lsources])).astype(int)\n",
        "\n",
        "        # recebe os demais objetos da classe l que nao estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(unique_vertices, all_vertices)).astype(int)\n",
        "\n",
        "        # popula a funcao de mapeamento dos vertices com os objetos da classe l\n",
        "        map_vertices[unique_vertices] = np.arange(\n",
        "            len(unique_vertices)).astype(int)\n",
        "\n",
        "        # print(len(unique_vertices), unique_vertices)\n",
        "\n",
        "        # cria o grafo para classe l\n",
        "        subg = ig.Graph(len(unique_vertices), list(zip(map_vertices[sources[lsources]].astype(\n",
        "            int), map_vertices[targets[lsources]].astype(int))))\n",
        "\n",
        "        #print(subg.vcount())\n",
        "\n",
        "        # popula a lista de grafos\n",
        "        lista_grafos.append(subg)\n",
        "\n",
        "        # calcula as medidas de rede associadas ao grafo l\n",
        "        measures[l, 0] = Assortativity(subg)\n",
        "        measures[l, 1] = ClustCoefficient(subg)\n",
        "        measures[l, 2] = AvgDegree(subg)\n",
        "        measures[l, 3] = Betweenness(subg)\n",
        "        measures[l, 4] = AvgPathLength(subg)\n",
        "        measures[l, 5] = Closeness(subg)\n",
        "\n",
        "\n",
        "    return lista_grafos, map_vertices, measures"
      ],
      "metadata": {
        "id": "3HT92DEFVn0-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def S_kNN_Graph(k, X, y):\n",
        "\n",
        "    numclasses = len(np.unique(y))\n",
        "    lista_grafos = []\n",
        "    # inicializa variavel para guardar o calculo das medidas\n",
        "    measures = np.zeros((numclasses, 6))\n",
        "    # inicializa funcao para mapeamento dos vertices\n",
        "    map_vertices = np.zeros(len(X)).astype(int) - 1\n",
        "    for l in range(0, numclasses):\n",
        "\n",
        "        classes = X[np.where(y == l)[0]]\n",
        "\n",
        "        euclidean_dist = pairwise.cosine_similarity(classes)\n",
        "        #dist = DistanceMetric.get_metric('euclidian')\n",
        "        #euclidean_dist = dist.pairwise(classes)\n",
        "\n",
        "        # preenche a diagonal principal com valor infinito\n",
        "        np.fill_diagonal(euclidean_dist, np.inf)\n",
        "\n",
        "        # ordena as distancias por objeto em ordem ascendente\n",
        "        ind_ranking = np.argsort(euclidean_dist, axis=1)[:, :k]\n",
        "\n",
        "        # inicializa uma mascara com False, num de objetos x k\n",
        "        mask = np.zeros((len(classes), k)).astype(int)\n",
        "\n",
        "        # preenche os campos True da mascara, vizinho mais proximos que sao da mesma clase\n",
        "\n",
        "        for i in range(len(ind_ranking)):\n",
        "            mask[i] = True\n",
        "\n",
        "        # captura os indices True da mascara, linha e coluna\n",
        "        links = mask.nonzero()\n",
        "\n",
        "        # atribui os indices das linhas\n",
        "        sources = links[0]\n",
        "\n",
        "        # atribui o indice real dos objetos das colunas\n",
        "        targets = ind_ranking[links]\n",
        "\n",
        "        # captura todos os objetos em sources que pertencem a classe l\n",
        "        lsources = np.where(y[sources] == l)[0]\n",
        "\n",
        "        # captura todos os objetos da base que pertencem a classe l\n",
        "        all_vertices = np.where(y == l)[0]\n",
        "\n",
        "        # recebe todos os objetos da classe l que estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(sources[lsources], targets[lsources])).astype(int)\n",
        "\n",
        "        # recebe os demais objetos da classe l que nao estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(unique_vertices, all_vertices)).astype(int)\n",
        "\n",
        "        # popula a funcao de mapeamento dos vertices com os objetos da classe l\n",
        "        map_vertices[unique_vertices] = np.arange(\n",
        "            len(unique_vertices)).astype(int)\n",
        "        # print(len(unique_vertices), unique_vertices)\n",
        "\n",
        "        # cria o grafo para classe l\n",
        "        subg = ig.Graph(len(unique_vertices), list(zip(map_vertices[sources[lsources]].astype(\n",
        "            int), map_vertices[targets[lsources]].astype(int))))\n",
        "\n",
        "        #print(subg.vcount())\n",
        "\n",
        "        # popula a lista de grafos\n",
        "        lista_grafos.append(subg)\n",
        "\n",
        "        # calcula as medidas de rede associadas ao grafo l\n",
        "        measures[l, 0] = Assortativity(subg)\n",
        "        measures[l, 1] = ClustCoefficient(subg)\n",
        "        measures[l, 2] = AvgDegree(subg)\n",
        "        measures[l, 3] = Betweenness(subg)\n",
        "        measures[l, 4] = AvgPathLength(subg)\n",
        "        measures[l, 5] = Closeness(subg)\n",
        "\n",
        "    return lista_grafos, map_vertices, measures"
      ],
      "metadata": {
        "id": "Tq8nJ-9wXCkM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def M_kNN_Graph(k, X, y):\n",
        "\n",
        "    numclasses = len(np.unique(y))\n",
        "    lista_grafos = []\n",
        "    # inicializa variavel para guardar o calculo das medidas\n",
        "    measures = np.zeros((numclasses, 6))\n",
        "    # inicializa funcao para mapeamento dos vertices\n",
        "    map_vertices = np.zeros(len(X)).astype(int) - 1\n",
        "    for l in range(0, numclasses):\n",
        "\n",
        "        classes = X[np.where(y == l)[0]]\n",
        "\n",
        "        euclidean_dist = pairwise.cosine_similarity(classes)\n",
        "        #dist = DistanceMetric.get_metric('euclidian')\n",
        "        #euclidean_dist = dist.pairwise(classes)\n",
        "\n",
        "        # preenche a diagonal principal com valor infinito\n",
        "        np.fill_diagonal(euclidean_dist, np.inf)\n",
        "\n",
        "        # ordena as distancias por objeto em ordem ascendente\n",
        "        ind_ranking = np.argsort(euclidean_dist, axis=1)[:, :k]\n",
        "        # inicializa uma mascara com False, num de objetos x k\n",
        "        mask = np.zeros((len(classes), k)).astype(int)\n",
        "\n",
        "        # preenche os campos True da mascara, vizinho mais proximos que sao da mesma clase\n",
        "\n",
        "        for i in range(len(ind_ranking)):\n",
        "          for j in range(0, k):\n",
        "            if ind_ranking[i][j] in ind_ranking[ind_ranking[i][j] - 1]:\n",
        "                mask[i][j] = True\n",
        "\n",
        "            else:\n",
        "                mask[i][j] = False\n",
        "\n",
        "        # captura os indices True da mascara, linha e coluna\n",
        "        links = mask.nonzero()\n",
        "\n",
        "        # atribui os indices das linhas\n",
        "        sources = links[0]\n",
        "\n",
        "        # atribui o indice real dos objetos das colunas\n",
        "        targets = ind_ranking[links]\n",
        "\n",
        "        # captura todos os objetos em sources que pertencem a classe l\n",
        "        lsources = np.where(y[sources] == l)[0]\n",
        "\n",
        "        # captura todos os objetos da base que pertencem a classe l\n",
        "        all_vertices = np.where(y == l)[0]\n",
        "\n",
        "        # recebe todos os objetos da classe l que estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(sources[lsources], targets[lsources])).astype(int)\n",
        "\n",
        "        # recebe os demais objetos da classe l que nao estao conectados\n",
        "        unique_vertices = np.unique(\n",
        "            np.append(unique_vertices, all_vertices)).astype(int)\n",
        "\n",
        "        # popula a funcao de mapeamento dos vertices com os objetos da classe l\n",
        "        map_vertices[unique_vertices] = np.arange(\n",
        "            len(unique_vertices)).astype(int)\n",
        "        # print(len(unique_vertices), unique_vertices)\n",
        "\n",
        "        # cria o grafo para classe l\n",
        "        subg = ig.Graph(len(unique_vertices), list(zip(map_vertices[sources[lsources]].astype(\n",
        "            int), map_vertices[targets[lsources]].astype(int))))\n",
        "\n",
        "        #print(subg.vcount())\n",
        "\n",
        "        # popula a lista de grafos\n",
        "        lista_grafos.append(subg)\n",
        "\n",
        "        # calcula as medidas de rede associadas ao grafo l\n",
        "        measures[l, 0] = Assortativity(subg)\n",
        "        measures[l, 1] = ClustCoefficient(subg)\n",
        "        measures[l, 2] = AvgDegree(subg)\n",
        "        measures[l, 3] = Betweenness(subg)\n",
        "        measures[l, 4] = AvgPathLength(subg)\n",
        "        measures[l, 5] = Closeness(subg)\n",
        "\n",
        "    return lista_grafos, map_vertices, measures"
      ],
      "metadata": {
        "id": "Yjsp_foEXMgw"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}