पायथन में एकाधिक रैखिक प्रतिगमन

Question

मैं किसी भी अजगर पुस्तकालयों को खोजने के लिए प्रतीत नहीं कर सकता जो कई प्रतिगमन करते हैं। केवल चीजें जो मुझे मिलती हैं वे केवल साधारण प्रतिगमन करते हैं। मुझे कई स्वतंत्र चर (X1, x2, x3, आदि) के खिलाफ अपने आश्रित चर (y) को पुनः प्राप्त करने की आवश्यकता है।

उदाहरण के लिए, इस डेटा के साथ:

print 'y        x1      x2       x3       x4      x5     x6       x7'
for t in texts:
    print "{:>7.1f}{:>10.2f}{:>9.2f}{:>9.2f}{:>10.2f}{:>7.2f}{:>7.2f}{:>9.2f}" /
   .format(t.y,t.x1,t.x2,t.x3,t.x4,t.x5,t.x6,t.x7)

(ऊपर के लिए उत्पादन :)

      y        x1       x2       x3        x4     x5     x6       x7
   -6.0     -4.95    -5.87    -0.76     14.73   4.02   0.20     0.45
   -5.0     -4.55    -4.52    -0.71     13.74   4.47   0.16     0.50
  -10.0    -10.96   -11.64    -0.98     15.49   4.18   0.19     0.53
   -5.0     -1.08    -3.36     0.75     24.72   4.96   0.16     0.60
   -8.0     -6.52    -7.45    -0.86     16.59   4.29   0.10     0.48
   -3.0     -0.81    -2.36    -0.50     22.44   4.81   0.15     0.53
   -6.0     -7.01    -7.33    -0.33     13.93   4.32   0.21     0.50
   -8.0     -4.46    -7.65    -0.94     11.40   4.43   0.16     0.49
   -8.0    -11.54   -10.03    -1.03     18.18   4.28   0.21     0.55

मैं लीनियर रिग्रेशन फॉर्मूला पाने के लिए अजगर में ये कैसे पाऊंगा:

Y = a1x1 + a2x2 + a3x3 + a4x4 + a5x5 + a6x6 + + a7x7 + c

Comments

एक विशेषज्ञ नहीं, लेकिन यदि चर स्वतंत्र हैं, तो क्या आप प्रत्येक के खिलाफ सरल प्रतिगमन नहीं कर सकते हैं और परिणाम का योग कर सकते हैं?

— ह्यूग बोथवेल

@HughBothwell आप यह नहीं मान सकते कि चर स्वतंत्र हैं, हालांकि। वास्तव में, यदि आप मान रहे हैं कि चर स्वतंत्र हैं, तो आप संभवतः अपने डेटा को गलत तरीके से मॉडलिंग कर सकते हैं। दूसरे शब्दों में, प्रतिक्रियाओं Yको एक दूसरे के साथ सहसंबद्ध किया जा सकता है, लेकिन यह मानते हुए कि स्वतंत्रता डेटासेट को सही ढंग से प्रदर्शित नहीं करती है।

— hlin117

@HuBBothwell खेद है अगर यह एक डम सवाल है, लेकिन यह क्यों फर्क पड़ता है अगर कच्चे फीचर चर x_i स्वतंत्र हैं या नहीं? भविष्यवक्ता (= मॉडल) को कैसे प्रभावित करता है?

— चार्ली पार्कर

Answer 1

sklearn.linear_model.LinearRegression करूंगा:

from sklearn import linear_model
clf = linear_model.LinearRegression()
clf.fit([[getattr(t, 'x%d' % i) for i in range(1, 8)] for t in texts],
        [t.y for t in texts])

फिर clf.coef_प्रतिगमन गुणांक होगा।

sklearn.linear_model प्रतिगमन पर विभिन्न प्रकार के नियमितीकरण करने के लिए समान इंटरफेस भी है।

Comments

यह कुछ इनपुट के साथ एक त्रुटि देता है । कोई अन्य समाधान उपलब्ध है?

— Zach

@Dougal sklearn.linear_model.LinearRegression का उपयोग भारित बहुभिन्नरूपी प्रतिगमन के लिए भी किया जा सकता है ?

— user961627

एक निरंतर शब्द फिट करने के लिए: clf = linear_model.LinearRegression (fit_intercept = True)

— इमरान

अनुवर्ती, क्या आप जानते हैं कि sklearn.linear_model.inearRegression का उपयोग करके आत्मविश्वास स्तर कैसे प्राप्त करें? धन्यवाद।

— ह्वेनियन जांग

@HuanianZhang क्या आप विश्वास स्तर से मतलब है? यदि आप दृढ़ संकल्प के गुणांक चाहते हैं, तो scoreविधि इसे करेगी; sklearn.metricsकुछ अन्य मॉडल मूल्यांकन मानदंड हैं। यदि आप अकवाल के उत्तर की तरह सामान चाहते हैं, तो Datamodels में कुछ और आर-जैसे डायग्नोस्टिक्स हैं।

— डगल

Answer 2

यहाँ थोड़ा सा काम है जो मैंने बनाया है। मैंने इसे आर के साथ जांचा और यह सही है।

import numpy as np
import statsmodels.api as sm

y = [1,2,3,4,3,4,5,4,5,5,4,5,4,5,4,5,6,5,4,5,4,3,4]

x = [
     [4,2,3,4,5,4,5,6,7,4,8,9,8,8,6,6,5,5,5,5,5,5,5],
     [4,1,2,3,4,5,6,7,5,8,7,8,7,8,7,8,7,7,7,7,7,6,5],
     [4,1,2,5,6,7,8,9,7,8,7,8,7,7,7,7,7,7,6,6,4,4,4]
     ]

def reg_m(y, x):
    ones = np.ones(len(x[0]))
    X = sm.add_constant(np.column_stack((x[0], ones)))
    for ele in x[1:]:
        X = sm.add_constant(np.column_stack((ele, X)))
    results = sm.OLS(y, X).fit()
    return results

परिणाम:

print reg_m(y, x).summary()

आउटपुट:

                            OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       0.535
Model:                            OLS   Adj. R-squared:                  0.461
Method:                 Least Squares   F-statistic:                     7.281
Date:                Tue, 19 Feb 2013   Prob (F-statistic):            0.00191
Time:                        21:51:28   Log-Likelihood:                -26.025
No. Observations:                  23   AIC:                             60.05
Df Residuals:                      19   BIC:                             64.59
Df Model:                           3                                         
==============================================================================
                 coef    std err          t      P>|t|      [95.0% Conf. Int.]
------------------------------------------------------------------------------
x1             0.2424      0.139      1.739      0.098        -0.049     0.534
x2             0.2360      0.149      1.587      0.129        -0.075     0.547
x3            -0.0618      0.145     -0.427      0.674        -0.365     0.241
const          1.5704      0.633      2.481      0.023         0.245     2.895

==============================================================================
Omnibus:                        6.904   Durbin-Watson:                   1.905
Prob(Omnibus):                  0.032   Jarque-Bera (JB):                4.708
Skew:                          -0.849   Prob(JB):                       0.0950
Kurtosis:                       4.426   Cond. No.                         38.6

pandas इस उत्तर में दिए गए अनुसार ओएलएस चलाने का एक सुविधाजनक तरीका प्रदान करता है:

पंडों डेटा फ़्रेम के साथ एक ओएलएस प्रतिगमन चलाएँ

Comments

reg_mसमारोह को अनावश्यक रूप से जटिल है। x = np.array(x).T, x = sm.add_constant(x)और results = sm.OLS(endog=y, exog=x).fit()पर्याप्त है।

— cd98

यह एक अच्छा उपकरण है। केवल एक प्रश्न पूछें: इस मामले में, टी मान 95.5% विश्वास अंतराल के बाहर है, इसलिए इसका मतलब है कि यह फिटिंग बिल्कुल भी सही नहीं है, या आप इसे कैसे समझाते हैं?

— हुआनियन जांग

बस ध्यान दिया गया है कि आपकी मूल भविष्यवाणी सूची में आपके X1, x2, x3 उल्टे क्रम में हैं, अर्थात, x = [x3, x2, X1]?

— सोफिअद्व

@sophiadw आप x = x[::-1]सही क्रम में प्राप्त करने के लिए फ़ंक्शन परिभाषा के भीतर जोड़ सकते हैं

— Ashrith

@HuanianZhang "टी वैल्यू" है कि कितने मानक विचलन गुणांक शून्य से दूर है, जबकि 95% सीआई लगभग coef +- 2 * std err(वास्तव में छात्र-टी वितरण अवशिष्ट में स्वतंत्रता की डिग्री के द्वारा मानकीकृत है )। यानी बड़ा निरपेक्ष टी मान शून्य से आगे CI का मतलब है, लेकिन वे सीधे तुलना नहीं की जानी चाहिए। स्पष्टीकरण थोड़ा देर से है, लेकिन आशा है कि यह किसी के लिए उपयोगी है

— सैम मेसन

Answer 3

बस स्पष्ट करने के लिए, आपने जो उदाहरण दिया है वह कई रैखिक प्रतिगमन है, न कि बहुभिन्नरूपी रैखिक प्रतिगमन देखें। अंतर :

एकल स्केलर भविष्यवक्ता चर x और एकल स्केलर प्रतिक्रिया चर y का सबसे सरल मामला सरल रेखीय प्रतिगमन के रूप में जाना जाता है। एकाधिक और / या वेक्टर-मूल्यवान भविष्यवक्ता चर (राजधानी एक्स के साथ चिह्नित) के विस्तार को कई रेखीय प्रतिगमन के रूप में जाना जाता है, जिसे बहुक्रियाशील रैखिक प्रतिगमन के रूप में भी जाना जाता है। लगभग सभी वास्तविक-विश्व प्रतिगमन मॉडल में कई भविष्यवक्ता शामिल होते हैं, और रैखिक प्रतिगमन के बुनियादी विवरण अक्सर कई प्रतिगमन मॉडल के संदर्भ में चिह्नित होते हैं। हालाँकि, ध्यान दें कि इन मामलों में प्रतिक्रिया चर y अभी भी एक अदिश राशि है। एक अन्य शब्द बहुभिन्नरूपी रैखिक प्रतिगमन उन मामलों को संदर्भित करता है जहां y एक वेक्टर है, अर्थात, सामान्य रैखिक प्रतिगमन के समान।

संक्षेप में:

• एकाधिक रैखिक प्रतिगमन: प्रतिक्रिया y एक अदिश राशि है।
• बहुभिन्नरूपी रैखिक प्रतिगमन: प्रतिक्रिया y एक वेक्टर है।

(एक और स्रोत ।)

Comments

यह उपयोगी जानकारी हो सकती है, लेकिन मैं यह नहीं देखता कि यह सवाल का जवाब कैसे देती है।

— अकवाल

@Akavall सही शब्दावली का उपयोग कर उत्तर खोजने के लिए पहला कदम है।

— बजे फ्रेंक डर्नोनकोर्ट

@FranckDernoncourt है, लेकिन ओपी के Y मूल्य एक वेक्टर है?

— हमेशा की तरह १६:५१

@FranckDernoncourt: "सही शब्दावली का उपयोग करना उत्तर खोजने के लिए पहला कदम है" । महान, इसलिए हम दोनों सहमत हो सकते हैं: यह, और अपने आप में, वास्तव में एक उत्तर नहीं है। उपयोगकर्ताओं को अन्य संसाधनों को देखने के लिए सहारा के बिना सीधे उत्तर से अपनी समस्या को हल करने में सक्षम होना चाहिए ।

— मैक

Answer 4

आप numpy.linalg.lstsq का उपयोग कर सकते हैं :

import numpy as np
y = np.array([-6,-5,-10,-5,-8,-3,-6,-8,-8])
X = np.array([[-4.95,-4.55,-10.96,-1.08,-6.52,-0.81,-7.01,-4.46,-11.54],[-5.87,-4.52,-11.64,-3.36,-7.45,-2.36,-7.33,-7.65,-10.03],[-0.76,-0.71,-0.98,0.75,-0.86,-0.50,-0.33,-0.94,-1.03],[14.73,13.74,15.49,24.72,16.59,22.44,13.93,11.40,18.18],[4.02,4.47,4.18,4.96,4.29,4.81,4.32,4.43,4.28],[0.20,0.16,0.19,0.16,0.10,0.15,0.21,0.16,0.21],[0.45,0.50,0.53,0.60,0.48,0.53,0.50,0.49,0.55]])
X = X.T # transpose so input vectors are along the rows
X = np.c_[X, np.ones(X.shape[0])] # add bias term
beta_hat = np.linalg.lstsq(X,y)[0]
print beta_hat

परिणाम:

[ -0.49104607   0.83271938   0.0860167    0.1326091    6.85681762  22.98163883 -41.08437805 -19.08085066]

आप इसके साथ अनुमानित आउटपुट देख सकते हैं:

print np.dot(X,beta_hat)

परिणाम:

[ -5.97751163,  -5.06465759, -10.16873217,  -4.96959788,  -7.96356915,  -3.06176313,  -6.01818435,  -7.90878145,  -7.86720264]

Comments

क्या मुझे पता है कि प्रिंट np.dot (X, beta_hat) ... और mod_wls = sm.WLS (y, X, weights = weights) Res = mod_wls.fit () predsY = res .predict () के बीच क्या अंतर है Y परिणाम

— dd90p

Answer 5

का उपयोग करें scipy.optimize.curve_fit। और न केवल रैखिक फिट के लिए।

from scipy.optimize import curve_fit
import scipy

def fn(x, a, b, c):
    return a + b*x[0] + c*x[1]

# y(x0,x1) data:
#    x0=0 1 2
# ___________
# x1=0 |0 1 2
# x1=1 |1 2 3
# x1=2 |2 3 4

x = scipy.array([[0,1,2,0,1,2,0,1,2,],[0,0,0,1,1,1,2,2,2]])
y = scipy.array([0,1,2,1,2,3,2,3,4])
popt, pcov = curve_fit(fn, x, y)
print popt

Answer 6

एक बार जब आप अपने डेटा को पांडा डेटाफ़्रेम ( df) में बदल देते हैं,

import statsmodels.formula.api as smf
lm = smf.ols(formula='y ~ x1 + x2 + x3 + x4 + x5 + x6 + x7', data=df).fit()
print(lm.params)

अवरोधन शब्द डिफ़ॉल्ट रूप से शामिल है।

अधिक उदाहरणों के लिए इस नोटबुक को देखें ।

Comments

यह नोटबुक कमाल की है। यह दिखाता है कि कोड की सिर्फ 3 पंक्तियों के साथ वाई पर कई स्वतंत्र चर (X1, x2, x3 ...) को कैसे प्राप्त करें और सीखें।

— jxn

नोटबुक के लिए @canary_in_the_data_mine धन्यवाद। मैं रैखिक प्रतिगमन की साजिश कैसे कर सकता हूं जिसमें कई विशेषताएं हैं? मुझे नोटबुक में नहीं मिला। किसी भी संकेत बहुत सराहना की जाएगी। -

— जय प्रकाश

क्या यह अवरोधन जोड़ता है क्योंकि हमें olf () के पैरामीटर के रूप में smf.add_intercept () पास करके अवरोधन जोड़ना है

— 16:18 पर bluedroid

Answer 7

मुझे लगता है कि इस काम को पूरा करने का यह सबसे आसान तरीका हो सकता है:

from random import random
from pandas import DataFrame
from statsmodels.api import OLS
lr = lambda : [random() for i in range(100)]
x = DataFrame({'x1': lr(), 'x2':lr(), 'x3':lr()})
x['b'] = 1
y = x.x1 + x.x2 * 2 + x.x3 * 3 + 4

print x.head()

         x1        x2        x3  b
0  0.433681  0.946723  0.103422  1
1  0.400423  0.527179  0.131674  1
2  0.992441  0.900678  0.360140  1
3  0.413757  0.099319  0.825181  1
4  0.796491  0.862593  0.193554  1

print y.head()

0    6.637392
1    5.849802
2    7.874218
3    7.087938
4    7.102337
dtype: float64

model = OLS(y, x)
result = model.fit()
print result.summary()

                            OLS Regression Results                            
==============================================================================
Dep. Variable:                      y   R-squared:                       1.000
Model:                            OLS   Adj. R-squared:                  1.000
Method:                 Least Squares   F-statistic:                 5.859e+30
Date:                Wed, 09 Dec 2015   Prob (F-statistic):               0.00
Time:                        15:17:32   Log-Likelihood:                 3224.9
No. Observations:                 100   AIC:                            -6442.
Df Residuals:                      96   BIC:                            -6431.
Df Model:                           3                                         
Covariance Type:            nonrobust                                         
==============================================================================
                 coef    std err          t      P>|t|      [95.0% Conf. Int.]
------------------------------------------------------------------------------
x1             1.0000   8.98e-16   1.11e+15      0.000         1.000     1.000
x2             2.0000   8.28e-16   2.41e+15      0.000         2.000     2.000
x3             3.0000   8.34e-16    3.6e+15      0.000         3.000     3.000
b              4.0000   8.51e-16    4.7e+15      0.000         4.000     4.000
==============================================================================
Omnibus:                        7.675   Durbin-Watson:                   1.614
Prob(Omnibus):                  0.022   Jarque-Bera (JB):                3.118
Skew:                           0.045   Prob(JB):                        0.210
Kurtosis:                       2.140   Cond. No.                         6.89
==============================================================================

Answer 8

एकाधिक रैखिक प्रतिगमन को स्केलेर लाइब्रेरी के रूप में ऊपर संदर्भित के रूप में उपयोग किया जा सकता है। मैं पाइथन 3.6 के एनाकोंडा इंस्टॉल का उपयोग कर रहा हूं।

अपना मॉडल इस प्रकार बनाएं:

from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X, y)

# display coefficients
print(regressor.coef_)

Answer 9

आप numpy.linalg.lstsq का उपयोग कर सकते हैं

Comments

एक बहुभिन्नरूपी प्रतिगमन के गुणांक प्राप्त करने के लिए आप इसका उपयोग कैसे कर सकते हैं? मैं केवल यह देखता हूं कि एक साधारण प्रतिगमन कैसे किया जाए ... और गुणांक प्राप्त करने का तरीका न देखें ..

— Zach

Answer 10

आप नीचे दिए गए फ़ंक्शन का उपयोग कर सकते हैं और इसे डेटाफ़्रेम पास कर सकते हैं:

def linear(x, y=None, show=True):
    """
    @param x: pd.DataFrame
    @param y: pd.DataFrame or pd.Series or None
              if None, then use last column of x as y
    @param show: if show regression summary
    """
    import statsmodels.api as sm

    xy = sm.add_constant(x if y is None else pd.concat([x, y], axis=1))
    res = sm.OLS(xy.ix[:, -1], xy.ix[:, :-1], missing='drop').fit()

    if show: print res.summary()
    return res

Answer 11

Scikit-learn पायथन के लिए एक मशीन लर्निंग लाइब्रेरी है जो आपके लिए यह काम कर सकती है। बस अपनी स्क्रिप्ट में sklearn.linear_model मॉड्यूल आयात करें।

पायथन में स्केलेर का उपयोग करके एकाधिक रैखिक प्रतिगमन के लिए कोड टेम्पलेट खोजें:

import numpy as np
import matplotlib.pyplot as plt #to plot visualizations
import pandas as pd

# Importing the dataset
df = pd.read_csv(<Your-dataset-path>)
# Assigning feature and target variables
X = df.iloc[:,:-1]
y = df.iloc[:,-1]

# Use label encoders, if you have any categorical variable
from sklearn.preprocessing import LabelEncoder
labelencoder = LabelEncoder()
X['<column-name>'] = labelencoder.fit_transform(X['<column-name>'])

from sklearn.preprocessing import OneHotEncoder
onehotencoder = OneHotEncoder(categorical_features = ['<index-value>'])
X = onehotencoder.fit_transform(X).toarray()

# Avoiding the dummy variable trap
X = X[:,1:] # Usually done by the algorithm itself

#Spliting the data into test and train set
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y, random_state = 0, test_size = 0.2)

# Fitting the model
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)

# Predicting the test set results
y_pred = regressor.predict(X_test)

बस। आप इस कोड का उपयोग किसी भी डेटासेट में एकाधिक रैखिक प्रतिगमन को लागू करने के लिए एक टेम्पलेट के रूप में कर सकते हैं। एक उदाहरण के साथ एक बेहतर समझ के लिए, जाएँ: एक उदाहरण के साथ रैखिक प्रतिगमन

Answer 12

यहाँ एक वैकल्पिक और बुनियादी तरीका है:

from patsy import dmatrices
import statsmodels.api as sm

y,x = dmatrices("y_data ~ x_1 + x_2 ", data = my_data)
### y_data is the name of the dependent variable in your data ### 
model_fit = sm.OLS(y,x)
results = model_fit.fit()
print(results.summary())

इसके बजाय sm.OLSआप भी sm.Logitया sm.Probitआदि का उपयोग कर सकते हैं