पायथन में प्रमुख घटक विश्लेषण और प्रतिगमन


11

मैं यह पता लगाने की कोशिश कर रहा हूं कि पायस में कुछ काम जो मैंने एसएएस में किए हैं, कैसे पुन: पेश करें। इस डेटासेट का उपयोग करना , जहां बहुसंस्कृति एक समस्या है, मैं पायथन में प्रमुख घटक विश्लेषण करना चाहूंगा। मैंने स्किटिट-लर्न और स्टैटमोडेल को देखा है, लेकिन मैं अनिश्चित हूं कि उनका आउटपुट कैसे लिया जाए और इसे एसएएस के समान परिणाम संरचना में परिवर्तित किया जाए। जब आप उपयोग करते हैं PROC PRINCOMP, तो एक चीज़ के लिए, एसएएस सहसंबंध मैट्रिक्स पर पीसीए प्रदर्शित करता है , लेकिन पायथन पुस्तकालयों के अधिकांश (सभी?) एसवीडी का उपयोग करते दिखाई देते हैं।

में डाटासेट , पहले कॉलम प्रतिक्रिया चर रहा है और अगले 5 भविष्य कहनेवाला चर, pred1-pred5 कहा जाता है।

SAS में, सामान्य वर्कफ़्लो है:

/* Get the PCs */
proc princomp data=indata out=pcdata;
    var pred1 pred2 pred3 pred4 pred5;
run;

/* Standardize the response variable */
proc standard data=pcdata mean=0 std=1 out=pcdata2;
    var response;
run;

/* Compare some models */
proc reg data=pcdata2;
    Reg:     model response = pred1 pred2 pred3 pred4 pred5 / vif;
    PCa:     model response = prin1-prin5 / vif;
    PCfinal: model response = prin1 prin2 / vif;
run;
quit;

/* Use Proc PLS to to PCR Replacement - dropping pred5 */
/* This gets me my parameter estimates for the original data */
proc pls data=indata method=pcr nfac=2;
    model response = pred1 pred2 pred3 pred4 / solution;
run;
quit;

मुझे पता है कि अंतिम चरण केवल इसलिए काम करता है क्योंकि मैं क्रम में केवल PC1 और PC2 चुन रहा हूं।

तो, पायथन में, इस बारे में जहाँ तक मैंने देखा है:

import pandas as pd
import numpy  as np
from sklearn.decomposition.pca import PCA

source = pd.read_csv('C:/sourcedata.csv')

# Create a pandas DataFrame object
frame = pd.DataFrame(source)

# Make sure we are working with the proper data -- drop the response variable
cols = [col for col in frame.columns if col not in ['response']]
frame2 = frame[cols]

pca = PCA(n_components=5)
pca.fit(frame2)

प्रत्येक पीसी बताते हैं कि विचरण की मात्रा?

print pca.explained_variance_ratio_

Out[190]:
array([  9.99997603e-01,   2.01265023e-06,   2.70712663e-07,
         1.11512302e-07,   2.40310191e-09])

ये क्या हैं? Eigenvectors?

print pca.components_

Out[179]:
array([[ -4.32840645e-04,  -7.18123771e-04,  -9.99989955e-01,
         -4.40303223e-03,  -2.46115129e-05],
       [  1.00991662e-01,   8.75383248e-02,  -4.46418880e-03,
          9.89353169e-01,   5.74291257e-02],
       [ -1.04223303e-02,   9.96159390e-01,  -3.28435046e-04,
         -8.68305757e-02,  -4.26467920e-03],
       [ -7.04377522e-03,   7.60168675e-04,  -2.30933755e-04,
          5.85966587e-02,  -9.98256573e-01],
       [ -9.94807648e-01,  -1.55477793e-03,  -1.30274879e-05,
          1.00934650e-01,   1.29430210e-02]])

क्या ये स्वदेशी हैं?

print pca.explained_variance_

Out[180]:
array([  8.07640319e+09,   1.62550137e+04,   2.18638986e+03,
         9.00620474e+02,   1.94084664e+01])

मैं पायथन परिणाम से वास्तव में प्रिंसिपल कंपोनेंट रिग्रेशन (पायथन में) का प्रदर्शन करने के तरीके के बारे में थोड़ा नुकसान पर हूं। क्या पायथन लाइब्रेरी में से कोई भी एसएएस के समान रिक्त स्थान को भरता है?

किसी भी सुझाव की सराहना की है। मैं एसएएस आउटपुट में लेबल के उपयोग से थोड़ा खराब हो गया हूं और मैं पांडा, संख्यात्मक, डरावना या डरावना-परिचित से बहुत परिचित नहीं हूं।


संपादित करें:

तो, ऐसा लगता है कि स्केलेन सीधे पंडों के डेटाफ़्रेम पर काम नहीं करेगा। मान लीजिए कि मैं इसे एक अफीम सरणी में परिवर्तित करता हूं:

npa = frame2.values
npa

यहाँ मुझे क्या मिलेगा:

Out[52]:
array([[  8.45300000e+01,   4.20730000e+02,   1.99443000e+05,
          7.94000000e+02,   1.21100000e+02],
       [  2.12500000e+01,   2.73810000e+02,   4.31180000e+04,
          1.69000000e+02,   6.28500000e+01],
       [  3.38200000e+01,   3.73870000e+02,   7.07290000e+04,
          2.79000000e+02,   3.53600000e+01],
       ..., 
       [  4.71400000e+01,   3.55890000e+02,   1.02597000e+05,
          4.07000000e+02,   3.25200000e+01],
       [  1.40100000e+01,   3.04970000e+02,   2.56270000e+04,
          9.90000000e+01,   7.32200000e+01],
       [  3.85300000e+01,   3.73230000e+02,   8.02200000e+04,
          3.17000000e+02,   4.32300000e+01]])

अगर मैं copysklearn के PCA के पैरामीटर को बदल देता हूं तो False,यह नीचे दी गई टिप्पणी के अनुसार सीधे सरणी पर संचालित होता है।

pca = PCA(n_components=5,copy=False)
pca.fit(npa)

npa

आउटपुट के अनुसार, ऐसा लगता है कि यह npaसरणी में किसी भी चीज़ को जोड़ने के बजाय सभी मानों को बदल दिया है । अब इसमें क्या मूल्य npaहैं? मूल सरणी के लिए प्रमुख घटक स्कोर?

Out[64]:
array([[  3.91846649e+01,   5.32456568e+01,   1.03614689e+05,
          4.06726542e+02,   6.59830027e+01],
       [ -2.40953351e+01,  -9.36743432e+01,  -5.27103110e+04,
         -2.18273458e+02,   7.73300268e+00],
       [ -1.15253351e+01,   6.38565684e+00,  -2.50993110e+04,
         -1.08273458e+02,  -1.97569973e+01],
       ..., 
       [  1.79466488e+00,  -1.15943432e+01,   6.76868901e+03,
          1.97265416e+01,  -2.25969973e+01],
       [ -3.13353351e+01,  -6.25143432e+01,  -7.02013110e+04,
         -2.88273458e+02,   1.81030027e+01],
       [ -6.81533512e+00,   5.74565684e+00,  -1.56083110e+04,
         -7.02734584e+01,  -1.18869973e+01]])

1
स्किकिट-लर्न में, प्रत्येक नमूने को आपके डेटा मैट्रिक्स में एक पंक्ति के रूप में संग्रहीत किया जाता है । पीसीए वर्ग सीधे डेटा मैट्रिक्स पर काम करता है अर्थात, यह सहसंयोजक मैट्रिक्स की गणना करने का ध्यान रखता है , और फिर इसके आइजनवेक्टर। आपके अंतिम 3 प्रश्नों के बारे में, हां, कंपोनेंट्स_ कोविर्सियस मैट्रिक्स के आईजेनवेक्टर हैं, समझाया_विरियन_रैटो_ प्रत्येक पीसी बताते हैं, और समझाया गया विचरण आइजेनवॉल के अनुरूप होना चाहिए।
लाइटकेमिस्ट

@lightalchemist स्पष्टीकरण के लिए धन्यवाद। स्केलेर के साथ, क्या पीसीए करने से पहले एक नया डेटाफ़्रेम तैयार करना उचित है, या क्या यह 'पूर्ण' पांडा डेटाफ़्रेम में भेजना संभव है और क्या यह बाईं ओर (प्रतिक्रिया) कॉलम पर काम नहीं करता है?
क्ले

मैंने थोड़ी और जानकारी जोड़ी। यदि मैं पहले एक अफीम सरणी में परिवर्तित करता हूं और फिर पीसीए के साथ चलाता copy=Falseहूं, तो मुझे नए मूल्य मिलते हैं। क्या वे प्रमुख घटक स्कोर हैं?
क्ले

मैं पंडों से परिचित नहीं हूँ इसलिए मुझे आपके प्रश्न के उस हिस्से का उत्तर नहीं मिला। दूसरे भाग के बारे में, मुझे नहीं लगता कि वे प्रमुख घटक हैं। मेरा मानना ​​है कि वे मूल डेटा नमूने हैं, लेकिन घटाव के साथ। हालाँकि, मैं वास्तव में इसके बारे में निश्चित नहीं हो सकता।
लाइटकेमिस्ट

जवाबों:


16

स्किकिट-लर्न में पीसीए और प्रतिगमन का संयुक्त कार्यान्वयन नहीं है, उदाहरण के लिए, आर पैकेज में pls पैकेज। लेकिन मुझे लगता है कि कोई नीचे की तरह कर सकता है या पीएलएस प्रतिगमन चुन सकता है।

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.preprocessing import scale
from sklearn.decomposition import PCA
from sklearn import cross_validation
from sklearn.linear_model import LinearRegression

%matplotlib inline

import seaborn as sns
sns.set_style('darkgrid')

df = pd.read_csv('multicollinearity.csv')
X = df.iloc[:,1:6]
y = df.response

Scikit- पीसीए सीखें

pca = PCA()

प्रिंसिपल कंपोनेंट्स को पाने के लिए स्केल और ट्रांसफॉर्म डाटा

X_reduced = pca.fit_transform(scale(X))

मूल घटकों द्वारा समझाया गया विचरण (% संचयी)

np.cumsum(np.round(pca.explained_variance_ratio_, decimals=4)*100)

array([  73.39,   93.1 ,   98.63,   99.89,  100.  ])

पहले दो घटकों की तरह लगता है वास्तव में डेटा में सबसे विचरण की व्याख्या करते हैं।

10-गुना CV, फेरबदल के साथ

n = len(X_reduced)
kf_10 = cross_validation.KFold(n, n_folds=10, shuffle=True, random_state=2)

regr = LinearRegression()
mse = []

एक सीवी केवल इंटरसेप्ट के लिए करें (प्रतिगमन में कोई प्रमुख घटक नहीं)

score = -1*cross_validation.cross_val_score(regr, np.ones((n,1)), y.ravel(), cv=kf_10, scoring='mean_squared_error').mean()    
mse.append(score) 

5 सिद्धांत घटकों के लिए सीवी करें, समय पर प्रतिगमन में एक घटक जोड़ रहा है

for i in np.arange(1,6):
    score = -1*cross_validation.cross_val_score(regr, X_reduced[:,:i], y.ravel(), cv=kf_10, scoring='mean_squared_error').mean()
    mse.append(score)

fig, (ax1, ax2) = plt.subplots(1,2, figsize=(12,5))
ax1.plot(mse, '-v')
ax2.plot([1,2,3,4,5], mse[1:6], '-v')
ax2.set_title('Intercept excluded from plot')

for ax in fig.axes:
    ax.set_xlabel('Number of principal components in regression')
    ax.set_ylabel('MSE')
    ax.set_xlim((-0.2,5.2))

यहां छवि विवरण दर्ज करें

स्किकिट-सीखें पीएलएस प्रतिगमन

mse = []

kf_10 = cross_validation.KFold(n, n_folds=10, shuffle=True, random_state=2)

for i in np.arange(1, 6):
    pls = PLSRegression(n_components=i, scale=False)
    pls.fit(scale(X_reduced),y)
    score = cross_validation.cross_val_score(pls, X_reduced, y, cv=kf_10, scoring='mean_squared_error').mean()
    mse.append(-score)

plt.plot(np.arange(1, 6), np.array(mse), '-v')
plt.xlabel('Number of principal components in PLS regression')
plt.ylabel('MSE')
plt.xlim((-0.2, 5.2))

यहां छवि विवरण दर्ज करें


7

यहां पाइथन और न्यूमपी (केवल बाद में) में एसवीडी है।
(यह SSA / sklearn / pandas के बारे में आपके प्रश्नों को बिल्कुल भी संबोधित नहीं करता है, लेकिन किसी दिन एक अजगर मदद कर सकता है ।)

#!/usr/bin/env python2
""" SVD straight up """
# geometry: see http://www.ams.org/samplings/feature-column/fcarc-svd

from __future__ import division
import sys
import numpy as np

__version__ = "2015-06-15 jun  denis-bz-py t-online de"

# from bz.etc import numpyutil as nu
def ints( x ):
    return np.round(x).astype(int)  # NaN Inf -> - maxint

def quantiles( x ):
    return "quantiles %s" % ints( np.percentile( x, [0, 25, 50, 75, 100] ))


#...........................................................................
csvin = "ccheaton-multicollinearity.csv"  # https://gist.github.com/ccheaton/8393329
plot = 0

    # to change these vars in sh or ipython, run this.py  csvin=\"...\"  plot=1  ...
for arg in sys.argv[1:]:
    exec( arg )

np.set_printoptions( threshold=10, edgeitems=10, linewidth=120,
    formatter = dict( float = lambda x: "%.2g" % x ))  # float arrays %.2g

#...........................................................................
yX = np.loadtxt( csvin, delimiter="," )
y = yX[:,0]
X = yX[:,1:]
print "read %s" % csvin
print "y %d  %s" % (len(y), quantiles(y))
print "X %s  %s" % (X.shape, quantiles(X))
print ""

#...........................................................................
U, sing, Vt = np.linalg.svd( X, full_matrices=False )
#...........................................................................

print "SVD: %s -> U %s . sing diagonal . Vt %s" % (
        X.shape, U.shape, Vt.shape )
print "singular values:", ints( sing )
    # % variance (sigma^2) explained != % sigma explained, e.g. 10 1 1 1 1

var = sing**2
var *= 100 / var.sum()
print "% variance ~ sing^2:", var

print "Vt, the right singular vectors  * 100:\n", ints( Vt * 100 )
    # multicollinear: near +- 100 in each row / col

yU = y.dot( U )
yU *= 100 / yU.sum()
print "y ~ these percentages of U, the left singular vectors:", yU


-> लॉग

# from: test-pca.py
# run: 15 Jun 2015 16:45  in ~bz/py/etc/data/etc  Denis-iMac 10.8.3
# versions: numpy 1.9.2  scipy 0.15.1   python 2.7.6   mac 10.8.3

read ccheaton-multicollinearity.csv
y 373  quantiles [  2823  60336  96392 147324 928560]
X (373, 5)  quantiles [     7     47    247    573 512055]

SVD: (373, 5) -> U (373, 5) . sing diagonal . Vt (5, 5)
singular values: [2537297    4132    2462     592      87]
% variance ~ sing^2: [1e+02 0.00027 9.4e-05 5.4e-06 1.2e-07]
Vt, the right singular vectors  * 100:
[[  0   0 100   0   0]
 [  1  98   0 -12  17]
 [-10 -11   0 -99  -6]
 [  1 -17   0  -4  98]
 [-99   2   0  10   2]]
y ~ these percentages of U, the left singular vectors: [1e+02 15 -18 0.88 -0.57]

मैं एक पार्टी है, लेकिन महान जवाब देने के लिए देर से थोड़ा कर रहा हूँ
plumbus_bouquet

4

सिद्धांत घटकों के विश्लेषण और रैखिक प्रतिगमन को संयोजित करने के लिए एक पाइपलाइन का उपयोग करने का प्रयास करें:

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline

# Principle components regression
steps = [
    ('scale', StandardScaler()),
    ('pca', PCA()),
    ('estimator', LinearRegression())
]
pipe = Pipeline(steps)
pca = pipe.set_params(pca__n_components=3)
pca.fit(X, y)

3

मेरा जवाब लगभग पांच साल देर से आ रहा है और एक अच्छा मौका है कि आपको अब पायथन में पीसीआर करने के बारे में मदद की ज़रूरत नहीं है। हमने हॉगगॉर्म नाम का एक पायथन पैकेज विकसित किया है जो वास्तव में आपको वापस चाहिए था। कृपया यहाँ पीसीआर के उदाहरण देखें । हॉगगोर्म के साथ गणना परिणामों के दृश्य के लिए हॉगगोर्मप्लॉट नामक एक पूरक प्लॉटिंग पैकेज भी है ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.