आप पंडों के साथ सहसंबंध मैट्रिक्स में शीर्ष सहसंबंध कैसे पाते हैं? आर के साथ यह करने के लिए कई उत्तर हैं ( एक आदेशित सूची के रूप में सहसंबंध दिखाएँ, न कि एक बड़े मैट्रिक्स या कुशल तरीके के रूप में पायथन या आर में स्थापित बड़े डेटा से अत्यधिक सहसंबद्ध जोड़े प्राप्त करने के लिए ), लेकिन मैं सोच रहा हूं कि यह कैसे करना है पांडा के साथ? मेरे मामले में मैट्रिक्स 4460x4460 है, इसलिए इसे नेत्रहीन नहीं कर सकते।
पंडों में एक बड़े सहसंबंध मैट्रिक्स से उच्चतम सहसंबंध जोड़े की सूची बनाएं?
जवाबों:
आप DataFrame.valuesडेटा का एक संख्यात्मक सरणी प्राप्त करने के लिए उपयोग कर सकते हैं और फिर argsort()सबसे सहसंबद्ध जोड़े प्राप्त करने के लिए NumPy फ़ंक्शन का उपयोग कर सकते हैं।
लेकिन अगर आप पंडों में ऐसा करना चाहते हैं, तो आप कर सकते हैं unstackऔर DataFrame को छाँट सकते हैं:
import pandas as pd
import numpy as np
shape = (50, 4460)
data = np.random.normal(size=shape)
data[:, 1000] += data[:, 2000]
df = pd.DataFrame(data)
c = df.corr().abs()
s = c.unstack()
so = s.sort_values(kind="quicksort")
print so[-4470:-4460]
यहाँ उत्पादन है:
2192 1522 0.636198
1522 2192 0.636198
3677 2027 0.641817
2027 3677 0.641817
242 130 0.646760
130 242 0.646760
1171 2733 0.670048
2733 1171 0.670048
1000 2000 0.742340
2000 1000 0.742340
dtype: float64
10
पंडों v 0.17.0 और उच्चतर के साथ आपको क्रम के बजाय Sort_values का उपयोग करना चाहिए। यदि आप ऑर्डर विधि का उपयोग करके प्रयास करते हैं तो आपको एक त्रुटि मिलेगी।
—
फ्रेंडम
@ HYRY का जवाब एकदम सही है। डुप्लिकेट और स्व-सहसंबंधों और उचित छँटाई से बचने के लिए थोड़ा और तर्क जोड़कर उस उत्तर पर निर्माण करें:
import pandas as pd
d = {'x1': [1, 4, 4, 5, 6],
'x2': [0, 0, 8, 2, 4],
'x3': [2, 8, 8, 10, 12],
'x4': [-1, -4, -4, -4, -5]}
df = pd.DataFrame(data = d)
print("Data Frame")
print(df)
print()
print("Correlation Matrix")
print(df.corr())
print()
def get_redundant_pairs(df):
'''Get diagonal and lower triangular pairs of correlation matrix'''
pairs_to_drop = set()
cols = df.columns
for i in range(0, df.shape[1]):
for j in range(0, i+1):
pairs_to_drop.add((cols[i], cols[j]))
return pairs_to_drop
def get_top_abs_correlations(df, n=5):
au_corr = df.corr().abs().unstack()
labels_to_drop = get_redundant_pairs(df)
au_corr = au_corr.drop(labels=labels_to_drop).sort_values(ascending=False)
return au_corr[0:n]
print("Top Absolute Correlations")
print(get_top_abs_correlations(df, 3))
यह निम्न आउटपुट देता है:
Data Frame
x1 x2 x3 x4
0 1 0 2 -1
1 4 0 8 -4
2 4 8 8 -4
3 5 2 10 -4
4 6 4 12 -5
Correlation Matrix
x1 x2 x3 x4
x1 1.000000 0.399298 1.000000 -0.969248
x2 0.399298 1.000000 0.399298 -0.472866
x3 1.000000 0.399298 1.000000 -0.969248
x4 -0.969248 -0.472866 -0.969248 1.000000
Top Absolute Correlations
x1 x3 1.000000
x3 x4 0.969248
x1 x4 0.969248
dtype: float64
बजाय get_redundant_pairs (df), तो आप उपयोग कर सकते हैं "cor.loc [:,:] = np.tril (cor.values k = -1)" और फिर "कोर = कोर [कोर> 0]"
—
सारा
मुझे लाइन के लिए इर्रो मिल रही है
—
स्टालिंगऑन
au_corr = au_corr.drop(labels=labels_to_drop).sort_values(ascending=False):# -- partial selection or non-unique index
चर के अनावश्यक जोड़े के बिना कुछ लाइनों का समाधान:
corr_matrix = df.corr().abs()
#the matrix is symmetric so we need to extract upper triangle matrix without diagonal (k = 1)
sol = (corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))
.stack()
.sort_values(ascending=False))
#first element of sol series is the pair with the biggest correlation
फिर आप चर जोड़े (जो कि पांडा हैं। मल्टी-इंडेक्स) के नामों के माध्यम से पुनरावृति कर सकते हैं और उनके मूल्य इस प्रकार हैं:
for index, value in sol.items():
# do some staff
शायद एक
—
shadi
osचर नाम के रूप में उपयोग करने के लिए एक बुरा विचार है क्योंकि यह कोड में उपलब्ध होने osसे मास्क करता हैimport os
आपके सुझाव के लिए धन्यवाद, मैंने इस unproper var नाम को बदल दिया।
—
MiFi
2018 के अनुसार क्रम के बजाय Sort_values (आरोही = गलत) का उपयोग करें
—
सेराफिन्स
लूप कैसे करें 'सोल' ??
—
सरजाय
@sirjay मैंने आपके प्रश्न का उत्तर ऊपर रखा
—
MiFi
@ हाई और अरुण के उत्तरों की कुछ विशेषताओं को मिलाकर, आप dfएक ही पंक्ति में डेटाफ़्रेम के लिए शीर्ष सहसंबंधों को प्रिंट कर सकते हैं :
df.corr().unstack().sort_values().drop_duplicates()
नोट: एक नकारात्मक पक्ष यह है कि यदि आपके पास 1.0 सहसंबंध हैं जो स्वयं के लिए एक चर नहीं हैं , तो drop_duplicates()जोड़ उन्हें हटा देगा
drop_duplicatesसभी सहसंबंधों को नहीं छोड़ेंगे जो समान हैं?
@ शदी हां, आप सही हैं। हालाँकि, हम केवल ऐसे सहसंबंधों को मानते हैं जो समान रूप से समान होंगे 1.0 के सहसंबंध हैं (अर्थात स्वयं के साथ एक चर)। संभावना हैं कि चर (यानी के दो अद्वितीय जोड़े के लिए सह-संबंध
—
एडिसन Klinke
v1को v2और v3करने के लिए v4) ठीक उसी नहीं होगा
निश्चित रूप से मेरे favoirite, सादगी ही। मेरे उपयोग में, मैंने उच्च गलियारों के लिए पहले फ़िल्टर किया
—
जेम्स इगोए
अवरोही क्रम में सहसंबंधों को देखने के लिए नीचे दिए गए कोड का उपयोग करें।
# See the correlations in descending order
corr = df.corr() # df is the pandas dataframe
c1 = corr.abs().unstack()
c1.sort_values(ascending = False)
आपकी दूसरी पंक्ति होनी चाहिए: c1 = core.abs ()। अनस्टैक ()
—
जैक
या पहली पंक्ति
—
vizyourdata
corr = df.corr()
आप अपने डेटा को प्रतिस्थापित करके इस सरल कोड के अनुसार रेखांकन कर सकते हैं।
corr = df.corr()
kot = corr[corr>=.9]
plt.figure(figsize=(12,8))
sns.heatmap(kot, cmap="Greens")
itertools.combinationsपांडा के सभी सहसंबंध मैट्रिक्स से सभी अद्वितीय सहसंबंधों को प्राप्त करने के लिए उपयोग करें .corr(), सूचियों की सूची बनाएं और '.sort_values' का उपयोग करने के लिए इसे वापस डेटाफ़्रेम में फ़ीड करें। ascending = Trueशीर्ष पर सबसे कम सहसंबंध प्रदर्शित करने के लिए सेट करें
corrankDataFrame को तर्क के रूप में लेता है क्योंकि इसके लिए आवश्यकता होती है .corr()।
def corrank(X: pandas.DataFrame):
import itertools
df = pd.DataFrame([[(i,j),X.corr().loc[i,j]] for i,j in list(itertools.combinations(X.corr(), 2))],columns=['pairs','corr'])
print(df.sort_values(by='corr',ascending=False))
corrank(X) # prints a descending list of correlation pair (Max on top)
हालांकि यह कोड स्निपेट समाधान हो सकता है, स्पष्टीकरण सहित वास्तव में आपके पोस्ट की गुणवत्ता में सुधार करने में मदद करता है। याद रखें कि आप भविष्य में पाठकों के लिए प्रश्न का उत्तर दे रहे हैं, और वे लोग आपके कोड सुझाव के कारणों को नहीं जान सकते हैं।
—
हंदल
मैं unstackइस मुद्दे को या अधिक जटिल नहीं करना चाहता था , क्योंकि मैं एक सुविधा चयन चरण के हिस्से के रूप में कुछ अत्यधिक सहसंबद्ध सुविधाओं को छोड़ना चाहता था।
तो मैं निम्नलिखित सरलीकृत समाधान के साथ समाप्त हुआ:
# map features to their absolute correlation values
corr = features.corr().abs()
# set equality (self correlation) as zero
corr[corr == 1] = 0
# of each feature, find the max correlation
# and sort the resulting array in ascending order
corr_cols = corr.max().sort_values(ascending=False)
# display the highly correlated features
display(corr_cols[corr_cols > 0.8])
इस मामले में, यदि आप सहसंबद्ध सुविधाओं को छोड़ना चाहते हैं, तो आप फ़िल्टर्ड corr_colsसरणी के माध्यम से मैप कर सकते हैं और विषम-अनुक्रमित (या सम-अनुक्रमित) को हटा सकते हैं।
यह सिर्फ एक इंडेक्स (सुविधा) देता है न कि फीचर 1 फीचर 2 0.98 जैसा कुछ।
—
१un
corr_cols = corr.max().sort_values(ascending=False)corr_cols = corr.unstack()
खैर ओपी ने एक सहसंबंध आकार निर्दिष्ट नहीं किया। जैसा कि मैंने उल्लेख किया है, मैं अनस्टैक नहीं करना चाहता था, इसलिए मैं सिर्फ एक अलग दृष्टिकोण लाया। प्रत्येक सहसंबंध जोड़ी को मेरे सुझाए गए कोड में 2 पंक्तियों द्वारा दर्शाया गया है। लेकिन उपयोगी टिप्पणी के लिए धन्यवाद!
—
falsarella
मैं यहाँ कुछ समाधानों की कोशिश कर रहा था, लेकिन तब मैं वास्तव में अपने स्वयं के साथ आया था। मुझे उम्मीद है कि यह अगले एक के लिए उपयोगी हो सकता है इसलिए मैं इसे यहां साझा करता हूं:
def sort_correlation_matrix(correlation_matrix):
cor = correlation_matrix.abs()
top_col = cor[cor.columns[0]][1:]
top_col = top_col.sort_values(ascending=False)
ordered_columns = [cor.columns[0]] + top_col.index.tolist()
return correlation_matrix[ordered_columns].reindex(ordered_columns)
यह @MiFi से बेहतर कोड है। एब्स में यह एक आदेश है लेकिन नकारात्मक मूल्यों को छोड़कर नहीं।
def top_correlation (df,n):
corr_matrix = df.corr()
correlation = (corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))
.stack()
.sort_values(ascending=False))
correlation = pd.DataFrame(correlation).reset_index()
correlation.columns=["Variable_1","Variable_2","Correlacion"]
correlation = correlation.reindex(correlation.Correlacion.abs().sort_values(ascending=False).index).reset_index().drop(["index"],axis=1)
return correlation.head(n)
top_correlation(ANYDATA,10)
निम्नलिखित फ़ंक्शन को चाल करना चाहिए। यह कार्यान्वयन
- स्वसंबंधों को दूर करता है
- डुप्लिकेट निकालता है
- शीर्ष एन उच्चतम सहसंबद्ध सुविधाओं का चयन सक्षम करता है
और यह कॉन्फ़िगर करने योग्य भी है ताकि आप दोनों स्व-सहसंबंधों के साथ-साथ डुप्लिकेट भी रख सकें। आप अपनी इच्छानुसार कई फीचर जोड़े की रिपोर्ट भी कर सकते हैं।
def get_feature_correlation(df, top_n=None, corr_method='spearman',
remove_duplicates=True, remove_self_correlations=True):
"""
Compute the feature correlation and sort feature pairs based on their correlation
:param df: The dataframe with the predictor variables
:type df: pandas.core.frame.DataFrame
:param top_n: Top N feature pairs to be reported (if None, all of the pairs will be returned)
:param corr_method: Correlation compuation method
:type corr_method: str
:param remove_duplicates: Indicates whether duplicate features must be removed
:type remove_duplicates: bool
:param remove_self_correlations: Indicates whether self correlations will be removed
:type remove_self_correlations: bool
:return: pandas.core.frame.DataFrame
"""
corr_matrix_abs = df.corr(method=corr_method).abs()
corr_matrix_abs_us = corr_matrix_abs.unstack()
sorted_correlated_features = corr_matrix_abs_us \
.sort_values(kind="quicksort", ascending=False) \
.reset_index()
# Remove comparisons of the same feature
if remove_self_correlations:
sorted_correlated_features = sorted_correlated_features[
(sorted_correlated_features.level_0 != sorted_correlated_features.level_1)
]
# Remove duplicates
if remove_duplicates:
sorted_correlated_features = sorted_correlated_features.iloc[:-2:2]
# Create meaningful names for the columns
sorted_correlated_features.columns = ['Feature 1', 'Feature 2', 'Correlation (abs)']
if top_n:
return sorted_correlated_features[:top_n]
return sorted_correlated_features
मुझे एडिसन केलिंक्स का पोस्ट सबसे सरल लगा, लेकिन फ़िल्टरिंग और चार्टिंग के लिए Wojciech Moszczy forsk के सुझाव का उपयोग किया, लेकिन निरपेक्ष मूल्यों से बचने के लिए फ़िल्टर का विस्तार किया, इसलिए एक बड़ा सहसंबंध मैट्रिक्स दिया, इसे फ़िल्टर करें, इसे चार्ट करें, और फिर इसे समतल करें:
बनाया गया, फ़िल्टर्ड और चार्टेड
dfCorr = df.corr()
filteredDf = dfCorr[((dfCorr >= .5) | (dfCorr <= -.5)) & (dfCorr !=1.000)]
plt.figure(figsize=(30,10))
sn.heatmap(filteredDf, annot=True, cmap="Reds")
plt.show()
समारोह
अंत में, मैंने सहसंबंध मैट्रिक्स बनाने के लिए एक छोटा सा फ़ंक्शन बनाया, इसे फ़िल्टर किया, और फिर इसे समतल किया। एक विचार के रूप में, इसे आसानी से बढ़ाया जा सकता है, जैसे, असममित ऊपरी और निचले सीमा, आदि।
def corrFilter(x: pd.DataFrame, bound: float):
xCorr = x.corr()
xFiltered = xCorr[((xCorr >= bound) | (xCorr <= -bound)) & (xCorr !=1.000)]
xFlattened = xFiltered.unstack().sort_values().drop_duplicates()
return xFlattened
corrFilter(df, .7)
कैसे बहुत पिछले एक को दूर करने के लिए? HofstederPowerDx और Hofsteder PowerDx एक ही चर हैं, है ना?
—
ल्यूक
कार्यों में .dropna () का उपयोग कर सकते हैं। मैंने इसे वीएस कोड में आज़माया और यह काम करता है, जहां मैं सहसंबंध मैट्रिक्स बनाने और फ़िल्टर करने के लिए पहले समीकरण का उपयोग करता हूं, और दूसरा इसे समतल करने के लिए। यदि आप इसका उपयोग करते हैं, तो आप .dropduplicates () को देखने के लिए प्रयोग कर सकते हैं, यह देखने के लिए कि क्या आपको .dropna () और dropduplicates () दोनों की आवश्यकता है।
—
जेम्स इगोए
एक नोटबुक जिसमें यह कोड शामिल है और कुछ अन्य सुधार यहाँ हैं: github.com/JamesIgoe/GoogleFitAnalysis
—
जेम्स इगोए