रैखिक बीजगणित डेटा साइंस में ज़रूरी बुनियादी गणितीय औज़ारों में से एक है। इन अवधारणाओं की कुछ समझ होने से अलग-अलग एल्गोरिद्म को समझने में मदद मिलती है। यह वास्तव में डेटा साइंस/मशीन लर्निंग के मार्ग के लिए एक उत्कृष्ट आधार है।
इस ट्यूटोरियल का उद्देश्य Python/Numpy के साथ कोडिंग करके डेटा साइंस के लिए गणित में प्रवेश करना है। मेरा मानना है कि रैखिक बीजगणित जैसे सैद्धांतिक विषयों पर व्यावहारिक ट्यूटोरियल उपयोगी हो सकते हैं, क्योंकि कोड लिखना और पढ़ना गणितीय अवधारणाओं को सच में समझने का अच्छा तरीका है। और सबसे बढ़कर, यह काफ़ी मज़ेदार भी हो सकता है!
कोई विशेष पूर्वापेक्षा नहीं है, लेकिन यदि आपको मैट्रिक्स क्या है या डॉट प्रोडक्ट कैसे करते हैं, यह स्पष्ट नहीं है, तो Ian Goodfellow की डीप लर्निंग किताब पर मेरी श्रृंखला की शुरुआती पोस्ट (1 से 4) एक अच्छा प्रारंभ हैं।
इस ट्यूटोरियल में, हम मशीन लर्निंग और डीप लर्निंग की एक महत्वपूर्ण अवधारणा से परिचित होंगे: नॉर्म। नॉर्म का व्यापक उपयोग होता है, जैसे किसी मॉडल की गुणवत्ता का आकलन करना। इस ट्यूटोरियल के अंत तक, आपको इस अवधारणा की बेहतर अंतर्दृष्टि मिलेगी और समझ आएगा कि मशीन लर्निंग में यह इतना क़ीमती क्यों है। हम यह भी देखेंगे कि नॉर्म का अवकलज मशीन लर्निंग एल्गोरिद्म को प्रशिक्षित करने में कैसे काम आता है।
बेसिक सेटअप
सबसे पहले, वे लाइब्रेरी सेटअप करेंगे जिनका उपयोग करेंगे:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
संचालित द्वारा
और कुछ LaTeX शॉर्टकट जोड़ेंगे — कमांड bs बोल्ड प्रतीकों के लिए और norm नॉर्म के संकेत के लिए:
$$
\newcommand\bs[1]{\boldsymbol{#1}}
\newcommand\norm[1]{\left\lVert#1\right\rVert}
$$
संचालित द्वारा
अंत में, उन ग्राफ़िक्स का रूप-रंग सेट करें जिन्हें हम बनाएंगे:
# Plot parameters
sns.set()%pylab inline
pylab.rcParams['figure.figsize']=(4,4)
plt.rcParams['xtick.major.size']=0
plt.rcParams['ytick.major.size']=0संचालित द्वारा
Populating the interactive namespace from numpy and matplotlib
संचालित द्वारा
एक व्यावहारिक उदाहरण
एक सरल उदाहरण से शुरू करते हैं। मान लें कि आपके पास गीतों का एक डेटासेट है जिसमें अलग-अलग फीचर्स हैं। अब मान लें कि आप ऐसा मॉडल बनाना चाहते हैं जो शैली, इंस्ट्रुमेंटेशन आदि जैसे फीचर्स के आधार पर किसी गीत की अवधि का अनुमान लगाए। आपने एक मॉडल प्रशिक्षित किया है, और अब आप किसी नए गीत की अवधि का अनुमान लगाने में उसके प्रदर्शन का मूल्यांकन करना चाहते हैं। ऐसा करने का एक तरीका यह है कि कुछ नया डेटा लें और अपने मॉडल से गीतों की अवधि का पूर्वानुमान लगाएँ। चूँकि इन अवलोकनों के लिए प्रत्येक गीत की वास्तविक अवधि आपको पता है, आप हर अवलोकन के लिए वास्तविक और अनुमानित अवधि की तुलना कर सकते हैं। 7 अवलोकनों के लिए आपके पास सेकंड में निम्नलिखित परिणाम हैं:
यदि आप सबसे अच्छा मॉडल ढूँढ़ना चाहते हैं तो क्या करेंगे? एक स्वाभाविक तरीका यह होगा कि इन त्रुटियों के परिमाणों का योग लें। परिमाण इसलिए लेते हैं क्योंकि ऋणात्मक त्रुटि (वास्तविक अवधि अनुमानित अवधि से कम) भी त्रुटि ही है। जिसका कुल त्रुटि योग छोटा होगा, वह मॉडल बेहतर है:
totalErrorModel1 = np.sum(np.abs(errorModel1))
totalErrorModel1
संचालित द्वारा
ऐसा लगता है कि मॉडल 1, मॉडल 2 की तुलना में काफ़ी बेहतर है।
बधाई! आपने अभी प्रत्येक मॉडल के लिए त्रुटि वेक्टर का नॉर्म निकाल लिया है!
अनुभवजन्य समझ
आप नॉर्म को वेक्टर की लंबाई के रूप में सोच सकते हैं। इसका ग्राफ़िकल निरूपण समझने के लिए, पिछले उदाहरण पर फिर से नज़र डालते हैं। त्रुटि वेक्टर बहुआयामी हैं: हर अवलोकन के लिए एक आयाम। पिछले उदाहरण में, 7 अवलोकन थे, यानी 7 आयाम। 7 आयामों को दर्शाना कठिन है, इसलिए फिर से सरल करते हुए सिर्फ़ 2 अवलोकन रखें:
अब हम इन वेक्टरों को इस तरह दर्शा सकते हैं कि ऐरे का पहला तत्व x-निर्देशांक और दूसरा तत्व y-निर्देशांक है। हम एक फ़ंक्शन लिखकर शुरू करेंगे जो वेक्टरों को आसानी से प्लॉट कर दे और उनकी आकृति का अंदाज़ा हो।
Python और Matplotlib से वेक्टर कैसे प्लॉट करें
हम ऐसा फ़ंक्शन चाहते हैं जो वेक्टरों को प्लॉट करने में मदद करे। पहले देखते हैं कि हम इसका उपयोग कैसे करना चाहेंगे। हम वेक्टरों के निर्देशांकों वाली ऐरों की सूची देना चाहते हैं और बदले में उनका प्लॉट पाना चाहते हैं। मान लें कि हम रंगों की एक ऐरे भी दे सकें ताकि प्लॉट पर वेक्टरों में भेद कर सकें। संक्षेप में, हम फ़ंक्शन को इस तरह कॉल करना चाहेंगे:
plotVectors([vector1, vector2],['red','blue'])संचालित द्वारा
चलिए यह फ़ंक्शन लिखते हैं:
defplotVectors(vecs, cols, alpha=1):"""
Plot set of vectors.
Parameters
----------
vecs : array-like
Coordinates of the vectors to plot. Each vector is in an array. For
instance: [[1, 3], [2, 2]] can be used to plot 2 vectors.
cols : array-like
Colors of the vectors. For instance: ['red', 'blue'] will display the
first vector in red and the second in blue.
alpha : float
Opacity of vectors
Returns:
fig : instance of matplotlib.figure.Figure
The figure of the vectors
"""
plt.axvline(x=0, color='#A9A9A9', zorder=0)
plt.axhline(y=0, color='#A9A9A9', zorder=0)for i inrange(len(vecs)):if(isinstance(alpha,list)):
alpha_i = alpha[i]else:
alpha_i = alpha
if(len(vecs[i])==2):
x = np.concatenate([[0,0],vecs[i]])elif(len(vecs[i])==4):
x = vecs[i]
plt.quiver([x[0]],[x[1]],[x[2]],[x[3]],
angles='xy', scale_units='xy', scale=1, color=cols[i],
alpha=alpha_i)संचालित द्वारा
यह इनपुट के रूप में प्लॉट करने वाले वेक्टरों की ऐरे (vecs) और उनके रंग (cols) लेता है। यदि वेक्टर में केवल 2 आयाम दिए हैं, तो यह (0, 0) से शुरू होता है। भीतर ही भीतर, हम वेक्टरों की इस ऐरे पर इटरेट करते हैं और उन्हें प्लॉट करने के लिए plt.quiver() का उपयोग करते हैं।
अब अपने नए फ़ंक्शन का उपयोग करके मॉडल 1 और 2 की त्रुटियों को प्लॉट करते हैं:
plotVectors([errorModel1, errorModel2],[sns.color_palette()[0], sns.color_palette()[1]])
plt.xlim(-1,25)
plt.ylim(-5,10)
plt.show()संचालित द्वारा
नोट: हमने plt.show() को फ़ंक्शन में शामिल नहीं किया ताकि हम यहाँ सीमा जैसी प्लॉट कॉन्फ़िगरेशन जोड़ सकें।
नोट 2: हमने seaborn के रंगों को मैन्युअली sns.color_palette() से लिया है।
तो हमारे पास प्रत्येक मॉडल के लिए एक त्रुटि वेक्टर है। बेहतर मॉडल वही है जो छोटे वेक्टर से मेल खाता है। वेक्टरों की लंबाई निकालने का एक तरीका पाइथागोरस प्रमेय का उपयोग करना है: $\sqrt{x^2+y^2}$। हम दोनों वेक्टरों की लंबाई निकाल सकते हैं:
# वेक्टर errorModel1 की लंबाई
np.sqrt(errorModel1[0]**2+errorModel1[1]**2)संचालित द्वारा
बधाई! आपने त्रुटि वेक्टरों का एक और नॉर्म निकाल लिया। पहले मॉडल के त्रुटि वेक्टर की लंबाई $22.36$ है और दूसरे मॉडल की लंबाई लगभग $16.64$ है। इस मामले में, दूसरा मॉडल बेहतर है, लेकिन ध्यान रखें कि हमने केवल पहले दो मानों का उपयोग किया है।
हमने पहले त्रुटियों का योग निकाला था, लेकिन हम वेक्टर का नॉर्म निकालने के लिए पाइथागोरस प्रमेय भी इस्तेमाल कर सकते हैं। ये दो अलग-अलग नॉर्म हैं, और इससे पता चलता है कि नॉर्म निकालने के कई तरीके हैं।
नॉर्म फ़ंक्शंस: परिभाषाएँ
किसी वेक्टर का नॉर्म कोई भी ऐसा फ़ंक्शन हो सकता है जो वेक्टर को धनात्मक मान पर मैप करे। अलग-अलग फ़ंक्शन इस्तेमाल किए जा सकते हैं, और हम कुछ उदाहरण देखेंगे। इन फ़ंक्शनों को निम्न गुणों से परिभाषित होने पर नॉर्म कहा जा सकता है:
नॉर्म सदैव धनात्मक होता है। यदि आप नॉर्म को लंबाई समझें, तो आसानी से दिखता है कि यह ऋणात्मक नहीं हो सकता।
नॉर्म $0$ तभी होता है जब वेक्टर शून्य वेक्टर हो।
नॉर्म त्रिभुज असमता का पालन करते हैं। नीचे देखें।
$\norm{k\cdot \bs{u}}=\norm{k}\cdot\norm{\bs{u}}$। यहाँ $k$ एक स्केलर है और $\bs{u}$ वेक्टर। किसी वेक्टर के स्केलर गुणन का नॉर्म, उस स्केलर के परिमाण और वेक्टर के नॉर्म के गुणन के बराबर होता है।
इसे आमतौर पर दो वर्टिकल बार के साथ लिखा जाता है: $\norm{\bs{x}}$
त्रिभुज असमता
ऊपर देखा कि किसी फ़ंक्शन के नॉर्म कहलाने की एक शर्त यह है कि वह त्रिभुज असमता का पालन करे। इसका सरल अर्थ है कि कुछ वेक्टरों के योग का नॉर्म, उन वेक्टरों के नॉर्मों के योग से कम या बराबर होता है:
हम आगे अलग-अलग प्रकार के नॉर्म देखेंगे, लेकिन अभी के लिए एक क्लासिक नॉर्म लेंगे: Euclidean नॉर्म ($L^2$)। $L^2$ नॉर्म Numpy के फ़ंक्शन np.linalg.norm() से निकाला जा सकता है (विस्तार के लिए डॉक देखें)।
इस प्रमेय का ग्राफ़िकल निरूपण इसे काफ़ी सीधा कर देता है। हम अपने plotVectors फ़ंक्शन का उपयोग करके वेक्टर $\bs{u}$, $\bs{v}$ और $\bs{u}+\bs{v}$ को प्लॉट करेंगे और पहचान के लिए कुछ टेक्स्ट जोड़ेंगे:
u = np.array([0,0,1,6])
v = np.array([0,0,4,2])
w = u+v
u_bis =[u[2], u[3], v[2], v[3]]
plotVectors([u, u_bis, w],[sns.color_palette()[0],
sns.color_palette()[1],
sns.color_palette()[2]])
plt.xlim(-2,6)
plt.ylim(-2,9)
plt.text(-1,3.5,r'$||\vec{u}||$', color=sns.color_palette()[0], size=20)
plt.text(2.5,7.5,r'$||\vec{v}||$', color=sns.color_palette()[1], size=20)
plt.text(2,2,r'$||\vec{u}+\vec{v}||$', color=sns.color_palette()[2], size=20)
plt.show()
plt.close()संचालित द्वारा
$\bs{u}$ की लंबाई प्लस $\bs{v}$ की लंबाई, वेक्टर $\bs{u}+\bs{b}$ की लंबाई से बड़ी है। ज्यामितीय रूप से, इसका सरल अर्थ है कि दो बिंदुओं के बीच सबसे छोटा रास्ता एक सीधी रेखा है!
P-नॉर्म: सामान्य नियम
हमने वे शर्तें देखीं जिनके पूरा होने पर कोई फ़ंक्शन नॉर्म कहलाता है। इसका मतलब है कि कई फ़ंक्शन नॉर्म के रूप में इस्तेमाल किए जा सकते हैं। आगे हम इन अलग-अलग नॉर्म के फायदे-नुक़सान देखेंगे। हम $p$-नॉर्म उस श्रेणी के फ़ंक्शनों को कहते हैं जो $p$ पर निर्भर करते हैं:
$$ \norm{\bs{x}}_p=(\sum_i|\bs{x}_i|^p)^{1/p} $$
आइए इस समीकरण को चरण-दर-चरण समझें। इसमें तत्वों का योग दिख रहा है, यानी हम इसे $i$ तत्वों पर इटरेशन के रूप में सोच सकते हैं:
$\vert\bs{x}_i\vert$ — $i$वें तत्व का परिमाण निकालें
$\vert\bs{x}_i\vert^p$ — इसका $p$ घात लें
$\sum_i\vert\bs{x}_i\vert^p$ — इन सभी घातांकित परिमाणों का योग करें
$(\sum_i\vert\bs{x}_i\vert^p)^{1/p}$ — परिणाम का $\frac{1}{p}$ घात लें
यह व्यापक रूप से उपयोग होने वाले $p$-नॉर्म के उदाहरणों से साफ़ हो जाएगा।
$L^0$ नॉर्म
यदि $p=0$, तो सूत्र बनता है:
$$ \norm{\bs{x}}_0=(\sum_i|\bs{x}_i|^0)^{1/0} $$
देखें इसका मतलब क्या है। परिमाण के साथ घात $0$ लेने पर, हर गैर-शून्य मान के लिए $1$ और $0$ के लिए $0$ मिलता है।
इसलिए यह नॉर्म वेक्टर में गैर-शून्य तत्वों की गिनती के अनुरूप होता है। यह वास्तव में नॉर्म नहीं माना जाता क्योंकि यदि आप वेक्टर को $\alpha$ से गुणा करें, तो यह संख्या वही रहती है (ऊपर का नियम 4)।
$L^1$ नॉर्म
यदि $p=1$, तो हमें बस परिमाणों का योग मिलता है। यही हमने इस ट्यूटोरियल की शुरुआत में सहज रूप से इस्तेमाल किया था:
$L^2$ नॉर्म (Euclidean नॉर्म)
Euclidean नॉर्म $p=2$ वाला $p$-नॉर्म है। यह संभवतः वर्ग $L^2$ नॉर्म (नीचे देखें) के साथ सबसे अधिक इस्तेमाल होने वाला नॉर्म है।
ध्यान दें कि यहाँ परिमाण की ज़रूरत नहीं रही क्योंकि $x$ का वर्ग लिया गया है। यही हमने ऊपर पाइथागोरस प्रमेय से वेक्टर की लंबाई निकालते समय किया था।
आइए इस नॉर्म का एक और उदाहरण देखें:
उदाहरण 2.
ग्राफ़िक रूप से, Euclidean नॉर्म उस वेक्टर की लंबाई के बराबर है जो आरंभ बिंदु से उस बिंदु तक जाता है जो रैखिक संयोजन से प्राप्त होता है (पाइथागोरस प्रमेय)। हम 2 आयाम में उदाहरण देखेंगे: वेक्टर $\bs{u}$ में दो मान हैं जो $x$-निर्देशांक और $y$-निर्देशांक के अनुरूप हैं। यदि आप इन निर्देशांकों वाले बिंदु को प्लॉट करें और आरंभ से इस बिंदु तक वेक्टर खींचें, तो $L^2$ नॉर्म उस वेक्टर की लंबाई होगी।
वर्ग $L^2$ नॉर्म सुविधाजनक है क्योंकि यह वर्गमूल हटा देता है और अंत में वेक्टर के हर वर्गित मान का सरल योग मिलता है।
वर्ग Euclidean नॉर्म का मशीन लर्निंग में व्यापक उपयोग होता है, आंशिक रूप से इसलिए कि इसे वेक्टर ऑपरेशन $\bs{x}^\text{T}\bs{x}$ से निकाला जा सकता है। अनुकूलन के कारण प्रदर्शन लाभ मिल सकते हैं। अधिक विवरण के लिए यहाँ और यहाँ देखें।
उदाहरण 3.
इस उदाहरण में हम देखेंगे कि वर्ग Euclidean नॉर्म को वेक्टराइज़्ड ऑपरेशनों से निकाला जा सकता है। मान लें हमारे पास वेक्टर $\bs{x}$ है:
$\bs{x}$ और $\bs{x}^\text{T}$ का डॉट प्रोडक्ट (यदि डॉट प्रोडक्ट पर फिर से याद दिलाने की ज़रूरत है तो यहाँ देखें) वास्तव में प्रत्येक तत्व को स्वयं से गुणा करने के अनुरूप है:
यही तो वर्ग Euclidean नॉर्म की परिभाषा है!
Numpy से जाँचें। याद रखें (और ख़ुद आज़माएँ ताकि यक़ीन हो) कि डॉट प्रोडक्ट में वेक्टरों का क्रम मायने रखता है:
सही है! अन्य नॉर्म की तुलना में वेक्टराइज़्ड ऑपरेशन का उपयोग करने की क्षमता एक बड़ा लाभ है।
वर्ग $L^2$ नॉर्म का अवकलज
हमने देखा कि नॉर्म का उपयोग मॉडल की त्रुटियों के वेक्टर को संक्षेप में व्यक्त करके मॉडल की गुणवत्ता आकलन करने में किया जा सकता है।
अब हम एक कदम आगे बढ़ते हैं और जानना चाहते हैं कि अपने मॉडल के पैरामीटर कैसे बदलें ताकि कुल त्रुटि घटे। इसके लिए हम एक कॉस्ट फ़ंक्शन का उपयोग कर सकते हैं जो पैरामीटर मानों के फ़ंक्शन के रूप में मॉडल की त्रुटि को जोड़ता है। इस फ़ंक्शन का निम्नतम मान ढूँढ़ने के लिए ग्रेडिएंट डिसेंट एल्गोरिद्म का उपयोग किया जा सकता है। ग्रेडिएंट डिसेंट प्रत्येक पैरामीटर के सापेक्ष अवकलज (आंशिक अवकलज = ग्रेडिएंट) निकालकर किया जाता है। इसलिए अवकलज को कुशलता से निकाल पाना बेहद महत्वपूर्ण है।
वास्तव में, वर्ग $L^2$ नॉर्म का एक बड़ा लाभ यह है कि इसका आंशिक अवकलज आसानी से निकाला जा सकता है। मान लें हमारे पास निम्न वेक्टर है:
फिर, आंशिक अवकलज निकालते समय, अन्य सभी चर को नियत मानते हैं। उदाहरण के लिए, $u_1$ के सापेक्ष आंशिक अवकलज $u_1^2+a$ का अवकलज होगा ($a$ अन्य सभी चर के अनुरूप नियत मान है)। इस कारण हमारे पास निम्न आंशिक अवकलज मिलते हैं:
वर्ग $L^2$ नॉर्म के ग्रेडिएंट की ख़ूबी यह है कि अवकलज अन्य चरों पर निर्भर नहीं करते। हम देखेंगे कि $L^2$ नॉर्म के साथ ऐसा नहीं है।
$L^2$ नॉर्म का अवकलज
$L^2$ नॉर्म के मामले में, अवकलज अधिक जटिल होता है और वेक्टर के हर तत्व को ध्यान में लेता है। पिछले वेक्टर $\bs{u}$ को उदाहरण के रूप में लें। $L^2$ नॉर्म है:
वर्ग $L^2$ नॉर्म बढ़िया है, लेकिन एक समस्या यह है कि यह 0 और छोटे मानों के बीच भेद करना कठिन बनाता है क्योंकि फ़ंक्शन धीरे-धीरे बढ़ता है।
हम इसे वर्ग $L^2$ नॉर्म और $L^2$ नॉर्म की ग्राफ़िक तुलना से देख सकते हैं। $z$-अक्ष नॉर्म के मान को दर्शाता है और $x$- तथा $y$-अक्ष दो पैरामीटरों को। यही बात 2 से अधिक आयामों में भी सही है, पर उसे दर्शाना कठिन होगा।
$L^2$ नॉर्म:
वर्ग $L^2$ नॉर्म:
तुलना के लिए, यह रहा $L^1$ नॉर्म:
ये प्लॉट इस वेबसाइट की मदद से बनाए गए हैं। यदि इनके आकार को समझने के लिए आपको इन्हें घुमा-फिरा कर देखना है, तो जाकर स्वयं प्लॉट करें।
मैक्स नॉर्म
यह $L^\infty$ नॉर्म है और वेक्टर के सबसे बड़े तत्व के परिमाण के बराबर होता है।
$$ \norm{\bs{x}}_\infty = \max\limits_i|x_i| $$
मैट्रिक्स नॉर्म: Frobenius नॉर्म
यह फ्लैट करने के बाद मैट्रिक्स का $L^2$ नॉर्म लेने के बराबर है।
यह डॉट प्रोडक्ट के समान ही परिणाम है। यहाँ numpy के साथ ऑपरेशन दिए हैं। ध्यान दें कि हम Numpy के deg2rad फ़ंक्शन का उपयोग करते हैं क्योंकि np.cos कोण को रेडियन में लेता है, इसलिए हमें रूपांतरण करना पड़ता है।
# Note: np.cos take the angle in radian
np.cos(np.deg2rad(45))*2*np.sqrt(8)संचालित द्वारा
$L^2$ नॉर्म (या मैट्रिक्स के मामले में Frobenius नॉर्म) और वर्ग $L^2$ नॉर्म मशीन लर्निंग, डीप लर्निंग और सामान्यतः डेटा साइंस में व्यापक रूप से उपयोग होते हैं। उदाहरण के लिए, नॉर्म को कॉस्ट फ़ंक्शन के रूप में इस्तेमाल किया जा सकता है। मान लें कि आप डेटा बिंदुओं के एक सेट पर एक रेखा फिट करना चाहते हैं। बेहतर रेखा ढूँढ़ने का एक तरीका यह है कि यादृच्छिक पैरामीटर से शुरू करें और कॉस्ट फ़ंक्शन को न्यूनतम करते हुए इटरेट करें। कॉस्ट फ़ंक्शन आपके मॉडल की त्रुटि को दर्शाने वाला फ़ंक्शन है, इसलिए आप चाहते हैं कि यह त्रुटि यथासंभव कम हो। यहाँ नॉर्म उपयोगी है क्योंकि यह इस त्रुटि को मापने का तरीका देता है। नॉर्म आपके सभी त्रुटियों वाले वेक्टर को एक सरल स्केलर पर मैप कर देता है, और किसी पैरामीटर सेट के लिए कॉस्ट फ़ंक्शन यही स्केलर है।
हमने देखा कि नॉर्म मूलतः किसी ऐरे को घटाकर एक स्केलर बनाना है। हमने यह भी नोट किया कि इसे निकालने के लिए प्रयुक्त फ़ंक्शन के आधार पर कुछ विविधताएँ होती हैं। कौन-सा नॉर्म इस्तेमाल करना है, यह काफ़ी हद तक समस्या पर निर्भर करता है, क्योंकि एक या दूसरे को लागू करने के अपने फायदे-नुक़सान हैं। उदाहरण के लिए, $L^1$ नॉर्म $L^2$ नॉर्म की तुलना में अधिक मजबूत होता है। यानी $L^2$ नॉर्म बहिर्गामी मानों के प्रति अधिक संवेदनशील है, क्योंकि बड़ी त्रुटियाँ बहुत बड़े वर्गित त्रुटि मान दे देंगी।
यह ट्यूटोरियल Goodfellow आदि की डीप लर्निंग किताब के रैखिक बीजगणित अध्याय पर मेरी श्रृंखला के इस लेख पर आधारित है।
%22%3E%3Cpath%20d%3D%22m-369%200h408v79h-408z%22%20fill%3D%22%237933ff%22%2F%3E%3Cpath%20d%3D%22m-148%200h306v45h-306z%22%20fill%3D%22%23974dff%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E)
%22%2F%3E%3C%2FclipPath%3E%3Cg%20clip-path%3D%22url(%23a)%22%3E%3Cpath%20d%3D%22m76%200h484v36h-484z%22%20fill%3D%22%23974dff%22%2F%3E%3Cpath%20d%3D%22m0%200h384v24h-384z%22%20fill%3D%22%2306bdfc%22%20transform%3D%22matrix(1%200%200%20-1%200%2060)%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E)
परिचय
रैखिक बीजगणित डेटा साइंस में ज़रूरी बुनियादी गणितीय औज़ारों में से एक है। इन अवधारणाओं की कुछ समझ होने से अलग-अलग एल्गोरिद्म को समझने में मदद मिलती है। यह वास्तव में डेटा साइंस/मशीन लर्निंग के मार्ग के लिए एक उत्कृष्ट आधार है।
इस ट्यूटोरियल का उद्देश्य Python/Numpy के साथ कोडिंग करके डेटा साइंस के लिए गणित में प्रवेश करना है। मेरा मानना है कि रैखिक बीजगणित जैसे सैद्धांतिक विषयों पर व्यावहारिक ट्यूटोरियल उपयोगी हो सकते हैं, क्योंकि कोड लिखना और पढ़ना गणितीय अवधारणाओं को सच में समझने का अच्छा तरीका है। और सबसे बढ़कर, यह काफ़ी मज़ेदार भी हो सकता है!
कोई विशेष पूर्वापेक्षा नहीं है, लेकिन यदि आपको मैट्रिक्स क्या है या डॉट प्रोडक्ट कैसे करते हैं, यह स्पष्ट नहीं है, तो Ian Goodfellow की डीप लर्निंग किताब पर मेरी श्रृंखला की शुरुआती पोस्ट (1 से 4) एक अच्छा प्रारंभ हैं।
इस ट्यूटोरियल में, हम मशीन लर्निंग और डीप लर्निंग की एक महत्वपूर्ण अवधारणा से परिचित होंगे: नॉर्म। नॉर्म का व्यापक उपयोग होता है, जैसे किसी मॉडल की गुणवत्ता का आकलन करना। इस ट्यूटोरियल के अंत तक, आपको इस अवधारणा की बेहतर अंतर्दृष्टि मिलेगी और समझ आएगा कि मशीन लर्निंग में यह इतना क़ीमती क्यों है। हम यह भी देखेंगे कि नॉर्म का अवकलज मशीन लर्निंग एल्गोरिद्म को प्रशिक्षित करने में कैसे काम आता है।
बेसिक सेटअप
सबसे पहले, वे लाइब्रेरी सेटअप करेंगे जिनका उपयोग करेंगे:
और कुछ LaTeX शॉर्टकट जोड़ेंगे — कमांड
bsबोल्ड प्रतीकों के लिए औरnormनॉर्म के संकेत के लिए:$$ \newcommand\bs[1]{\boldsymbol{#1}} \newcommand\norm[1]{\left\lVert#1\right\rVert} $$
अंत में, उन ग्राफ़िक्स का रूप-रंग सेट करें जिन्हें हम बनाएंगे:
एक व्यावहारिक उदाहरण
एक सरल उदाहरण से शुरू करते हैं। मान लें कि आपके पास गीतों का एक डेटासेट है जिसमें अलग-अलग फीचर्स हैं। अब मान लें कि आप ऐसा मॉडल बनाना चाहते हैं जो शैली, इंस्ट्रुमेंटेशन आदि जैसे फीचर्स के आधार पर किसी गीत की अवधि का अनुमान लगाए। आपने एक मॉडल प्रशिक्षित किया है, और अब आप किसी नए गीत की अवधि का अनुमान लगाने में उसके प्रदर्शन का मूल्यांकन करना चाहते हैं। ऐसा करने का एक तरीका यह है कि कुछ नया डेटा लें और अपने मॉडल से गीतों की अवधि का पूर्वानुमान लगाएँ। चूँकि इन अवलोकनों के लिए प्रत्येक गीत की वास्तविक अवधि आपको पता है, आप हर अवलोकन के लिए वास्तविक और अनुमानित अवधि की तुलना कर सकते हैं। 7 अवलोकनों के लिए आपके पास सेकंड में निम्नलिखित परिणाम हैं:
इन अंतरों को मॉडल की त्रुटि माना जा सकता है। एक परिपूर्ण मॉडल में केवल 0 होंगे, जबकि बहुत खराब मॉडल में बहुत बड़े धनात्मक या ऋणात्मक मान होंगे।
अब कल्पना करें कि आपने एक और मॉडल आज़माया और अनुमानित और वास्तविक गीत अवधि के बीच निम्नलिखित अंतर मिले:
यदि आप सबसे अच्छा मॉडल ढूँढ़ना चाहते हैं तो क्या करेंगे? एक स्वाभाविक तरीका यह होगा कि इन त्रुटियों के परिमाणों का योग लें। परिमाण इसलिए लेते हैं क्योंकि ऋणात्मक त्रुटि (वास्तविक अवधि अनुमानित अवधि से कम) भी त्रुटि ही है। जिसका कुल त्रुटि योग छोटा होगा, वह मॉडल बेहतर है:
ऐसा लगता है कि मॉडल 1, मॉडल 2 की तुलना में काफ़ी बेहतर है।
बधाई! आपने अभी प्रत्येक मॉडल के लिए त्रुटि वेक्टर का नॉर्म निकाल लिया है!
अनुभवजन्य समझ
आप नॉर्म को वेक्टर की लंबाई के रूप में सोच सकते हैं। इसका ग्राफ़िकल निरूपण समझने के लिए, पिछले उदाहरण पर फिर से नज़र डालते हैं। त्रुटि वेक्टर बहुआयामी हैं: हर अवलोकन के लिए एक आयाम। पिछले उदाहरण में, 7 अवलोकन थे, यानी 7 आयाम। 7 आयामों को दर्शाना कठिन है, इसलिए फिर से सरल करते हुए सिर्फ़ 2 अवलोकन रखें:
अब हम इन वेक्टरों को इस तरह दर्शा सकते हैं कि ऐरे का पहला तत्व x-निर्देशांक और दूसरा तत्व y-निर्देशांक है। हम एक फ़ंक्शन लिखकर शुरू करेंगे जो वेक्टरों को आसानी से प्लॉट कर दे और उनकी आकृति का अंदाज़ा हो।
Python और Matplotlib से वेक्टर कैसे प्लॉट करें
हम ऐसा फ़ंक्शन चाहते हैं जो वेक्टरों को प्लॉट करने में मदद करे। पहले देखते हैं कि हम इसका उपयोग कैसे करना चाहेंगे। हम वेक्टरों के निर्देशांकों वाली ऐरों की सूची देना चाहते हैं और बदले में उनका प्लॉट पाना चाहते हैं। मान लें कि हम रंगों की एक ऐरे भी दे सकें ताकि प्लॉट पर वेक्टरों में भेद कर सकें। संक्षेप में, हम फ़ंक्शन को इस तरह कॉल करना चाहेंगे:
चलिए यह फ़ंक्शन लिखते हैं:
यह इनपुट के रूप में प्लॉट करने वाले वेक्टरों की ऐरे (
vecs) और उनके रंग (cols) लेता है। यदि वेक्टर में केवल 2 आयाम दिए हैं, तो यह (0, 0) से शुरू होता है। भीतर ही भीतर, हम वेक्टरों की इस ऐरे पर इटरेट करते हैं और उन्हें प्लॉट करने के लिएplt.quiver()का उपयोग करते हैं।अब अपने नए फ़ंक्शन का उपयोग करके मॉडल 1 और 2 की त्रुटियों को प्लॉट करते हैं:
नोट: हमने
plt.show()को फ़ंक्शन में शामिल नहीं किया ताकि हम यहाँ सीमा जैसी प्लॉट कॉन्फ़िगरेशन जोड़ सकें।नोट 2: हमने seaborn के रंगों को मैन्युअली sns.color_palette() से लिया है।
तो हमारे पास प्रत्येक मॉडल के लिए एक त्रुटि वेक्टर है। बेहतर मॉडल वही है जो छोटे वेक्टर से मेल खाता है। वेक्टरों की लंबाई निकालने का एक तरीका पाइथागोरस प्रमेय का उपयोग करना है: $\sqrt{x^2+y^2}$। हम दोनों वेक्टरों की लंबाई निकाल सकते हैं:
बधाई! आपने त्रुटि वेक्टरों का एक और नॉर्म निकाल लिया। पहले मॉडल के त्रुटि वेक्टर की लंबाई $22.36$ है और दूसरे मॉडल की लंबाई लगभग $16.64$ है। इस मामले में, दूसरा मॉडल बेहतर है, लेकिन ध्यान रखें कि हमने केवल पहले दो मानों का उपयोग किया है।
हमने पहले त्रुटियों का योग निकाला था, लेकिन हम वेक्टर का नॉर्म निकालने के लिए पाइथागोरस प्रमेय भी इस्तेमाल कर सकते हैं। ये दो अलग-अलग नॉर्म हैं, और इससे पता चलता है कि नॉर्म निकालने के कई तरीके हैं।
नॉर्म फ़ंक्शंस: परिभाषाएँ
किसी वेक्टर का नॉर्म कोई भी ऐसा फ़ंक्शन हो सकता है जो वेक्टर को धनात्मक मान पर मैप करे। अलग-अलग फ़ंक्शन इस्तेमाल किए जा सकते हैं, और हम कुछ उदाहरण देखेंगे। इन फ़ंक्शनों को निम्न गुणों से परिभाषित होने पर नॉर्म कहा जा सकता है:
नॉर्म सदैव धनात्मक होता है। यदि आप नॉर्म को लंबाई समझें, तो आसानी से दिखता है कि यह ऋणात्मक नहीं हो सकता।
नॉर्म $0$ तभी होता है जब वेक्टर शून्य वेक्टर हो।
नॉर्म त्रिभुज असमता का पालन करते हैं। नीचे देखें।
$\norm{k\cdot \bs{u}}=\norm{k}\cdot\norm{\bs{u}}$। यहाँ $k$ एक स्केलर है और $\bs{u}$ वेक्टर। किसी वेक्टर के स्केलर गुणन का नॉर्म, उस स्केलर के परिमाण और वेक्टर के नॉर्म के गुणन के बराबर होता है।
इसे आमतौर पर दो वर्टिकल बार के साथ लिखा जाता है: $\norm{\bs{x}}$
त्रिभुज असमता
ऊपर देखा कि किसी फ़ंक्शन के नॉर्म कहलाने की एक शर्त यह है कि वह त्रिभुज असमता का पालन करे। इसका सरल अर्थ है कि कुछ वेक्टरों के योग का नॉर्म, उन वेक्टरों के नॉर्मों के योग से कम या बराबर होता है:
उदाहरण 1.
इसे दिखाने के लिए, हम दो वेक्टर लेंगे, प्रत्येक में दो तत्व (फिर से, x और y निर्देशांक के रूप में दर्शाने के काम के)। हमारे वेक्टर हैं:
और
तुलना करें:
और:
हम आगे अलग-अलग प्रकार के नॉर्म देखेंगे, लेकिन अभी के लिए एक क्लासिक नॉर्म लेंगे: Euclidean नॉर्म ($L^2$)। $L^2$ नॉर्म Numpy के फ़ंक्शन
np.linalg.norm()से निकाला जा सकता है (विस्तार के लिए डॉक देखें)।हम आगे विस्तार से देखेंगे कि $L^1$ या $L^2$ नॉर्म क्या हैं।
और
हम देखते हैं कि त्रिभुज असमता का पालन होता है क्योंकि:
ग्राफ़िकल व्याख्या
इस प्रमेय का ग्राफ़िकल निरूपण इसे काफ़ी सीधा कर देता है। हम अपने
plotVectorsफ़ंक्शन का उपयोग करके वेक्टर $\bs{u}$, $\bs{v}$ और $\bs{u}+\bs{v}$ को प्लॉट करेंगे और पहचान के लिए कुछ टेक्स्ट जोड़ेंगे:$\bs{u}$ की लंबाई प्लस $\bs{v}$ की लंबाई, वेक्टर $\bs{u}+\bs{b}$ की लंबाई से बड़ी है। ज्यामितीय रूप से, इसका सरल अर्थ है कि दो बिंदुओं के बीच सबसे छोटा रास्ता एक सीधी रेखा है!
P-नॉर्म: सामान्य नियम
हमने वे शर्तें देखीं जिनके पूरा होने पर कोई फ़ंक्शन नॉर्म कहलाता है। इसका मतलब है कि कई फ़ंक्शन नॉर्म के रूप में इस्तेमाल किए जा सकते हैं। आगे हम इन अलग-अलग नॉर्म के फायदे-नुक़सान देखेंगे। हम $p$-नॉर्म उस श्रेणी के फ़ंक्शनों को कहते हैं जो $p$ पर निर्भर करते हैं:
आइए इस समीकरण को चरण-दर-चरण समझें। इसमें तत्वों का योग दिख रहा है, यानी हम इसे $i$ तत्वों पर इटरेशन के रूप में सोच सकते हैं:
यह व्यापक रूप से उपयोग होने वाले $p$-नॉर्म के उदाहरणों से साफ़ हो जाएगा।
$L^0$ नॉर्म
यदि $p=0$, तो सूत्र बनता है:
देखें इसका मतलब क्या है। परिमाण के साथ घात $0$ लेने पर, हर गैर-शून्य मान के लिए $1$ और $0$ के लिए $0$ मिलता है।
इसलिए यह नॉर्म वेक्टर में गैर-शून्य तत्वों की गिनती के अनुरूप होता है। यह वास्तव में नॉर्म नहीं माना जाता क्योंकि यदि आप वेक्टर को $\alpha$ से गुणा करें, तो यह संख्या वही रहती है (ऊपर का नियम 4)।
$L^1$ नॉर्म
यदि $p=1$, तो हमें बस परिमाणों का योग मिलता है। यही हमने इस ट्यूटोरियल की शुरुआत में सहज रूप से इस्तेमाल किया था:
$L^2$ नॉर्म (Euclidean नॉर्म)
Euclidean नॉर्म $p=2$ वाला $p$-नॉर्म है। यह संभवतः वर्ग $L^2$ नॉर्म (नीचे देखें) के साथ सबसे अधिक इस्तेमाल होने वाला नॉर्म है।
ध्यान दें कि यहाँ परिमाण की ज़रूरत नहीं रही क्योंकि $x$ का वर्ग लिया गया है। यही हमने ऊपर पाइथागोरस प्रमेय से वेक्टर की लंबाई निकालते समय किया था।
आइए इस नॉर्म का एक और उदाहरण देखें:
उदाहरण 2.
ग्राफ़िक रूप से, Euclidean नॉर्म उस वेक्टर की लंबाई के बराबर है जो आरंभ बिंदु से उस बिंदु तक जाता है जो रैखिक संयोजन से प्राप्त होता है (पाइथागोरस प्रमेय)। हम 2 आयाम में उदाहरण देखेंगे: वेक्टर $\bs{u}$ में दो मान हैं जो $x$-निर्देशांक और $y$-निर्देशांक के अनुरूप हैं। यदि आप इन निर्देशांकों वाले बिंदु को प्लॉट करें और आरंभ से इस बिंदु तक वेक्टर खींचें, तो $L^2$ नॉर्म उस वेक्टर की लंबाई होगी।
उदाहरण के लिए:
पहले, सूत्र से नॉर्म निकालते हैं:
तो $L^2$ नॉर्म $5$ है।
वैसे, याद रखें कि $L^2$ नॉर्म Numpy के
linalg.norm()फ़ंक्शन से निकाला जा सकता है:वेक्टर का ग्राफ़िकल निरूपण यहाँ है:
हम देखते हैं कि वेक्टर आरंभ बिंदु (0, 0) से (3, 4) तक जाता है और इसकी लंबाई 5 है।
इस मामले में, वेक्टर 2-आयामी स्पेस में है, पर यह अधिक आयामों के लिए भी सही है।
वर्ग Euclidean नॉर्म (वर्ग $L^2$ नॉर्म)
वर्ग $L^2$ नॉर्म सुविधाजनक है क्योंकि यह वर्गमूल हटा देता है और अंत में वेक्टर के हर वर्गित मान का सरल योग मिलता है।
वर्ग Euclidean नॉर्म का मशीन लर्निंग में व्यापक उपयोग होता है, आंशिक रूप से इसलिए कि इसे वेक्टर ऑपरेशन $\bs{x}^\text{T}\bs{x}$ से निकाला जा सकता है। अनुकूलन के कारण प्रदर्शन लाभ मिल सकते हैं। अधिक विवरण के लिए यहाँ और यहाँ देखें।
उदाहरण 3.
इस उदाहरण में हम देखेंगे कि वर्ग Euclidean नॉर्म को वेक्टराइज़्ड ऑपरेशनों से निकाला जा सकता है। मान लें हमारे पास वेक्टर $\bs{x}$ है:
हमेशा की तरह, प्रक्रिया जाँचने के लिए कोड का उपयोग करेंगे। पहले, Numpy वेक्टर $\bs{x}$ बनाते हैं:
अब इस वेक्टर का ट्रांसपोज़ लेते हैं। इससे शुरुआती कॉलम वेक्टर रो वेक्टर में बदल जाएगा:
Numpy ऑब्जेक्ट के
Tमेथड से $\bs{x}$ का ट्रांसपोज़ निकाल सकते हैं:$\bs{x}$ और $\bs{x}^\text{T}$ का डॉट प्रोडक्ट (यदि डॉट प्रोडक्ट पर फिर से याद दिलाने की ज़रूरत है तो यहाँ देखें) वास्तव में प्रत्येक तत्व को स्वयं से गुणा करने के अनुरूप है:
यही तो वर्ग Euclidean नॉर्म की परिभाषा है!
Numpy से जाँचें। याद रखें (और ख़ुद आज़माएँ ताकि यक़ीन हो) कि डॉट प्रोडक्ट में वेक्टरों का क्रम मायने रखता है:
यह हमारा वर्ग Euclidean नॉर्म होना चाहिए! $L^2$ नॉर्म से निकालकर उसका वर्ग लेकर मिलान करते हैं:
सही है! अन्य नॉर्म की तुलना में वेक्टराइज़्ड ऑपरेशन का उपयोग करने की क्षमता एक बड़ा लाभ है।
वर्ग $L^2$ नॉर्म का अवकलज
हमने देखा कि नॉर्म का उपयोग मॉडल की त्रुटियों के वेक्टर को संक्षेप में व्यक्त करके मॉडल की गुणवत्ता आकलन करने में किया जा सकता है।
अब हम एक कदम आगे बढ़ते हैं और जानना चाहते हैं कि अपने मॉडल के पैरामीटर कैसे बदलें ताकि कुल त्रुटि घटे। इसके लिए हम एक कॉस्ट फ़ंक्शन का उपयोग कर सकते हैं जो पैरामीटर मानों के फ़ंक्शन के रूप में मॉडल की त्रुटि को जोड़ता है। इस फ़ंक्शन का निम्नतम मान ढूँढ़ने के लिए ग्रेडिएंट डिसेंट एल्गोरिद्म का उपयोग किया जा सकता है। ग्रेडिएंट डिसेंट प्रत्येक पैरामीटर के सापेक्ष अवकलज (आंशिक अवकलज = ग्रेडिएंट) निकालकर किया जाता है। इसलिए अवकलज को कुशलता से निकाल पाना बेहद महत्वपूर्ण है।
वास्तव में, वर्ग $L^2$ नॉर्म का एक बड़ा लाभ यह है कि इसका आंशिक अवकलज आसानी से निकाला जा सकता है। मान लें हमारे पास निम्न वेक्टर है:
हमने देखा कि इसका वर्ग $L^2$ नॉर्म ऐसे निकलेगा:
फिर, आंशिक अवकलज निकालते समय, अन्य सभी चर को नियत मानते हैं। उदाहरण के लिए, $u_1$ के सापेक्ष आंशिक अवकलज $u_1^2+a$ का अवकलज होगा ($a$ अन्य सभी चर के अनुरूप नियत मान है)। इस कारण हमारे पास निम्न आंशिक अवकलज मिलते हैं:
वर्ग $L^2$ नॉर्म के ग्रेडिएंट की ख़ूबी यह है कि अवकलज अन्य चरों पर निर्भर नहीं करते। हम देखेंगे कि $L^2$ नॉर्म के साथ ऐसा नहीं है।
$L^2$ नॉर्म का अवकलज
$L^2$ नॉर्म के मामले में, अवकलज अधिक जटिल होता है और वेक्टर के हर तत्व को ध्यान में लेता है। पिछले वेक्टर $\bs{u}$ को उदाहरण के रूप में लें। $L^2$ नॉर्म है:
इसका $u_1$ के सापेक्ष अवकलज निकालते हैं:
हम देखते हैं कि $u_1$ का आंशिक अवकलज अभी भी $u_2...u_n$ को समाहित करता है। अन्य ग्रेडिएंट भी इसी संरचना का पालन करते हैं:
अन्य विचार
वर्ग $L^2$ नॉर्म बढ़िया है, लेकिन एक समस्या यह है कि यह 0 और छोटे मानों के बीच भेद करना कठिन बनाता है क्योंकि फ़ंक्शन धीरे-धीरे बढ़ता है।
हम इसे वर्ग $L^2$ नॉर्म और $L^2$ नॉर्म की ग्राफ़िक तुलना से देख सकते हैं। $z$-अक्ष नॉर्म के मान को दर्शाता है और $x$- तथा $y$-अक्ष दो पैरामीटरों को। यही बात 2 से अधिक आयामों में भी सही है, पर उसे दर्शाना कठिन होगा।
$L^2$ नॉर्म:
वर्ग $L^2$ नॉर्म:
तुलना के लिए, यह रहा $L^1$ नॉर्म:
ये प्लॉट इस वेबसाइट की मदद से बनाए गए हैं। यदि इनके आकार को समझने के लिए आपको इन्हें घुमा-फिरा कर देखना है, तो जाकर स्वयं प्लॉट करें।
मैक्स नॉर्म
यह $L^\infty$ नॉर्म है और वेक्टर के सबसे बड़े तत्व के परिमाण के बराबर होता है।
मैट्रिक्स नॉर्म: Frobenius नॉर्म
यह फ्लैट करने के बाद मैट्रिक्स का $L^2$ नॉर्म लेने के बराबर है।
यही Numpy फ़ंक्शन इस्तेमाल किया जा सकता है:
नॉर्म के साथ डॉट प्रोडक्ट की अभिव्यक्ति
वेक्टर $\bs{x}$ और $\bs{y}$ के बीच डॉट प्रोडक्ट को इन वेक्टरों के $L^2$ नॉर्म से निकाला जा सकता है। यहाँ $\theta$ इन दोनों वेक्टरों के बीच का कोण है।
उदाहरण 4.
2 आयाम में दो वेक्टर लेते हैं:
और
निम्न प्लॉट उनका ग्राफ़िक निरूपण दिखाता है:
हमने यह उदाहरण इसकी सरलता के लिए चुना। जैसा कि हम देखते हैं, कोण $\theta$ 45° है।
पहले, वेक्टरों का डॉट प्रोडक्ट निकालते हैं:
और अब उनके नॉर्म निकालते हैं:
और
तो ऊपर के सूत्र से हमें मिलता है:
यह डॉट प्रोडक्ट के समान ही परिणाम है। यहाँ numpy के साथ ऑपरेशन दिए हैं। ध्यान दें कि हम Numpy के
deg2radफ़ंक्शन का उपयोग करते हैं क्योंकिnp.cosकोण को रेडियन में लेता है, इसलिए हमें रूपांतरण करना पड़ता है।निष्कर्ष
$L^2$ नॉर्म (या मैट्रिक्स के मामले में Frobenius नॉर्म) और वर्ग $L^2$ नॉर्म मशीन लर्निंग, डीप लर्निंग और सामान्यतः डेटा साइंस में व्यापक रूप से उपयोग होते हैं। उदाहरण के लिए, नॉर्म को कॉस्ट फ़ंक्शन के रूप में इस्तेमाल किया जा सकता है। मान लें कि आप डेटा बिंदुओं के एक सेट पर एक रेखा फिट करना चाहते हैं। बेहतर रेखा ढूँढ़ने का एक तरीका यह है कि यादृच्छिक पैरामीटर से शुरू करें और कॉस्ट फ़ंक्शन को न्यूनतम करते हुए इटरेट करें। कॉस्ट फ़ंक्शन आपके मॉडल की त्रुटि को दर्शाने वाला फ़ंक्शन है, इसलिए आप चाहते हैं कि यह त्रुटि यथासंभव कम हो। यहाँ नॉर्म उपयोगी है क्योंकि यह इस त्रुटि को मापने का तरीका देता है। नॉर्म आपके सभी त्रुटियों वाले वेक्टर को एक सरल स्केलर पर मैप कर देता है, और किसी पैरामीटर सेट के लिए कॉस्ट फ़ंक्शन यही स्केलर है।
हमने देखा कि नॉर्म मूलतः किसी ऐरे को घटाकर एक स्केलर बनाना है। हमने यह भी नोट किया कि इसे निकालने के लिए प्रयुक्त फ़ंक्शन के आधार पर कुछ विविधताएँ होती हैं। कौन-सा नॉर्म इस्तेमाल करना है, यह काफ़ी हद तक समस्या पर निर्भर करता है, क्योंकि एक या दूसरे को लागू करने के अपने फायदे-नुक़सान हैं। उदाहरण के लिए, $L^1$ नॉर्म $L^2$ नॉर्म की तुलना में अधिक मजबूत होता है। यानी $L^2$ नॉर्म बहिर्गामी मानों के प्रति अधिक संवेदनशील है, क्योंकि बड़ी त्रुटियाँ बहुत बड़े वर्गित त्रुटि मान दे देंगी।
यह ट्यूटोरियल Goodfellow आदि की डीप लर्निंग किताब के रैखिक बीजगणित अध्याय पर मेरी श्रृंखला के इस लेख पर आधारित है।
संदर्भ
https://www.quora.com/Why-is-L1-regularization-better-than-L2-regularization-provided-that-all-Norms-are-equivalent
http://www.deeplearningbook.org/contents/linear_algebra.html
https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.linalg.norm.html
https://hadrienj.github.io/deep-learning-book-series-home/
http://christopher5106.github.io/deep/learning/2016/09/16/about-loss-functions-multinomial-logistic-logarithm-cross-entropy-square-errors-euclidian-absolute-frobenius-hinge.html
https://datascience.stackexchange.com/questions/10188/why-do-cost-functions-use-the-square-error