पैंडस डेटाफ्रेम से जेककार्ड समानता की गणना कैसे करें

Question

मेरे पास डेटाफ्रेम निम्नानुसार है: फ्रेम का आकार (1510, 13 99) है। कॉलम उत्पादों का प्रतिनिधित्व करते हैं, पंक्तियां किसी दिए गए उत्पाद के लिए उपयोगकर्ता द्वारा असाइन किए गए मान (0 या 1) का प्रतिनिधित्व करती हैं। मैं jaccard_similarity_score की गणना कैसे कर सकता हूं?

मैं एक प्लेसहोल्डर dataframe उत्पाद प्रविष्टि बनाम उत्पाद

data_ibs = pd.DataFrame(index=data_g.columns,columns=data_g.columns) 

मुझे यकीन है कि data_ibs समानताएं गणना करने के लिए हालांकि पुनरावृति करने के लिए कैसे नहीं कर रहा हूँ बनाया।

for i in range(0,len(data_ibs.columns)) : 
    # Loop through the columns for each column 
    for j in range(0,len(data_ibs.columns)) : 
......... 

Answer 1

लघु और vectorized (तेज) जवाब:

scikit जोड़ो में दूरी से प्रयोग करें 'आलोचनात्मक' सीखना:

from sklearn.metrics.pairwise import pairwise_distances 
jac_sim = 1 - pairwise_distances(df.T, metric = "hamming") 
# optionally convert it to a DataFrame 
jac_sim = pd.DataFrame(jac_sim, index=df.columns, columns=df.columns) 

---

स्पष्टीकरण:

मान लें यह है आपका डेटासेट:

import pandas as pd 
import numpy as np 
np.random.seed(0) 
df = pd.DataFrame(np.random.binomial(1, 0.5, size=(100, 5)), columns=list('ABCDE')) 
print(df.head()) 

    A B C D E 
0 1 1 1 1 0 
1 1 0 1 1 0 
2 1 1 1 1 0 
3 0 0 1 1 1 
4 1 1 0 1 0 

sklearn के jaccard_similarity_score, स्तंभ ए और बी के बीच समानता का उपयोग करना है:

from sklearn.metrics import jaccard_similarity_score 
print(jaccard_similarity_score(df['A'], df['B'])) 
0.43 

यह मैं के रूप में जहाँ तक पंक्तियों पंक्तियों की कुल संख्या से अधिक एक ही मूल्य है कि की संख्या, 100

है पता है, jaccard_similarity_score का कोई जोड़ी संस्करण नहीं है लेकिन दूरी के जोड़ों के संस्करण हैं। इस प्रकार

हालांकि, SciPy Jaccard distance परिभाषित करता है:

को देखते हुए दो वैक्टर, यू और वी, Jaccard दूरी उन तत्वों का अनुपात है यू [i] और वी [i] कि असहमत जहां कम से कम एक उनमें से शून्य नहीं है।

तो यह उन पंक्तियों को बाहर करता है जहां दोनों कॉलम में 0 मान हैं। jaccard_similarity_score नहीं करता है। दूरी हैमिंग, दूसरे हाथ पर, समानता परिभाषा के साथ इनलाइन है:

उन वेक्टर तत्वों का अनुपात दो वैक्टर n u और वी जो असहमत के बीच।

from sklearn.metrics.pairwise import pairwise_distances 
print(1 - pairwise_distances(df.T, metric = "hamming")) 

array([[ 1. , 0.43, 0.61, 0.55, 0.46], 
     [ 0.43, 1. , 0.52, 0.56, 0.49], 
     [ 0.61, 0.52, 1. , 0.48, 0.53], 
     [ 0.55, 0.56, 0.48, 1. , 0.49], 
     [ 0.46, 0.49, 0.53, 0.49, 1. ]]) 

एक DataFrame के स्वरूप में:: के संयोजन से अधिक पुनरावृत्ति द्वारा

jac_sim = 1 - pairwise_distances(df.T, metric = "hamming") 
jac_sim = pd.DataFrame(jac_sim, index=df.columns, columns=df.columns) 
# jac_sim = np.triu(jac_sim) to set the lower diagonal to zero 
# jac_sim = np.tril(jac_sim) to set the upper diagonal to zero 

     A  B  C  D  E 
A 1.00 0.43 0.61 0.55 0.46 
B 0.43 1.00 0.52 0.56 0.49 
C 0.61 0.52 1.00 0.48 0.53 
D 0.55 0.56 0.48 1.00 0.49 
E 0.46 0.49 0.53 0.49 1.00 

आप भी ऐसा कर सकते आलोचनात्मक -

तो अगर आप jaccard_similarity_score गणना करना चाहते हैं, तो आप उपयोग कर सकते हैं 1 कॉलम लेकिन यह बहुत धीमा हो जाएगा।

import itertools 
sim_df = pd.DataFrame(np.ones((5, 5)), index=df.columns, columns=df.columns) 
for col_pair in itertools.combinations(df.columns, 2): 
    sim_df.loc[col_pair] = sim_df.loc[tuple(reversed(col_pair))] = jaccard_similarity_score(df[col_pair[0]], df[col_pair[1]]) 
print(sim_df) 
     A  B  C  D  E 
A 1.00 0.43 0.61 0.55 0.46 
B 0.43 1.00 0.52 0.56 0.49 
C 0.61 0.52 1.00 0.48 0.53 
D 0.55 0.56 0.48 1.00 0.49 
E 0.46 0.49 0.53 0.49 1.00