वैरिएबल्स को ट्रांसफॉर्म करना

Python में statsmodels के साथ Regression परिचय

Maarten Van den Broeck

Content Developer at DataCamp

Perch डेटासेट

perch = fish[fish["species"] == "Perch"]
print(perch.head())

   species  mass_g  length_cm
55   Perch     5.9        7.5
56   Perch    32.0       12.5
57   Perch    40.0       13.8
58   Perch    51.5       15.0
59   Perch    70.0       15.7

यूरोपीय पर्च, _Perca fluviatilis_

यह रेखीय संबंध नहीं है

sns.regplot(x="length_cm",
            y="mass_g",
            data=perch,
            ci=None)

plt.show()

पर्च के वज़न बनाम लंबाई का स्कैटर प्लॉट, ट्रेंड लाइन सहित। जैसे-जैसे लंबाई बढ़ती है, वज़न रेखीय से तेज़ बढ़ता है, इसलिए कर्व ऊपर की ओर मुड़ता है.

Bream बनाम Perch

एक कॉमन ब्रीम. ब्रीम काफी चपटी होती है.

एक यूरोपीय पर्च. पर्च काफ़ी गोल-मटोल होती है.

वज़न बनाम लंबाई का घन प्लॉट करना

perch["length_cm_cubed"] = perch["length_cm"] ** 3

sns.regplot(x="length_cm_cubed",
            y="mass_g",
            data=perch,
            ci=None)
plt.show()

पर्च के वज़न बनाम लंबाई के घन का स्कैटर प्लॉट, ट्रेंड लाइन सहित। इस ट्रांसफॉर्मेशन के बाद, ज़्यादातर पॉइंट्स ट्रेंड लाइन के क़रीब हैं.

वज़न बनाम लंबाई का घन मॉडल करना

perch["length_cm_cubed"] = perch["length_cm"] ** 3

mdl_perch = ols("mass_g ~ length_cm_cubed", data=perch).fit()
mdl_perch.params

Intercept         -0.117478
length_cm_cubed    0.016796
dtype: float64

वज़न बनाम लंबाई के घन की भविष्यवाणी

explanatory_data = pd.DataFrame({"length_cm_cubed": np.arange(10, 41, 5) ** 3,
                                 "length_cm": np.arange(10, 41, 5)})

prediction_data = explanatory_data.assign(
  mass_g=mdl_perch.predict(explanatory_data))
print(prediction_data)

   length_cm_cubed  length_cm       mass_g
0             1000         10    16.678135
1             3375         15    56.567717
2             8000         20   134.247429
3            15625         25   262.313982
4            27000         30   453.364084
5            42875         35   719.994447
6            64000         40  1074.801781

वज़न बनाम लंबाई का घन प्लॉट करना

fig = plt.figure()
sns.regplot(x="length_cm_cubed", y="mass_g",
            data=perch, ci=None)
sns.scatterplot(data=prediction_data,
                x="length_cm_cubed", y="mass_g",
                color="red", marker="s")

पर्च के वज़न बनाम लंबाई के घन का स्कैटर प्लॉट, ट्रेंड लाइन सहित, predict() फंक्शन से निकले पॉइंट्स के साथ एनोटेटेड। पॉइंट्स ट्रेंड लाइन को ठीक-ठीक फ़ॉलो करते हैं.

fig = plt.figure()
sns.regplot(x="length_cm", y="mass_g",
            data=perch, ci=None)
sns.scatterplot(data=prediction_data,
                x="length_cm", y="mass_g",
                color="red", marker="s")

पर्च के वज़न बनाम लंबाई का स्कैटर प्लॉट, ट्रेंड लाइन सहित, predict() फंक्शन से निकले पॉइंट्स के साथ एनोटेटेड। पॉइंट्स ट्रेंड लाइन नहीं, बल्कि डेटा पॉइंट्स के कर्व को फ़ॉलो करते हैं.

Facebook विज्ञापन डेटासेट

विज्ञापन कैसे काम करता है

Facebook को पैसे दें ताकि वह ऐड दिखाए.
लोग ऐड देखते हैं ("impressions").
कुछ लोग इसे देखकर क्लिक करते हैं.

936 रो
हर रो 1 ऐड को दर्शाती है

spent_usd	n_impressions	n_clicks
1.43	7350	1
1.82	17861	2
1.25	4259	1
1.29	4133	1
4.77	15615	3
...	...	...

प्लॉट भरा-भरा है

sns.regplot(x="spent_usd",
            y="n_impressions",
            data=ad_conversion,
            ci=None)

इम्प्रेशन की संख्या बनाम विज्ञापन खर्च का स्कैटर प्लॉट, ट्रेंड लाइन सहित। ज़्यादातर पॉइंट्स प्लॉट के नीचे-बाएँ कोने में सिमटे हैं.

स्क्वेयर रूट बनाम स्क्वेयर रूट

ad_conversion["sqrt_spent_usd"] = np.sqrt(
  ad_conversion["spent_usd"])

ad_conversion["sqrt_n_impressions"] = np.sqrt(
  ad_conversion["n_impressions"])

sns.regplot(x="sqrt_spent_usd",
            y="sqrt_n_impressions",
            data=ad_conversion,
            ci=None)

इम्प्रेशन की संख्या के वर्गमूल बनाम विज्ञापन खर्च के वर्गमूल का स्कैटर प्लॉट, ट्रेंड लाइन सहित। अब पॉइंट्स पूरे प्लॉट में काफ़ी समान रूप से फैले हैं.

मॉडलिंग और भविष्यवाणी

mdl_ad = ols("sqrt_n_impressions ~ sqrt_spent_usd", data=ad_conversion).fit()

explanatory_data = pd.DataFrame({"sqrt_spent_usd": np.sqrt(np.arange(0, 601, 100)),
                                 "spent_usd": np.arange(0, 601, 100)})

prediction_data = explanatory_data.assign(sqrt_n_impressions=mdl_ad.predict(explanatory_data),
                          n_impressions=mdl_ad.predict(explanatory_data) ** 2)
print(prediction_data)

   sqrt_spent_usd  spent_usd  sqrt_n_impressions  n_impressions
0        0.000000          0           15.319713   2.346936e+02
1       10.000000        100          597.736582   3.572890e+05
2       14.142136        200          838.981547   7.038900e+05
3       17.320508        300         1024.095320   1.048771e+06
4       20.000000        400         1180.153450   1.392762e+06
5       22.360680        500         1317.643422   1.736184e+06
6       24.494897        600         1441.943858   2.079202e+06

अभ्यास करते हैं!

Python में statsmodels के साथ Regression परिचय