👨🏾‍🏭 😋 🍏 मिश्रण घनत्व नेटवर्क 🛴 🔲 👩🏾‍⚖️

सभी को नमस्कार!

के रूप में आप अनुमान लगाया है, तंत्रिका नेटवर्क और मशीन सीखने के बारे में बात करते हैं। नाम से यह स्पष्ट है कि मिक्सचर डेंसिटी नेटवर्क्स के बारे में क्या बताया जाएगा, फिर सिर्फ एमडीएन, मैं नाम का अनुवाद नहीं करना चाहता और इसे छोड़ देना चाहता हूं। हां, हां, हां ... थोड़ा उबाऊ गणित और संभावना सिद्धांत होगा, लेकिन इसके बिना, दुर्भाग्य से, या सौभाग्य से, यह आपको तय करना है कि क्या मशीन सीखने की दुनिया की कल्पना करना मुश्किल है। लेकिन मैं आपको आश्वस्त करने के लिए जल्दबाजी करता हूं, यह अपेक्षाकृत छोटा होगा और यह बहुत मुश्किल नहीं होगा। वैसे भी, आप इसे छोड़ सकते हैं, लेकिन बस पायथन और प्योरोच में थोड़ी मात्रा में कोड को देखें, यह सही है, हम PyTorch का उपयोग करके नेटवर्क, साथ ही परिणामों के साथ विभिन्न ग्राफ़ लिखेंगे। लेकिन सबसे महत्वपूर्ण बात यह है कि एमडी नेटवर्क क्या हैं, इसे थोड़ा समझने और समझने का अवसर मिलेगा।

खैर, चलो शुरू हो जाओ!

वापसी

शुरू करने के लिए, आइए अपने ज्ञान को थोड़ा ताज़ा करें और याद करें, काफी संक्षेप में, रैखिक प्रतिगमन क्या है ।

हमारे पास एक वेक्टर है

X = \ {x_1, x_2, ..., x_n \}

$X = \ {x_1, x_2, ..., x_n \}$ हमें मूल्य का अनुमान लगाने की आवश्यकता है

य

$य$ , जो किसी तरह निर्भर करता है

$X$ कुछ रैखिक मॉडल का उपयोग करना:

$\ hat {Y} = X ^ T \ hat {\ beta}$

त्रुटि फ़ंक्शन के रूप में, हम चुकता त्रुटि का उपयोग करेंगे:

$SE (\ Beta) = \ sum_ {i = 1} ^ n (y_i- \ hat {y} _i) ^ 2 = \ sum_ {i = 1} ^ N (y_i-x_i ^ T \ hat {बीटा बीटा}} ) ^ 2$

एसई के व्युत्पन्न लेने और शून्य के लिए इसका मूल्य निर्धारित करके इस समस्या को सीधे हल किया जा सकता है:

$\ frac {\ delta SE (\ Beta)} {\ delta \ beta} = 2X ^ T (\ mathbf {y} -X \ beta) = 0$

इस प्रकार, हम बस इसका न्यूनतम पाते हैं, और एसई एक द्विघात फ़ंक्शन है, जिसका अर्थ है कि न्यूनतम हमेशा मौजूद रहेगा। उसके बाद, आप पहले से ही आसानी से पा सकते हैं

$\ बीटा$ :

$\ hat \ Beta = (X ^ TX) ^ {- 1} X ^ T \ mathbf {y}$

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

बेशक, डेटा पीढ़ी की प्रकृति में निहित निर्भरता अलग-अलग हो सकती है और फिर हमारे मॉडल में पहले से ही कुछ गैर-शुद्धता को जोड़ा जाना चाहिए। मैट्रिक्स और बड़े डेटा के लिए प्रतिगमन समस्या को सीधे हल करना भी एक बुरा विचार है, क्योंकि मैट्रिक्स है

$X ^ TX$ आयामी स्वरूप

$n \ n n$ , और एक को अभी भी अपने व्युत्क्रम मैट्रिक्स को खोजने की आवश्यकता है, और यह अक्सर ऐसा होता है कि ऐसा मैट्रिक्स बस मौजूद नहीं होता है। इस मामले में, ढाल वंश पर आधारित विभिन्न विधियां हमारी सहायता के लिए आती हैं। मॉडल के गैर-रैखिकता को विभिन्न तरीकों से लागू किया जा सकता है, जिसमें तंत्रिका नेटवर्क का उपयोग करना शामिल है।

लेकिन अब, इस बारे में बात करते हैं, लेकिन त्रुटि कार्यों के बारे में। जब डेटा का गैर-रैखिक संबंध हो सकता है, तो एसई और लॉग-लिक्लिहुड के बीच क्या अंतर है?

हम चिड़ियाघर से संबंधित हैं, अर्थात्: ओएलएस, एलएस, एसई, एमएसई, आरएसएस

यह सब एक और समान रूप से समान है, आरएसएस - वर्गों का अवशिष्ट योग, ओएलएस - साधारण न्यूनतम वर्ग, एलएस - कम से कम वर्ग, एमएसई - मतलब चुकता त्रुटि, एसई - चुकता त्रुटि। विभिन्न स्रोतों में आप अलग-अलग नाम पा सकते हैं। इसका सार केवल एक है: द्विघात विचलन । आप निश्चित रूप से भ्रमित हो सकते हैं, लेकिन आपको इसकी आदत है।

यह ध्यान देने योग्य है कि एमएसई मानक विचलन है, संपूर्ण प्रशिक्षण डेटा सेट के लिए त्रुटि का एक निश्चित औसत मूल्य है। व्यवहार में, एमएसई का उपयोग आमतौर पर किया जाता है। सूत्र विशेष रूप से भिन्न नहीं है:

$MSE (\ Beta) = \ frac {1} {N} \ sum_ {i = 1} ^ n (y_i- \ hat {y} _i) ^ 2$

$एन$ - डेटासेट का आकार,

$\ _ {y} _i$ - के लिए मॉडल भविष्यवाणी

$y_i$ ।

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

$\ _मु$ ।

यह महसूस करने के लिए कि यह ऐसा है, चलो फिर से वर्ग-विचलन फ़ंक्शन को देखें:

$RSS (\ Beta) = \ sum_ {i = 1} ^ n (y_i- \ hat {y} _i) ^ 2 \ qquad \ qquad (1)$

अब मान लें कि संभावना फ़ंक्शन का एक सामान्य रूप है, अर्थात् एक गाऊसी या सामान्य वितरण:

$L (X) = p (X (। | Theta) = \ prod ^ X \ mathcal {N} (x_i; \ mu, \ sigma ^ 2)$

सामान्य तौर पर, संभावना समारोह क्या है और इसका क्या अर्थ है यह मैं नहीं बताऊंगा, आप इसके बारे में कहीं और पढ़ सकते हैं, आपको गहन समझ के लिए सशर्त संभाव्यता, बेयस प्रमेय और बहुत कुछ की अवधारणा से भी परिचित होना चाहिए। यह सब संभाव्यता के शुद्ध सिद्धांत में जाता है, जिसका अध्ययन स्कूल और विश्वविद्यालय दोनों में किया जाता है।

अब, सामान्य वितरण सूत्र को याद करते हुए, हम प्राप्त करते हैं:

$L (X; \ mu, \ sigma ^ 2) = \ prod ^ X \ frac {1} {\ sqrt {2 \ pi \ sigma ^ 2}} e ^ {- \ frac {(x_i- mu) ^) 2} {2 \ _ सिग्मा ^ 2}} \ qquad \ qquad (2)$

क्या होगा अगर हम मानक विचलन डालते हैं

$\ _ सिग्मा ^ 2 = 1$ और सभी स्थिरांक को सूत्र में हटा दें (2), बस हटा दें, कम न करें, क्योंकि फ़ंक्शन का न्यूनतम पता लगाना उन पर निर्भर नहीं करता है। तब हम इसे देखेंगे:

$L (X; \ mu, \ sigma ^ 2) \ sim \ prod ^ Xe ^ {- (x_i- \ mu) ^ 2}$

अभी भी कुछ पसंद नहीं है? नहीं? ठीक है, क्या होगा अगर हम फ़ंक्शन का लघुगणक लेते हैं? लघुगणक से, सामान्य तौर पर, कुछ प्लस होते हैं: गुणा एक योग में बदल जाएगा, गुणा में एक डिग्री, और

$\ log {e} = 1$ - इस संपत्ति के लिए यह स्पष्ट करने योग्य है कि हम प्राकृतिक लघुगणक के बारे में बात कर रहे हैं और, सख्ती से बोल रहे हैं

$\ ln {e} = 1$ । और सामान्य तौर पर, एक फ़ंक्शन का लघुगणक इसकी अधिकतम परिवर्तन नहीं करता है, और यह हमारे लिए सबसे महत्वपूर्ण विशेषता है। लॉग-लिकेलिहुड और लिकेलिहुड के साथ संबंध और यह क्यों उपयोगी होगा एक छोटे से विषयांतर में नीचे वर्णित किया जाएगा। और इसलिए हमने क्या किया: सभी स्थिरांक हटा दिए, और संभावना समारोह का लघुगणक लिया। उन्होंने माइनस साइन को भी हटा दिया, इस प्रकार लॉग-लिकेलिहुड को नेगेटिव लॉग-लिकेलिहुड (एनएलएल) में बदल दिया, उनके बीच के संबंध को भी बोनस के रूप में वर्णित किया जाएगा। नतीजतन, हमें एनएलएल फ़ंक्शन मिला:

$\ log L (X; \ mu, I ^ 2) \ sim \ sum (X- \ mu) ^ 2$

RSS फ़ंक्शन (1) पर एक और नज़र डालें। हाँ, वे वही हैं! बिलकुल सही! यह भी देखा जाता है कि

$\ _मु = \ टोपी {य}$ ।

यदि आप MSE मानक विचलन फ़ंक्शन का उपयोग करते हैं, तो हम इससे प्राप्त करते हैं:

$\ operatorname {argmin} MSE (\ beta) \ sim \ operatorname {argmax} \ mathbb {E} _ {X \ sim P_ {data}} \ log P_ {मॉडल} (x; \ beta)$

जहाँ

$\ mathbb {E}$ - गणितीय अपेक्षा

$\ बीटा$ - मॉडल पैरामीटर, भविष्य में हम उन्हें निम्न रूप में निरूपित करेंगे:

$$ थीटा$ ।

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

$\ _ {y}$ सामान्य वितरण में औसत के बराबर। और अब हम जानते हैं कि यह सब कैसे जुड़ा हुआ है, कैसे संभाव्यता सिद्धांत (इसकी संभावना समारोह और सामान्य वितरण के साथ) और मानक विचलन या ओएलएस के तरीके जुड़े हुए हैं। इसके बारे में अधिक जानकारी [2] में मिल सकती है।

और यहाँ वादा किया गया बोनस है। चूंकि हम विभिन्न त्रुटि कार्यों के बीच संबंधों के बारे में बात कर रहे हैं, हम विचार करेंगे (पढ़ने के लिए आवश्यक नहीं):

क्रॉस-एन्ट्रॉपी, लिकेलिहुड, लॉग-लिकेलिहुड और नेगेटिव लॉग-लिकेलिहुड के बीच संबंध

मान लीजिए हमारे पास डेटा है

$X = \ {x_1, x_2, x_3, x_4, ... \}$ , प्रत्येक बिंदु एक विशिष्ट वर्ग का है, उदाहरण के लिए

$\ {x_1 \ rightarrow1, x_2 \ rightarrow2, x_3 \ rightarrow n, ... \}$ । कुल वहाँ

$एन$ कक्षाएं, जबकि कक्षा 1 होती हैं

$c_1$ समय, कक्षा 2 -

$c_2$ समय और कक्षा

$एन$ -

$c_n$ समय। इस डेटा पर हमने कुछ मॉडल को प्रशिक्षित किया

$$ थीटा$ । इसके लिए संभावना समारोह (संभावना) इस तरह दिखेगा:

$P (डेटा | \ theta) = P (0,1, ..., n। \ Theta) = P (0 |। The थीटा) P (1 | \ the थीटा) ... P (n | \ the थीटा)$

$P (1 | \ theta) P (2 | \ theta) ... P (n। \ The थी) = \ prod ^ {c_1} \ hat {y} _1 \ prod ^ {c_2} \ hat {y} _2 ... \ prod ^ {c_n} \ hat {y} _n = \ hat {y} _1 ^ {c_1} \ hat {y} _2 ^ {c_2} ... \ hat {y} _n ^ {c_n}$

जहाँ

$P (n | \ theta) = \ hat {y} _n$ - कक्षा के लिए संभावना की भविष्यवाणी की

$एन$ ।

हम संभावना फ़ंक्शन के लघुगणक को लेते हैं और लॉग-लाइकेलिहुड प्राप्त करते हैं:

$\ log {P (डेटा। \ theta)} = \ लॉग {(\ hat {y} _1 ^ {c_1} ... \ hat {y} _n ^ {c_n})} = c_1 \ log {\ hat {{ y_1}} + ... + c_n \ log {\ hat {y_n}} = \ sum_i ^ n {c_i \ log {\ hat {y_i}}}$

संभावना

$0 टोपी {y} \ में [0, 1]$ संभावना की परिभाषा के आधार पर, 0 से 1 तक की सीमा में है। इसलिए, लघुगणक का नकारात्मक मान होगा। और अगर हम लॉग-लिक्लिहुड को 1 से गुणा करते हैं, तो हमें फंक्शन निगेटिव लॉग-लिक्लिहुड (NLL) मिलता है:

$एनएलएल = - \ लॉग {पी (डेटा। \ थीटा)} = - \ sum_i ^ n {c_i \ log {\ hat {y_i}}}$

यदि हम एनएलएल को अंकों की संख्या से विभाजित करते हैं

$X$ ।

$N = c_1 + c_2 + ... + c_n$ तब हमें मिलता है:

$- \ frac {1} {N} \ log {P (data। theta)} = - \ _ sum_i ^ n {\ frac {c_i} {N} \ log {\ hat {y_i}}$

यह ध्यान दिया जा सकता है कि कक्षा के लिए वास्तविक संभावना

$एन$ के बराबर है:

$y_n = \ frac {c_n} {N}$ । यहाँ से हमें मिलता है:

$NLL = - \ sum_i ^ n {y_i \ log {\ hat {y_i}}}$

अब यदि आप क्रॉस एन्ट्रॉपी की परिभाषा को देखते हैं

$H (p, q) = - \ sum {p \ log {q}}$ तब हमें मिलता है:

$एनएलएल = एच (y_i, \ hat {y_i})$

मामले में जब हमारे पास केवल दो वर्ग हैं

$n = 2$ (बाइनरी वर्गीकरण) हमें बाइनरी क्रॉस एन्ट्रॉपी का सूत्र मिलता है (आप प्रसिद्ध नाम लॉग-लॉस से भी मिल सकते हैं):

$H (y, \ hat {y}) = - (y \ log {\ hat {y}} + + (1-y) \ log {(1- \ hat {y}})}$

इस सब से, यह समझा जा सकता है कि कुछ मामलों में क्रॉस-एन्ट्रॉपी को कम करना एनएलएल को कम करने या संभावना फ़ंक्शन (लिकेलिहुड) या लॉग-लिकेलिहुड का अधिकतम पता लगाने के बराबर है।

एक उदाहरण है। एक द्विआधारी वर्गीकरण पर विचार करें। हमारे पास वर्ग मूल्य हैं:

y = np.array([0, 1, 1, 1, 1, 0, 1, 1]).astype(np.float32)

वास्तविक संभावना

$य$ वर्ग 0 के लिए बराबर है

$2/8 = 0.25$ , कक्षा 1 के लिए बराबर है

$6/8 = 0.75$ । मान लीजिए कि हमारे पास एक बाइनरी क्लासिफायरियर है जो क्लास 0 की संभावना की भविष्यवाणी करता है

$\ _ {y}$ प्रत्येक उदाहरण के लिए, क्रमशः, कक्षा 1 के लिए, संभावना है

$(1- हैट {y})$ । आइए विभिन्न पूर्वानुमानों के लिए लॉग-लॉस फ़ंक्शन के मूल्यों को प्लॉट करें

$\ _ {y}$ :

ग्राफ़ पर आप देख सकते हैं कि लॉग-लॉस फ़ंक्शन का न्यूनतम बिंदु 0.75 से मेल खाता है, अर्थात। यदि हमारा मॉडल पूरी तरह से स्रोत डेटा के वितरण को "सीखा" है,

$\ _ {y} = y$ ।

तंत्रिका नेटवर्क प्रतिगमन

इसलिए हम एक और दिलचस्प अभ्यास में आए। आइए देखें कि आप तंत्रिका नेटवर्क (तंत्रिका नेटवर्क) का उपयोग करके प्रतिगमन की समस्या को कैसे हल कर सकते हैं। हम पायथन प्रोग्रामिंग भाषा में सब कुछ लागू करेंगे, एक नेटवर्क बनाने के लिए हम PyTorch डीप लर्निंग लाइब्रेरी का उपयोग करते हैं।

स्रोत डेटा पीढ़ी

इनपुट डेटा

$\ mathbf {X} \ in \ mathbb {R} ^ N$ एक समान वितरण का उपयोग करके उत्पन्न करें, अंतराल -15 से 15 तक ले जाएं,

$U [-15, 15] $ में $ \ mathbf {X}$ । अंक

$\ mathbf {Y}$ हम समीकरण का उपयोग कर प्राप्त करते हैं:

$\ mathbf {Y} = 0.5 \ mathbf {X} + 8 \ sin (0.3 \ mathbf {X}) + शोर \ qquad \ qquad (3)$

जहाँ

$शोर$ आयाम का एक शोर वेक्टर है

$एन$ मापदंडों के साथ सामान्य वितरण का उपयोग करके प्राप्त:

$\ mu = 0, \ sigma ^ 2 = 1$ ।

डेटा जनरेशन

 N = 3000 #   IN_DIM = 1 OUT_DIM = IN_DIM x = np.random.uniform(-15., 15., (IN_DIM, N)).T.astype(np.float32) noise = np.random.normal(size=(N, 1)).astype(np.float32) y = 0.5*x+ 8.*np.sin(0.3*x) + noise #  3 x_train, x_test, y_train, y_test = train_test_split(x, y) #

प्राप्त आंकड़ों का ग्राफ।

नेटवर्क बिल्डिंग

एक नियमित फ़ीड फॉरवर्ड न्यूरल नेटवर्क या FFNN बनाएं।

एफएफएनएन का निर्माण

 class Net(nn.Module): def __init__(self, input_dim=IN_DIM, out_dim=OUT_DIM, layer_size=40): super(Net, self).__init__() self.fc = nn.Linear(input_dim, layer_size) self.logit = nn.Linear(layer_size, out_dim) def forward(self, x): x = F.tanh(self.fc(x)) #  4 x = self.logit(x) return x

हमारे नेटवर्क में 40 न्यूरॉन्स के आयाम के साथ और सक्रियण फ़ंक्शन के साथ एक छिपी हुई परत होती है - हाइपरबोलिक स्पर्शरेखा:

$\ tanh x = \ frac {e ^ x-e ^ {- x}} {e ^ x + e ^ {- x}} \ qquad \ qquad (4)$

आउटपुट परत एक सक्रियण फ़ंक्शन के बिना एक सामान्य रैखिक परिवर्तन है।

सीखना और परिणाम प्राप्त करना

एक अनुकूलक के रूप में हम AdamOptimizer का उपयोग करेंगे। अध्ययन के युगों की संख्या = 2000, सीखने की दर (सीखने की दर या lr) = 0.1।

एफएफएनएन प्रशिक्षण

 def train(net, x_train, y_train, x_test, y_test, epoches=2000, lr=0.1): criterion = nn.MSELoss() optimizer = optim.Adam(net.parameters(), lr=lr) N_EPOCHES = epoches BS = 1500 n_batches = int(np.ceil(x_train.shape[0] / BS)) train_losses = [] test_losses = [] for i in range(N_EPOCHES): for bi in range(n_batches): x_batch, y_batch = fetch_batch(x_train, y_train, bi, BS) x_train_var = Variable(torch.from_numpy(x_batch)) y_train_var = Variable(torch.from_numpy(y_batch)) optimizer.zero_grad() outputs = net(x_train_var) loss = criterion(outputs, y_train_var) loss.backward() optimizer.step() with torch.no_grad(): x_test_var = Variable(torch.from_numpy(x_test)) y_test_var = Variable(torch.from_numpy(y_test)) outputs = net(x_test_var) test_loss = criterion(outputs, y_test_var) test_losses.append(test_loss.item()) train_losses.append(loss.item()) if i%100 == 0: sys.stdout.write('\r Iter: %d, test loss: %.5f, train loss: %.5f' %(i, test_loss.item(), loss.item())) sys.stdout.flush() return train_losses, test_losses net = Net() train_losses, test_losses = train(net, x_train, y_train, x_test, y_test)

अब सीखने के परिणामों पर नजर डालते हैं।

प्रशिक्षण की पुनरावृत्ति के आधार पर MSE फ़ंक्शन मानों का ग्राफ़, प्रशिक्षण डेटा और परीक्षण डेटा के लिए मूल्यों का ग्राफ़।

परीक्षण डेटा पर वास्तविक और अनुमानित परिणाम।

उलटा डेटा

हम कार्य को जटिल करते हैं और डेटा को उल्टा करते हैं।

डेटा उलटा

 x_train_inv = y_train y_train_inv = x_train x_test_inv = y_train y_test_inv = x_train

उलटा डेटा ग्राफ।

भविष्यवाणी के लिए

$\ mathbf {\ hat Y}$ चलो पिछले अनुभाग से प्रत्यक्ष वितरण नेटवर्क का उपयोग करें और देखें कि यह कैसे संभालता है।

 inv_train_losses, inv_test_losses = train(net, x_train_inv, y_train_inv, x_test_inv, y_test_inv)

परीक्षण डेटा पर वास्तविक और अनुमानित परिणाम।

जैसा कि आप ऊपर दिए गए ग्राफ़ से देख सकते हैं, हमारे नेटवर्क ने इस तरह के डेटा का बिल्कुल भी सामना नहीं किया है , यह केवल उनकी भविष्यवाणी नहीं कर सकता है। और यह सब इसलिए हुआ क्योंकि एक बिंदु के लिए ऐसी उलटी समस्या थी

$x$ कई बिंदुओं के अनुरूप हो सकता है

$य$ । आप पूछते हैं, शोर के बारे में क्या? उन्होंने एक स्थिति भी बनाई जिसमें एक के लिए

$x$ कुछ मूल्य मिल सकता है

$य$ । हाँ, यह सही है। लेकिन पूरे बिंदु यह है कि शोर के बावजूद, यह सभी एक निश्चित वितरण था। और चूंकि हमारे मॉडल ने अनिवार्य रूप से भविष्यवाणी की थी

$p (y | x)$ , और एमएसई के मामले में यह सामान्य वितरण के लिए औसत मूल्य था (यह लेख के पहले भाग में क्यों वर्णित है), तो यह "प्रत्यक्ष" कार्य के साथ अच्छी तरह से मुकाबला किया। अन्यथा, हम एक के लिए कई अलग-अलग वितरण प्राप्त करते हैं

$x$ और तदनुसार हमें केवल एक सामान्य वितरण के साथ एक अच्छा परिणाम नहीं मिल सकता है।

मिश्रण घनत्व नेटवर्क

मज़ा शुरू होता है! मिक्सचर डेंसिटी नेटवर्क (इसके बाद एमडीएन या एमडी नेटवर्क) क्या है? सामान्य तौर पर, यह एक निश्चित मॉडल है जो एक साथ कई वितरणों को मॉडल करने में सक्षम है:

$p (\ mathbf {y} | \ mathbf {x}; theta) = \ sum_k ^ K \ pi_k (\ mathbf {x}) \ mathcal {N} (\ mathbf / y}; mu_k (\ mathbf {) x}), \ sigma ^ 2 (\ mathbf {x})) \ qquad \ qquad (5)$

क्या अजीब सूत्र है, आप कहते हैं। चलिए इसका पता लगाते हैं। हमारा एमडी नेटवर्क माडल बनाना सीख रहा है

$\ _मु$ और विचरण

$\ _ सिग्मा ^ 2$ कई वितरण के लिए। सूत्र में (5)

$\ pi_k (\ mathbf {x})$ - प्रत्येक बिंदु के लिए एक अलग वितरण के तथाकथित महत्व कारक

$x_i \ in \ mathbf {x}$ एक निश्चित मिश्रण कारक, या वितरण में से प्रत्येक एक निश्चित बिंदु पर कितना योगदान देता है। कुल वहाँ

$K$ वितरण।

के बारे में कुछ और शब्द

$\ pi_k (\ mathbf {x})$ - वास्तव में, यह एक वितरण भी है और एक बिंदु के लिए संभावना का प्रतिनिधित्व करता है

$x_i \ in \ mathbf {x}$ एक शर्त होगी

$k$ ।

फू, फिर, यह गणित, चलो पहले से ही कुछ लिखें। और इसलिए, चलो नेटवर्क को लागू करना शुरू करते हैं। हमारे नेटवर्क के लिए हम लेते हैं

$K = 30$ ।

 self.fc = nn.Linear(input_dim, layer_size) self.fc2 = nn.Linear(layer_size, 50) self.pi = nn.Linear(layer_size, coefs) self.mu = nn.Linear(layer_size, out_dim*coefs) # mean self.sigma_sq = nn.Linear(layer_size, coefs) # variance

हमारे नेटवर्क के लिए आउटपुट लेयर को परिभाषित करें:

 x = F.relu(self.fc(x)) x = F.relu(self.fc2(x)) pi = F.softmax(self.pi(x), dim=1) sigma_sq = torch.exp(self.sigma_sq(x)) mu = self.mu(x)

हम त्रुटि फ़ंक्शन या हानि फ़ंक्शन, सूत्र (5) लिखते हैं:

 def gaussian_pdf(x, mu, sigma_sq): return (1/torch.sqrt(2*np.pi*sigma_sq)) * torch.exp((-1/(2*sigma_sq)) * torch.norm((x-mu), 2, 1)**2) losses = Variable(torch.zeros(y.shape[0])) # p(y|x) for i in range(COEFS): likelihood = gaussian_pdf(y, mu[:, i*OUT_DIM:(i+1)*OUT_DIM], sigma_sq[:, i]) prior = pi[:, i] losses += prior * likelihood loss = torch.mean(-torch.log(losses))

एमडीएन बिल्ड कोड को पूरा करें

 COEFS = 30 class MDN(nn.Module): def __init__(self, input_dim=IN_DIM, out_dim=OUT_DIM, layer_size=50, coefs=COEFS): super(MDN, self).__init__() self.fc = nn.Linear(input_dim, layer_size) self.fc2 = nn.Linear(layer_size, 50) self.pi = nn.Linear(layer_size, coefs) self.mu = nn.Linear(layer_size, out_dim*coefs) # mean self.sigma_sq = nn.Linear(layer_size, coefs) # variance self.out_dim = out_dim self.coefs = coefs def forward(self, x): x = F.relu(self.fc(x)) x = F.relu(self.fc2(x)) pi = F.softmax(self.pi(x), dim=1) sigma_sq = torch.exp(self.sigma_sq(x)) mu = self.mu(x) return pi, mu, sigma_sq #       def gaussian_pdf(x, mu, sigma_sq): return (1/torch.sqrt(2*np.pi*sigma_sq)) * torch.exp((-1/(2*sigma_sq)) * torch.norm((x-mu), 2, 1)**2) #   def loss_fn(y, pi, mu, sigma_sq): losses = Variable(torch.zeros(y.shape[0])) # p(y|x) for i in range(COEFS): likelihood = gaussian_pdf(y, mu[:, i*OUT_DIM:(i+1)*OUT_DIM], sigma_sq[:, i]) prior = pi[:, i] losses += prior * likelihood loss = torch.mean(-torch.log(losses)) return loss

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

एमडीएन प्रशिक्षण

 def train_mdn(net, x_train, y_train, x_test, y_test, epoches=1000): optimizer = optim.Adam(net.parameters(), lr=0.01) N_EPOCHES = epoches BS = 1500 n_batches = int(np.ceil(x_train.shape[0] / BS)) train_losses = [] test_losses = [] for i in range(N_EPOCHES): for bi in range(n_batches): x_batch, y_batch = fetch_batch(x_train, y_train, bi, BS) x_train_var = Variable(torch.from_numpy(x_batch)) y_train_var = Variable(torch.from_numpy(y_batch)) optimizer.zero_grad() pi, mu, sigma_sq = net(x_train_var) loss = loss_fn(y_train_var, pi, mu, sigma_sq) loss.backward() optimizer.step() with torch.no_grad(): if i%10 == 0: x_test_var = Variable(torch.from_numpy(x_test)) y_test_var = Variable(torch.from_numpy(y_test)) pi, mu, sigma_sq = net(x_test_var) test_loss = loss_fn(y_test_var, pi, mu, sigma_sq) train_losses.append(loss.item()) test_losses.append(test_loss.item()) sys.stdout.write('\r Iter: %d, test loss: %.5f, train loss: %.5f' %(i, test_loss.item(), loss.item())) sys.stdout.flush() return train_losses, test_losses mdn_net = MDN() mdn_train_losses, mdn_test_losses = train_mdn(mdn_net, x_train_inv, y_train_inv, x_test_inv, y_test_inv)

प्रशिक्षण की पुनरावृत्ति के आधार पर हानि फ़ंक्शन मूल्यों का ग्राफ, प्रशिक्षण डेटा और परीक्षण डेटा के लिए मूल्यों का ग्राफ।

चूंकि हमारे नेटवर्क ने कई वितरणों के लिए माध्य मान सीखे हैं, तो आइए इसे देखें:

 pi, mu, sigma_sq = mdn_net(Variable(torch.from_numpy(x_test_inv)))

प्रत्येक बिंदु (बाएं) के लिए दो सबसे अधिक संभावित माध्य मानों के लिए ग्राफ़। प्रत्येक बिंदु (दाएं) के लिए 4 सबसे अधिक संभावित माध्य मानों के लिए ग्राफ़।

प्रत्येक बिंदु के लिए सभी माध्य मानों के लिए ग्राफ़।

डेटा की भविष्यवाणी करने के लिए, हम बेतरतीब ढंग से कई मानों का चयन करेंगे

$\ _मु$ और

$\ _ सिग्मा ^ 2$ मूल्य के आधार पर

$\ pi_k (\ mathbf {x})$ । और फिर लक्ष्य डेटा उत्पन्न करने के लिए उनके आधार पर

$\ _ {y}$ सामान्य वितरण का उपयोग करना।

परिणाम की भविष्यवाणी

 def rand_n_sample_cumulative(pi, mu, sigmasq, samples=10): n = pi.shape[0] out = Variable(torch.zeros(n, samples, OUT_DIM)) for i in range(n): for j in range(samples): u = np.random.uniform() prob_sum = 0 for k in range(COEFS): prob_sum += pi.data[i, k] if u < prob_sum: for od in range(OUT_DIM): sample = np.random.normal(mu.data[i, k*OUT_DIM+od], np.sqrt(sigmasq.data[i, k])) out[i, j, od] = sample break return out pi, mu, sigma_sq = mdn_net(Variable(torch.from_numpy(x_test_inv))) preds = rand_n_sample_cumulative(pi, mu, sigma_sq, samples=10)

10 बेतरतीब ढंग से चयनित मूल्यों के लिए अनुमानित डेटा

$\ _मु$ और

$\ _ सिग्मा ^ 2$ (बाएं) और दो (दाएं) के लिए।

यह उन आंकड़ों से देखा जा सकता है कि एमडीएन ने "उलटा" कार्य के साथ एक उत्कृष्ट कार्य किया।

अधिक जटिल डेटा का उपयोग करना

आइए देखें कि हमारा एमडी नेटवर्क सर्पिल डेटा जैसे अधिक जटिल डेटा को कैसे संभालता है। कार्तीय निर्देशांक में हाइपरबोलिक सर्पिल का समीकरण:

$x = \ rho \ cos \ phi \\\ qquad \ qquad \ qquad \ qquad \ qquad \ qquad (6) \\ y = \ rho \ sin \ phi \\$

सर्पिल डेटा जनरेशन

 N = 2000 x_train_compl = [] y_train_compl = [] x_test_compl = [] y_test_compl = [] noise_train = np.random.uniform(-1, 1, (N, IN_DIM)).astype(np.float32) noise_test = np.random.uniform(-1, 1, (N, IN_DIM)).astype(np.float32) for i, theta in enumerate(np.linspace(0, 5*np.pi, N).astype(np.float32)): #  6 r = ((theta)) x_train_compl.append(r*np.cos(theta) + noise_train[i]) y_train_compl.append(r*np.sin(theta)) x_test_compl.append(r*np.cos(theta) + noise_test[i]) y_test_compl.append(r*np.sin(theta)) x_train_compl = np.array(x_train_compl).reshape((-1, 1)) y_train_compl = np.array(y_train_compl).reshape((-1, 1)) x_test_compl = np.array(x_test_compl).reshape((-1, 1)) y_test_compl = np.array(y_test_compl).reshape((-1, 1))

सर्पिल डेटा का ग्राफ।

मज़े के लिए, आइए देखें कि एक नियमित फ़ीड-फॉरवर्ड नेटवर्क इस तरह के कार्य से कैसे निपटेगा।

जैसी कि उम्मीद थी, फीड-फॉरवर्ड नेटवर्क ऐसे डेटा के लिए प्रतिगमन समस्या को हल करने में सक्षम नहीं है।

हम सर्पिल डेटा पर प्रशिक्षण के लिए पहले से वर्णित और निर्मित एमडी नेटवर्क का उपयोग करते हैं।

मिक्सचर डेंसिटी नेटवर्क ने इस स्थिति में बहुत अच्छा काम किया।

निष्कर्ष

इस लेख की शुरुआत में, हमने रैखिक प्रतिगमन की मूल बातें याद कीं। हमने देखा कि सामान्य वितरण और एमएसई के लिए औसत खोजने के बीच। खारिज कर दिया कि एनएलएल और क्रॉस एन्ट्रॉपी कैसे जुड़े। और सबसे महत्वपूर्ण बात, हमने एमडीएन मॉडल का पता लगाया, जो मिश्रित वितरण से प्राप्त आंकड़ों से सीखने में सक्षम है। मुझे उम्मीद है कि लेख समझ में आता है और दिलचस्प है, इस तथ्य के बावजूद कि गणित का एक सा था।

पूरा कोड GitHub पर देखा जा सकता है ।

साहित्य

मिक्सचर डेंसिटी नेटवर्क्स (क्रिस्टोफर एम। बिशप, न्यूरल कंप्यूटिंग रिसर्च ग्रुप, कंप्यूटर साइंस एंड एप्लाइड मैथमेटिक्स, एस्टन यूनिवर्सिटी, बर्मिंघम) विभाग - लेख एमडी नेटवर्क के सिद्धांत का पूरी तरह से वर्णन करता है।
कम से कम वर्ग और अधिकतम संभावना (MROsborne)

मिश्रण घनत्व नेटवर्क

वापसी

तंत्रिका नेटवर्क प्रतिगमन

स्रोत डेटा पीढ़ी

नेटवर्क बिल्डिंग

सीखना और परिणाम प्राप्त करना

उलटा डेटा

मिश्रण घनत्व नेटवर्क

अधिक जटिल डेटा का उपयोग करना

निष्कर्ष

साहित्य

More articles: