boucle Optimisation pour trouver les différences entre les deux tableaux avec décile héliporté pour heatmap terrain

Question

code a été écrit avant tout plan de l'utiliser pour de nombreux fichiers de données - manque scalabiity

Le problème: J'ai deux tableaux remplis avec des scores de prédiction entre 0 et 1. Je souhaite comparer les différences entre deux sorties de modèle différentes, dans une carte thermique 10x10. Je reçois un score du modèle NNC, et vois à quelle distance de l'instance correspondante se trouve le FLC, compte le nombre et la distribution de ces différences, puis trace.

choses que je suis envisage/ont été proposées par d'autres:

1) tour des tableaux en dataframes pandas, potentiellement plus rapide pour les actions en vrac. Peut-être utiliser une colonne de branchement dataframe pour chaque sous-ensemble de décile

2) progressivement créer 10 tableaux individuels à la volée pour partitionner les valeurs dans des seaux décile avant de reboucler

3) combiner tous les fichiers en un seul tableau, il sera toujours prendre de temps, mais pas du jour au lendemain

4) remplacer une partie des opérations mathématiques en ligne avec la définition des fonctions

pour un fichier, il faut ~ 80 pour compléter la procédure, ce qui est correct pour un jeu de données, mais pas 600 à moins que je veux courir pendant la nuit. Ceci est la cellule qui prend la plus longue: (code a été modifié un peu pour le laisser être exécuté par lui-même)

import time 
import numpy as np 
import pandas as pd 
import seaborn as sns 
import matplotlib.pyplot as plt 

startTime = time.time() 

fromNNC = 0 
toNNC = 0.1 
fromDC = 0 
toDC = 0.1 

comparisonNNC = np.random.rand(14044, 1) 
comparisonFLC = np.random.rand(14044, 1) 

diffGridC = np.array([]) 
diffGridCounterC = 0 

thisDiffC = 0 

for yaxis in range(10):   
    for xaxis in range(10): 
     for eachScore in range(len(comparisonNNC)): 
      if(comparisonNNC[eachScore] > fromNNC and comparisonNNC[eachScore] < toNNC): 
       thisDiffC = (abs(comparisonNNC[eachScore] - comparisonFLC[eachScore])) 
       #print(thisDiff) 
       if(thisDiffC > fromDC and thisDiffC < toDC): 
        diffGridCounterC = diffGridCounterC + 1 

     diffGridC = np.append(diffGridC, diffGridCounterC) 
     diffGridCounterC = 0 

     fromDC = fromDC + 0.1 
     #print(fromNN) 
     toDC = toDC + 0.1 
     #print(toNN)  

    fromDC = 0.0 
    toDC = 0.1 

    fromNNC = fromNNC + 0.1 
    toNNC = toNNC + 0.1 
    print(fromNNC)  


diffGridC = diffGridC.reshape(10, 10) 
diffGridC = diffGridC.astype(int) 
print(diffGridC.shape) 

diffMapC = sns.heatmap(diffGridC, annot=True, fmt='d', cmap="OrRd") 
diffMapC.set(xlabel='Diff', ylabel='NN') 
plt.xticks(range(10), ['0.0-0.1', '0.1-0.2', '0.2-0.3', '0.3-0.4', '0.4-0.5', 
         '0.5-0.6', '0.6-0.7', '0.7-0.8', '0.8-0.9', '0.9-1.0'], rotation=50) 
plt.yticks(range(10), ['0.0-0.1', '0.1-0.2', '0.2-0.3', '0.3-0.4', '0.4-0.5', 
         '0.5-0.6', '0.6-0.7', '0.7-0.8', '0.8-0.9', '0.9-1.0'], rotation=0) 
plt.show() 

#diffGridDFC = pd.DataFrame(diffGridC) 
#diffGridDFC.to_csv('difference grid correct.csv') 

endTime = time.time() 
print(endTime - startTime) 

résultat ressemble à: Heatmap

Edit: TENTATIVE passer comme un éclair les tableaux, na pas améliorer la vitesse par beaucoup pas du tout

for eachScoreNNC, eachScoreFLC in zip(comparisonNNC, comparisonFLC): 
    if(eachScoreNNC > fromNNC and eachScoreNNC < toNNC): 
     thisDiffC = (abs(eachScoreNNC - eachScoreFLC)) 
     #print(thisDiff) 

Des suggestions d'experts experts en la matière?

Answer 1

[RESOLU], grâce à/u/two_bob sur/r/learnpython

seaux créés pour les deux tableaux qui sont à comparer, puis utilisé groupby pour compter les intersections - puis utilisé la méthode DROPIN dans le heatmap grille au lieu de faire une boucle/recherche à travers les 100 cellules pour les matches.

correctNNFL['NNbuckets'] = pd.cut(correctNNFL['Score'], np.linspace(0, 1, 11), labels=['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']) 
    correctNNFL['difference'] = abs(correctNNFL['Score'] - correctNNFL['Conf. Perc Uncreditworthy']) 
    correctNNFL['diffBuckets'] = pd.cut(correctNNFL['difference'], np.linspace(0, 1, 11), labels=['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']) 

    correctNNFL.groupby(['diffBuckets']).count() 
    diffCoords = np.array(correctNNFL[['NNbuckets', 'diffBuckets']].groupby(['diffBuckets', 'NNbuckets'])['diffBuckets'].count().index.tolist()) 
    diffIntersections = correctNNFL[['NNbuckets', 'diffBuckets']].groupby(['diffBuckets', 'NNbuckets'])['diffBuckets'].count().as_matrix() 

    diffGridC = np.zeros(100) 
    #diffGridC = np.arange(100) 
    diffGridC = diffGridC.reshape(10, 10) 
    diffGridC = diffGridC.astype(int) 

    for eachBucket in range(len(diffCoords)): 
     diffGridC[int(diffCoords[eachBucket][1])][int(diffCoords[eachBucket][0])] = int(diffIntersections[eachBucket]) 
    print(diffGridC) 
    diffMapC = sns.heatmap(diffGridC, annot=True, fmt='d', cmap="OrRd") 
    diffMapC.set(xlabel='Diff', ylabel='NN') 
    plt.show()