Python >> Tutoriel Python >  >> Python Tag >> Array

Comment puis-je convertir un tableau à deux colonnes en une matrice avec un nombre d'occurrences ?

Une façon pourrait être de construire un graphique à l'aide de NetworkX et d'obtenir la matrice d'adjacence directement sous forme de dataframe avec nx.to_pandas_adjacency . Pour tenir compte des cooccurrences des arêtes dans le graphique, nous pouvons créer un nx.MultiGraph , ce qui permet à plusieurs arêtes de connecter la même paire de nœuds :

import networkx as nx

G = nx.from_edgelist(pair_array, create_using=nx.MultiGraph)
nx.to_pandas_adjacency(G, nodelist=sorted(G.nodes()), dtype='int')

      18   31   69   183  205  254  267  382
18     0    0    1    0    0    0    0    0
31     0    0    0    1    0    0    1    1
69     1    0    0    0    0    0    0    0
183    0    1    0    0    0    0    1    1
205    0    0    0    0    0    1    0    2
254    0    0    0    0    1    0    0    1
267    0    1    0    1    0    0    0    0
382    0    1    0    1    2    1    0    0

Construire un NetworkX graph, permettra également de créer une matrice d'adjacence ou une autre selon le comportement que l'on attend. Nous pouvons soit le créer en utilisant un :

  • nx.Graph :Si nous voulons mettre à 1 les deux entrées (x,y) et (y,x ) pour un (x,y) (ou (y,x) ) bord. Cela produira donc une matrice d'adjacence symétrique
  • nx.DiGraph :Si (x,y) ne doit définir que le (x,y) l'entrée à 1
  • nx.MultiGraph :Pour le même comportement qu'un nx.Graph mais en tenant compte des co-occurrences de bord
  • nx.MultiDiGraph :Pour le même comportement qu'un nx.DiGraph mais aussi en tenant compte des co-occurrences de bord

Une façon de le faire est d'ajouter le pair_array avec pair_array inversé à l'axe 1 qui peut être fait en utilisant [::-1] . Et pour ajouter, utilisez np.vstack /np.r_ /np.concatenate .

Utilisez maintenant pd.crosstab pour effectuer un tableau croisé.

all_vals = np.r_[pair_array, pair_array[:, ::-1]]
pd.crosstab(all_vals[:, 0], all_vals[:, 1])

col_0  18   31   69   183  205  254  267  382
row_0                                        
18       0    0    1    0    0    0    0    0
31       0    0    0    1    0    0    1    1
69       1    0    0    0    0    0    0    0
183      0    1    0    0    0    0    1    1
205      0    0    0    0    0    1    0    2
254      0    0    0    0    1    0    0    1
267      0    1    0    1    0    0    0    0
382      0    1    0    1    2    1    0    0

Comme @QuangHoang l'a souligné lorsqu'il y a des paires identiques se produisant plus d'une fois, c'est-à-dire [(18, 18), (18, 18), ...] , puis utilisez

rev = pair_array[:, ::-1]
m = (pair_array == rev)
rev = rev[~np.all(m, axis=1)]
all_vals = np.r_[pair_arr, rev]

Vous pouvez créer au préalable un bloc de données de la taille appropriée avec des zéros et simplement incrémenter les cellules appropriées en bouclant sur les paires :

import numpy as np
import pandas as pd

pair_array = np.array([(205, 254), (205, 382), (254, 382), (18, 69), (205, 382),
                       (31, 183), (31, 267), (31, 82), (183, 267), (183, 382)])

vals = sorted(set(pair_array.flatten()))
n = len(vals)

df = pd.DataFrame(np.zeros((n, n), dtype=np.int), columns=vals, index=vals)

for r, c in pair_array:
    df.at[r, c] += 1
    df.at[c, r] += 1

print(df)

Sortie :

     18   31   69   82   183  205  254  267  382
18     0    0    1    0    0    0    0    0    0
31     0    0    0    1    1    0    0    1    0
69     1    0    0    0    0    0    0    0    0
82     0    1    0    0    0    0    0    0    0
183    0    1    0    0    0    0    0    1    1
205    0    0    0    0    0    0    1    0    2
254    0    0    0    0    0    1    0    0    1
267    0    1    0    0    1    0    0    0    0
382    0    0    0    0    1    2    1    0    0