Comparaison de la vitesse de transposition de la matrice par Python

1. Origines

Je voulais obtenir un tableau bidimensionnel (matrice de translocation) avec les lignes et les colonnes permutées à partir d'un tableau bidimensionnel basé sur le type de liste standard Python, et ** parce que mon code était extrêmement lent **, quelle méthode de matrice de transposition Je me demandais si c'était le plus rapide, alors je l'ai comparé.

Transfer Matrix-Wikipedia

Étant donné que l'auteur est un débutant avec moins de six mois d'expérience en programmation, je vous serais reconnaissant si vous pouviez signaler des erreurs ou des méthodes d'amélioration. [** Pour accélérer le résultat de la comparaison **](résultat de la comparaison # 5 vitesses)

2. Environnement

3. Conditions

--Input est un tableau à deux dimensions avec le type de liste standard Python --Output est le type de liste standard Python, numpy.array ou pandas.DataFrame

3-1. Matrice de translocation

Le nom de la matrice à transposer est ʻin_matrix`, et cette fois une matrice 100x100 est générée.

Matrice à transloquer

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

3-2. Mesure du temps de traitement

Ceci est fait en utilisant le % timeit du Jupyter Notebook (IPython). Built-in magic commands — %timeit
Le nombre de boucles est "-n 10000" et la répétition est "-r 10".

Mesure du temps de traitement

#Mesure du temps de traitement
%timeit -n 10000 -r 10 turn_matrix(in_matrix)

4. Méthode de translocation envisagée

--Transfert par double boucle [[turn_matrix1 ()](# 6-1-Transfert par double boucle 1), [turn_matrix2 ()](# 6-2-Transfert par double boucle 2)] --Transfert par la fonction intégrée zip () [[turn_matrix3 ()](# 6-3-Transfert par la fonction intégrée zip), [turn_matrix4 ()](# 6-4-Transfert par la notation d'inclusion de liste zip de la fonction intégrée) )]] --Transfert par NumPy [[turn_matrix5 ()](Transfert par # 6-5-numpy)] --Transfert par Pandas [[turn_matrix6 ()](Transfert par # 6-6-pandas)]

Parmi ce qui précède, la translocation à l'aide des fonctions intégrées zip (), NumPy et Pandas est basée sur les éléments suivants. Permuter les lignes et les colonnes d'un tableau bidimensionnel de type liste Python (translocation) | note.nkmk.me

5. Résultat de la comparaison de vitesse

En comparaison des vitesses de translocation, [Transfer by NumPy](Transfer by # 6-5-numpy) est ** extrêmement plus rapide (1,67 µs) **, suivi de [Transfer by Pandas](Transfer by # 6-6-pandas). ) (86,3 µs), [Fonction zip () + notation d'inclusion de liste](# 6-4-Transfert par notation d'inclusion de liste zip de fonction intégrée) (99,4 µs).

Cependant, dans [Transfer by NumPy](Transfer by # 6-5-numpy) et [Transfer by Pandas](Transfer by # 6-6-pandas), la conversion du type de liste en numpy.array est de ** 486 µs *. *, La conversion en pandas.DataFrame prend ** 6,19 ms , donc Le temps, y compris la conversion du type de liste, est [Transfer by NumPy](Transfer by # 6-5-numpy) ( 487.67 µs ), [Transfer by Pandas](Transfer by # 6-6-pandas) Il est devenu ( 6,2763 ms **). Par conséquent, si la matrice donnée est de type liste, le temps de traitement total pour obtenir la matrice transposée à partir de la matrice de type liste est ** [fonction zip () + notation d'inclusion de liste](# 6-4-fonction intégrée zip). (Transfert par notation d'inclusion de liste) (99,4 µs) ** a été considéré comme le plus rapide.

6. Fonction de translocation

6-1. Inversion par double boucle 1

Nom de la fonction: turn_matrix1 () Translocation par double boucle créée sans aucune référence. Passez le nombre de lignes x et le nombre de colonnes y de l'argument «matrice» à la boucle for, et extrayez de l'argument «matrice» avec le nombre de lignes comme nombre de colonnes et le nombre de colonnes comme nombre de lignes.

Inversion par double boucle 1

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Rotation de la fonction de translocation_matrix1()
def turn_matrix1(matrix):
    x = len(matrix)
    y = len(matrix[0])    
    turned = []
    for i in range(y):
        tmp = []
        for j in range(x):
            tmp.append(matrix[j][i])
        turned.append(tmp)
    return turned

#Mesure du temps de traitement
%timeit -r 10 -n 10000 turn_matrix1(in_matrix)

** Résultat d'exécution ** 777 µs ± 43.6 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

6-2. Inversion par double boucle 2

Nom de la fonction: turn_matrix2 () Dans [6-1. Translocation 1 par double boucle](# 6-1-Transfert 1 par double boucle), le nombre de lignes x et le nombre de colonnes y de l'argument matrice ont été acquis, mais l'argument matrice De, sortez ligne par ligne avec une boucle for, créez une ligne tmp avec la même valeur de numéro de colonne, et ajoutez-la à turn.

Inversion par double boucle 2

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Rotation de la fonction de translocation_matrix2()
def turn_matrix2(matrix):
    y = len(matrix[0])
    turned = []
    for i in range(y):
        tmp = []
        for j in matrix:
            tmp.append(j[i])
        turned.append(tmp)
    return turned

#Mesure du temps de traitement
%timeit -r 10 -n 10000 turn_matrix2(in_matrix)

** Résultat d'exécution ** 654 µs ± 83 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

6-3. Translocation par la fonction intégrée zip ()

Nom de la fonction: turn_matrix3 ()

Zip de fonction intégré()Déménagement par

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Rotation de la fonction de translocation_matrix3(matrix)
def turn_matrix3(matrix):
    turned = []
    for i in zip(*matrix):
        turned.append(list(i))
    return turned

#Mesure du temps de traitement
%timeit -r 10 -n 10000 turn_matrix3(in_matrix)

** Résultat d'exécution ** 105 µs ± 4.22 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

6-4. Fonction intégrée zip () + translocation par notation d'inclusion de liste

Nom de la fonction: turn_matrix4 ()

Zip de fonction intégré()+Inversion par notation d'inclusion de liste

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#Rotation de la fonction de translocation_matrix4()
def turn_matrix4(matrix):
    return [list(x) for x in zip(*matrix)]

#Mesure du temps de traitement
%timeit -r 10 -n 10000 turn_matrix3(in_matrix)

** Résultat d'exécution ** 99.4 µs ± 1.36 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

• Lorsqu'il ne fonctionne pas

Notation d'inclusion de liste

turned_matrix = [list(x) for x in zip(*in_matrix)] 

Permuter les lignes et les colonnes d'un tableau bidimensionnel de type liste Python (translocation) | note.nkmk.me

6-5. Translocation par NumPy

Nom de la fonction: turn_matrix5 ()

Translocation par NumPy

import numpy as np

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#in_numpy de matrice.tableau numpy_in_Créer une matrice
%timeit numpy_in_matrix = np.array(in_matrix)

#Rotation de la fonction de translocation_matrix5()
def turn_matrix5(matrix):
    return matrix.T

#Mesure du temps de traitement
%timeit -r 10 -n 10000 turn_matrix5(numpy_in_matrix)

** Résultat d'exécution ** Conversion de in_matrix en numpy.array 486 µs ± 10.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Translocation 1.67 µs ± 38.9 ns per loop (mean ± std. dev. of 10 runs, 10000 loops each)

• Lorsqu'il ne fonctionne pas

Translocation par NumPy

import numpy as np

turned_matrix = np.array(in_matrix).T

Permuter les lignes et les colonnes d'un tableau bidimensionnel de type liste Python (translocation) | note.nkmk.me

6-6. Réinstallation par les pandas

Nom de la fonction: turn_matrix6 ()

Translocation par les pandas

import pandas as pd

#Matrice dans laquelle transférer_Créer une matrice
n = 100
m = 100
in_matrix = [[i for i in range(n)] for j in range(m)]

#in_pandas de la matrice.Pandas DataFrame_in_Créer une matrice
%timeit pandas_in_matrix = pd.DataFrame(in_matrix)

#Rotation de la fonction de translocation_matrix6()
def turn_matrix5(matrix):
    return matrix.T

#Mesure du temps de traitement
%timeit -r 10 -n 10000 turn_matrix5(pandas_in_matrix)

** Résultat d'exécution ** -Conversion de in_matrix à pandas.DataFrame 6.19 ms ± 43.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

· Transfert 86.3 µs ± 4.54 µs per loop (mean ± std. dev. of 10 runs, 10000 loops each)

• Lorsqu'il ne fonctionne pas

Translocation par les pandas

import pandas as pd

turned_matrix = pd.DataFrame(in_matrix).T

Permuter les lignes et les colonnes d'un tableau bidimensionnel de type liste Python (translocation) | note.nkmk.me