तंत्रिका नेटवर्क डेटा संपीड़न

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

1. कोहेनन नेटवर्क और इसकी विविधताएँ। अक्सर गुणवत्ता की हानि के साथ छवियों को संपीड़ित करने के लिए उपयोग किया जाता है, यह दोषरहित संपीड़न एल्गोरिथ्म नहीं है।

2. साहचर्य स्मृति (हॉपफील्ड नेटवर्क, द्विदिश साहचर्य स्मृति, आदि)। नेटवर्क के इस वर्ग के लिए "डेटा संपीड़न" एक "विशेषता" है, एक साइड इफेक्ट, क्योंकि उनका मुख्य उद्देश्य शोर / क्षतिग्रस्त इनपुट डेटा से मूल सिग्नल / छवि को पुनर्स्थापित करना है। सबसे अधिक बार, एक ही आयाम की एक शोर छवि इन नेटवर्क के इनपुट पर आती है, इसलिए हम डेटा संपीड़न के बारे में बात नहीं कर रहे हैं।

3. "टोंटी" विधि।

लेख में अंतिम विधि पर चर्चा की जाएगी।

विधि का सार

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

सीखने को क्या प्रभावित करता है?

नेटवर्क सीखने की दर को प्रभावित करने के लिए एक महत्वपूर्ण लीवर सीखने की दर गुणांक का कुशल समायोजन है। सबसे सरल विकल्प - जब पिछले समय में नेटवर्क त्रुटि के साथ तुलना में नेटवर्क त्रुटि अपेक्षाकृत कम मूल्य (0.0000001 से कम) में बदल जाती है, तो गुणांक कम होना चाहिए। सीखने की गति को बदलने के लिए अधिक बुद्धिमान एल्गोरिदम हैं।
और प्रशिक्षण में एक और बहुत महत्वपूर्ण तत्व सर्वशक्तिमान यादृच्छिकता है। यह अपने वजन गुणांक के साथ एक न्यूरॉन बनाते समय छोटे यादृच्छिक मूल्यों को निर्धारित करने के लिए प्रथागत है। कभी-कभी यह पता चलता है कि मान बेतरतीब ढंग से सेट हैं जैसे कि नेटवर्क अप्रशिक्षित हो जाता है, या त्रुटि का अभिसरण बहुत छोटा है।

कार्यान्वयन

कार्यान्वयन ने AForge.NET लाइब्रेरी का उपयोग किया। मैंने लंबाई 10 के वैक्टर पर मुख्य प्रयोगों का संचालन किया, फिर लंबाई 20 के वैक्टर पर, इससे सार नहीं बदला, इसलिए मैंने आयाम नहीं बढ़ाया, लेकिन एक और कारण है। मैंने लंबे वैक्टर के साथ प्रयोग क्यों नहीं किया है? लंबे वैक्टर के साथ एक बड़ा प्रशिक्षण सेट क्यों नहीं बनाया गया? यह आलस्य के कारण होता है क्योंकि यह कुछ समस्याओं और असुविधाओं का कारण बनता है। ऐसे नमूने में विरोधाभास हो सकता है। उदाहरण के लिए, वैक्टर के इनपुट सेट में दो या अधिक समान या समान वैक्टर मौजूद हो सकते हैं, जिनमें से वांछित आउटपुट पूरी तरह से अलग होगा। फिर ऐसे प्रशिक्षण नमूने पर नेटवर्क अप्रशिक्षित होगा, और "परस्पर विरोधी" वैक्टर ढूंढना मुश्किल है।

परिणाम और निष्कर्ष

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

"त्वरित संपीड़न"

"फास्ट कम्प्रेशन" वाला एक नेटवर्क एक ऐसा नेटवर्क है जहाँ छिपी हुई परतों में न्यूरॉन्स की संख्या इनपुट / आउटपुट लेयर की तुलना में बहुत कम (3, 5, इत्यादि) होती है और नेटवर्क में 4 लेयर्स होते हैं - इनपुट, आउटपुट और दो छिपा हुआ (जैसे 10-3-3-10)। एक समान नेटवर्क टोपोलॉजी कुछ मामलों में बहुत प्रभावी साबित हुई है। सबसे पहले, ऐसा नेटवर्क बहुत जल्दी सीखता है। यह इस तथ्य के कारण है कि प्रशिक्षण एल्गोरिथ्म को आसन्न परतों के बीच अपेक्षाकृत कम संख्या में बांड के लिए वजन गुणांक को समायोजित करने की आवश्यकता है। दूसरे, नेटवर्क के कामकाज के दौरान परिणाम के आउटपुट की गति भी बहुत अधिक है (उसी कारण से)। रिवर्स साइड - नेटवर्क को केवल इनपुट में न्यूरॉन्स की संख्या के सापेक्ष एक छोटे नमूने पर प्रशिक्षित किया जाता है (और, तदनुसार, आउटपुट) परत (वैक्टर की स्वीकार्य संख्या नेटवर्क की पहली / अंतिम परत में न्यूरॉन्स के आधे के बराबर है)। इसके अलावा, छड़ी को न मोड़ें और परतों के बीच बहुत अंतर करें, सबसे अच्छा विकल्प यह है कि छिपी हुई परत में न्यूरॉन्स की संख्या इनपुट / आउटपुट परत की तुलना में लगभग 3 गुना कम होनी चाहिए।

"अनुक्रमिक संपीड़न"

"अनुक्रमिक" या "इत्मीनान" संपीड़न वाला एक नेटवर्क एक नेटवर्क है जहां पड़ोसी परतों में न्यूरॉन्स की संख्या बहुत अलग नहीं है (25% तक), और नेटवर्क में 4 या अधिक छिपी हुई परतें हैं (उदाहरण के लिए, 10-8-5-3-3- 05.08.10)। इस तरह के नेटवर्क मेरी उम्मीदों पर खरे नहीं उतरे। यहां तक ​​कि एक छोटे से प्रशिक्षण नमूने और वेक्टर की लंबाई के साथ, उन्हें सीखने में बहुत लंबा समय लगता है। खैर, वे काम करते हैं, ज़ाहिर है, धीमी भी। हालांकि वे कहते हैं कि वास्तविक युद्ध स्थितियों में वे अधिक स्थिर हैं। लेकिन बहुत लंबे प्रशिक्षण समय के कारण, यह सत्यापित नहीं किया जा सका।

दक्षता और अपटाइम के बारे में

व्यावहारिक दृष्टिकोण से, दो तथ्य दिलचस्प हैं - संपीड़न अनुपात और संपीड़न / पुनर्प्राप्ति समय। नेटवर्क लगभग 100% प्रशिक्षित है और पूरी तरह से कार्य करता है, 3 बार डेटा को संपीड़ित करता है। काम की गति भी मनभावन है। वास्तुकला (10-3-3-10) के लिए, पूर्ण चक्र निष्पादन समय (संपीड़न और पुनर्प्राप्ति) 00: 00: 00.0000050 है। के लिए (20-6-6-20) - 00: 00: 00.000006565। हम सुरक्षित रूप से 2 से विभाजित कर सकते हैं और एक वेक्टर के संपीड़न या बहाली के लिए 00: 00: 00.000002525 और 00: 00: 00.0000033 प्राप्त कर सकते हैं।
एएमडी एथलॉन II x240 2.80 Ghz प्रोसेसर पर टेस्ट आयोजित किए गए थे।

उदाहरण

एक उदाहरण के रूप में, कोड का एक छोटा टिप्पणी टुकड़ा (सी # में) एक नेटवर्क के निर्माण, प्रशिक्षण और संचालन के एक आदिम उदाहरण का वर्णन करता है। नेटवर्क वेक्टर को 3 बार संकुचित करता है, यह 98% मामलों में प्रशिक्षित होता है। कामकाज के लिए AForge.NET लाइब्रेरी को कनेक्ट करना आवश्यक है।

using System;
using AForge.Neuro;
using AForge.Neuro.Learning;

namespace FANN
{
class Program
{
static void Main( string [] args)
{
// 4 ( 10,3,3,10 , )
ActivationNetwork net = new ActivationNetwork((IActivationFunction) new SigmoidFunction(), 10,3,3,10);
// -
BackPropagationLearning trainer = new BackPropagationLearning(net);

//
double [][] input = new double [][] {
new double []{1,1,1,1,1,1,1,1,1,1},
new double []{0,0,0,0,0,0,0,0,0,0},
new double []{1,1,1,1,1,0,0,0,0,0},
new double []{0,0,0,0,0,1,1,1,1,1},
};

//
double [][] output= new double [][] {
new double []{1,1,1,1,1,1,1,1,1,1},
new double []{0,0,0,0,0,0,0,0,0,0},
new double []{1,1,1,1,1,0,0,0,0,0},
new double []{0,0,0,0,0,1,1,1,1,1},
};

// ,
double prErr = 10000000;
//
double error = 100;
//
trainer.LearningRate = 1;
//
while (error > 0.001)
{
//
error = trainer.RunEpoch(input, output);
// ,
if ( Math .Abs(error - prErr) < 0.000000001)
{
// 2
trainer.LearningRate /= 2;
if (trainer.LearningRate < 0.001)
trainer.LearningRate = 0.001;
}

prErr = error;
}

//
double [] result;
result = net.Compute( new double [] { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
result = net.Compute( new double [] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
result = net.Compute( new double [] { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 });
result = net.Compute( new double [] { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1 });
}
}
}

* This source code was highlighted with Source Code Highlighter .

साहित्य और नोट्स

• विकिपीडिया
• लाइब्रेरी पेज - www.aforgenet.com
• लाइब्रेरी डाउनलोड पेज - www.aforgenet.com/framework/downloads.html
• पूरे AForge.NET लाइब्रेरी में से, इसका केवल एक हिस्सा आवश्यक है - AForge.Neuro।
• AForge.NET लाइब्रेरी दोहरे प्रकार के साथ काम करती है, क्योंकि नेटवर्क आउटपुट आंशिक है, लेकिन हमारे द्वारा आवश्यक मानों के बहुत करीब है - 0 और 1. इसलिए, एक पूर्ण आउटपुट प्राप्त करने के लिए, आप "थ्रेसहोल्ड" फ़ंक्शन के माध्यम से प्रत्येक सरणी मान को चला सकते हैं जो मान कम होने पर 0 देता है। 0.5 और 1 अन्यथा।