🤚🏼 🐥 🛌🏼 C ++ डेवलपर्स के लिए तंत्रिका नेटवर्क 🤞 👺 🚵🏽

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

उन्होंने एक तंत्रिका नेटवर्क के प्रशिक्षण के लिए एक पुस्तकालय लिखा था। कौन परवाह करता है, कृपया।

मैं लंबे समय से खुद को इस स्तर का साधन बनाना चाहता था। सी गर्मियों में वह व्यापार में उतर गया। यहाँ क्या हुआ:

लाइब्रेरी को C ++ में स्क्रैच से लिखा गया है (गणना के लिए केवल STL + OpenBLAS), C- इंटरफ़ेस, जीत / लिनक्स;
JSON में नेटवर्क संरचना निर्दिष्ट है;
आधार परत: पूरी तरह से जुड़ा हुआ, दृढ़, पूलिंग। अतिरिक्त: आकार, फसल ..;
बुनियादी विशेषताएं: बैचनॉर्म, ड्रॉपआउट, वेट ऑप्टिमाइज़र - एडम, एडग्राड ..;
OpenBLAS का उपयोग वीडियो कार्ड के लिए CPU, CUDA / cuDNN की गणना करने के लिए किया जाता है। उन्होंने भविष्य के लिए OpenCL पर कार्यान्वयन भी रखा;
प्रत्येक परत के लिए अलग-अलग सेट करने का अवसर है कि क्या विचार किया जाए - सीपीयू या जीपीयू (और कौन सा);
इनपुट डेटा का आकार कठोरता से सेट नहीं है, यह कार्य / प्रशिक्षण के दौरान बदल सकता है;
सी ++ और पायथन के लिए इंटरफेस बनाया। C # बाद में भी आएगा।

पुस्तकालय को स्काईनेट कहा जाता था। (सब कुछ नामों के साथ जटिल है, अन्य विकल्प थे, लेकिन कुछ सही नहीं है ..)

MNIST उदाहरण का उपयोग करके PyTorch के साथ तुलना:

PyTorch: सटीकता: 98%, समय: 140 सेकंड
स्काईनेट: सटीकता: 95%, समय: 150 सेकंड

मशीन: i5-2300, GF1060। टेस्ट कोड।

सॉफ्टवेयर वास्तुकला

यह संचालन के एक ग्राफ पर आधारित है जो नेटवर्क संरचना को पार्स करने के बाद गतिशील रूप से बनाया जाता है।
प्रत्येक शाखा के लिए, एक नया धागा। नेटवर्क का प्रत्येक नोड (नोड) गणना की एक परत है।

काम की विशेषताएं हैं:

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

उदाहरण

MNIST

C ++ कोड इस तरह दिखता है:

//   sn::Net snet; snet.addNode("Input", sn::Input(), "C1") .addNode("C1", sn::Convolution(15, 0, sn::calcMode::CUDA), "C2") .addNode("C2", sn::Convolution(15, 0, sn::calcMode::CUDA), "P1") .addNode("P1", sn::Pooling(sn::calcMode::CUDA), "FC1") .addNode("FC1", sn::FullyConnected(128, sn::calcMode::CUDA), "FC2") .addNode("FC2", sn::FullyConnected(10, sn::calcMode::CUDA), "LS") .addNode("LS", sn::LossFunction(sn::lossType::softMaxToCrossEntropy), "Output"); ............. // -  //   for (int k = 0; k < 1000; ++k){ targetLayer.clear(); srand(clock()); //   for (int i = 0; i < batchSz; ++i){ ............. } //     float accurat = 0; snet.training(lr, inLayer, outLayer, targetLayer, accurat); }

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

उसी योजना का एक और नेटवर्क, अधिक जटिल।

ऐसा नेटवर्क बनाने के लिए कोड:

  //   sn::Net snet; snet.addNode("Input", sn::Input(), "C1 C2 C3") .addNode("C1", sn::Convolution(15, 0, sn::calcMode::CUDA), "P1") .addNode("P1", sn::Pooling(sn::calcMode::CUDA), "FC1") .addNode("C2", sn::Convolution(12, 0, sn::calcMode::CUDA), "P2") .addNode("P2", sn::Pooling(sn::calcMode::CUDA), "FC3") .addNode("C3", sn::Convolution(12, 0, sn::calcMode::CUDA), "P3") .addNode("P3", sn::Pooling(sn::calcMode::CUDA), "FC5") .addNode("FC1", sn::FullyConnected(128, sn::calcMode::CUDA), "FC2") .addNode("FC2", sn::FullyConnected(10, sn::calcMode::CUDA), "LS1") .addNode("LS1", sn::LossFunction(sn::lossType::softMaxToCrossEntropy), "Summ") .addNode("FC3", sn::FullyConnected(128, sn::calcMode::CUDA), "FC4") .addNode("FC4", sn::FullyConnected(10, sn::calcMode::CUDA), "LS2") .addNode("LS2", sn::LossFunction(sn::lossType::softMaxToCrossEntropy), "Summ") .addNode("FC5", sn::FullyConnected(128, sn::calcMode::CUDA), "FC6") .addNode("FC6", sn::FullyConnected(10, sn::calcMode::CUDA), "LS3") .addNode("LS3", sn::LossFunction(sn::lossType::softMaxToCrossEntropy), "Summ") .addNode("Summ", sn::Summator(), "Output"); .............

उदाहरणों में यह नहीं है, आप यहां से कॉपी कर सकते हैं।

पायथन में, कोड भी दिखता है

  //   snet = snNet.Net() snet.addNode("Input", Input(), "C1 C2 C3") \ .addNode("C1", Convolution(15, 0, calcMode.CUDA), "P1") \ .addNode("P1", Pooling(calcMode.CUDA), "FC1") \ .addNode("C2", Convolution(12, 0, calcMode.CUDA), "P2") \ .addNode("P2", Pooling(calcMode.CUDA), "FC3") \ .addNode("C3", Convolution(12, 0, calcMode.CUDA), "P3") \ .addNode("P3", Pooling(calcMode.CUDA), "FC5") \ \ .addNode("FC1", FullyConnected(128, calcMode.CUDA), "FC2") \ .addNode("FC2", FullyConnected(10, calcMode.CUDA), "LS1") \ .addNode("LS1", LossFunction(lossType.softMaxToCrossEntropy), "Summ") \ \ .addNode("FC3", FullyConnected(128, calcMode.CUDA), "FC4") \ .addNode("FC4", FullyConnected(10, calcMode.CUDA), "LS2") \ .addNode("LS2", LossFunction(lossType.softMaxToCrossEntropy), "Summ") \ \ .addNode("FC5", FullyConnected(128, calcMode.CUDA), "FC6") \ .addNode("FC6", FullyConnected(10, calcMode.CUDA), "LS3") \ .addNode("LS3", LossFunction(lossType.softMaxToCrossEntropy), "Summ") \ \ .addNode("Summ", LossFunction(lossType.softMaxToCrossEntropy), "Output") .............

CIFAR-10

यहां मुझे पहले से ही बैचमोन को सक्षम करना था। यह ग्रिड 1000 पुनरावृत्तियों, बैच 100 पर 50% सटीकता तक सीखता है।

यह कोड निकला

 sn::Net snet; snet.addNode("Input", sn::Input(), "C1") .addNode("C1", sn::Convolution(15, -1, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "C2") .addNode("C2", sn::Convolution(15, 0, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "P1") .addNode("P1", sn::Pooling(sn::calcMode::CUDA), "C3") .addNode("C3", sn::Convolution(25, -1, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "C4") .addNode("C4", sn::Convolution(25, 0, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "P2") .addNode("P2", sn::Pooling(sn::calcMode::CUDA), "C5") .addNode("C5", sn::Convolution(40, -1, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "C6") .addNode("C6", sn::Convolution(40, 0, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "P3") .addNode("P3", sn::Pooling(sn::calcMode::CUDA), "FC1") .addNode("FC1", sn::FullyConnected(2048, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "FC2") .addNode("FC2", sn::FullyConnected(128, sn::calcMode::CUDA, sn::batchNormType::beforeActive), "FC3") .addNode("FC3", sn::FullyConnected(10, sn::calcMode::CUDA), "LS") .addNode("LS", sn::LossFunction(sn::lossType::softMaxToCrossEntropy), "Output");

मुझे लगता है कि यह स्पष्ट है कि किसी भी चित्र वर्गों को प्रतिस्थापित किया जा सकता है।

उ० — शुद्ध तिनि

अंतिम उदाहरण। प्रदर्शन के लिए सरलीकृत देशी यू-नेट।

मुझे थोड़ा समझाइए: लेयर DC1 ... - रिवर्स कनवल्शन, लेयर्स Concat1 ... - चैनल के अलावा की लेयर्स,
Rsz1 ... - विपरीत चरण में चैनलों की संख्या पर सहमत होने के लिए उपयोग किया जाता है, क्योंकि चैनलों की राशि से त्रुटि कॉनैट परत से वापस जाती है।

C ++ कोड।

  sn::Net snet; snet.addNode("In", sn::Input(), "C1") .addNode("C1", sn::Convolution(10, -1, sn::calcMode::CUDA), "C2") .addNode("C2", sn::Convolution(10, 0, sn::calcMode::CUDA), "P1 Crop1") .addNode("Crop1", sn::Crop(sn::rect(0, 0, 487, 487)), "Rsz1") .addNode("Rsz1", sn::Resize(sn::diap(0, 10), sn::diap(0, 10)), "Conc1") .addNode("P1", sn::Pooling(sn::calcMode::CUDA), "C3") .addNode("C3", sn::Convolution(10, -1, sn::calcMode::CUDA), "C4") .addNode("C4", sn::Convolution(10, 0, sn::calcMode::CUDA), "P2 Crop2") .addNode("Crop2", sn::Crop(sn::rect(0, 0, 247, 247)), "Rsz2") .addNode("Rsz2", sn::Resize(sn::diap(0, 10), sn::diap(0, 10)), "Conc2") .addNode("P2", sn::Pooling(sn::calcMode::CUDA), "C5") .addNode("C5", sn::Convolution(10, 0, sn::calcMode::CUDA), "C6") .addNode("C6", sn::Convolution(10, 0, sn::calcMode::CUDA), "DC1") .addNode("DC1", sn::Deconvolution(10, sn::calcMode::CUDA), "Rsz3") .addNode("Rsz3", sn::Resize(sn::diap(0, 10), sn::diap(10, 20)), "Conc2") .addNode("Conc2", sn::Concat("Rsz2 Rsz3"), "C7") .addNode("C7", sn::Convolution(10, 0, sn::calcMode::CUDA), "C8") .addNode("C8", sn::Convolution(10, 0, sn::calcMode::CUDA), "DC2") .addNode("DC2", sn::Deconvolution(10, sn::calcMode::CUDA), "Rsz4") .addNode("Rsz4", sn::Resize(sn::diap(0, 10), sn::diap(10, 20)), "Conc1") .addNode("Conc1", sn::Concat("Rsz1 Rsz4"), "C9") .addNode("C9", sn::Convolution(10, 0, sn::calcMode::CUDA), "C10"); sn::Convolution convOut(1, 0, sn::calcMode::CUDA); convOut.act = sn::active::sigmoid; snet.addNode("C10", convOut, "Output");

पूर्ण कोड और चित्र यहाँ हैं ।

इस तरह से ओपन सोर्स मैथ्स।
मैंने MNIST पर सभी परतों का परीक्षण किया; TF ने त्रुटियों के मूल्यांकन के लिए मानक के रूप में कार्य किया।

आगे क्या है

लाइब्रेरी चौड़ाई में नहीं बढ़ेगी, यानी कोई ओपेकेंव, सॉकेट्स इत्यादि नहीं, ताकि फुलाया न जाए।
लाइब्रेरी इंटरफ़ेस नहीं बदलेगा / विस्तारित होगा, मैं यह बिल्कुल नहीं कहूंगा कि और कभी नहीं, लेकिन अंतिम लेकिन कम से कम नहीं।

केवल गहराई में: मैं OpenCL पर गणना करूँगा, C # के लिए इंटरफ़ेस, RNN नेटवर्क हो सकता है ...
MKL मुझे लगता है कि इसे जोड़ने का कोई मतलब नहीं है, क्योंकि नेटवर्क थोड़ा गहरा है - यह वीडियो कार्ड पर वैसे भी तेज़ है, और औसत प्रदर्शन कार्ड बिल्कुल भी कम नहीं है।

अन्य चौखटों के साथ तौल का आयात / निर्यात - पायथन के माध्यम से (अभी तक लागू नहीं)। रोडमैप होगा अगर लोगों में दिलचस्पी पैदा हो।

कृपया कोड का समर्थन कौन कर सकता है। लेकिन सीमाएं हैं ताकि वर्तमान वास्तुकला टूट न जाए।

आप अजगर को असंभवता के लिए इंटरफ़ेस का विस्तार कर सकते हैं, जैसे डॉक और उदाहरणों की आवश्यकता होती है।

पायथन से स्थापित करने के लिए:

* पाइप स्थापित करें libskynet - सीपीयू
* पाइप स्थापित करें libskynet-cu - CUDA9.2 + cuDNN7.3.1

उपयोगकर्ता गाइड ।

सॉफ्टवेयर स्वतंत्र रूप से वितरित किया जाता है, एमआईटी लाइसेंस।

आपका धन्यवाद

C ++ डेवलपर्स के लिए तंत्रिका नेटवर्क

सॉफ्टवेयर वास्तुकला

उदाहरण

MNIST

CIFAR-10

उ० — शुद्ध तिनि

More articles: