તમારી પ્રથમ ડીપ લર્નિંગ લાઇબ્રેરી માત્ર મોડેલ ચલાવવા કરતાં ઘણું વધારે કામ કરે છે. તે ગ્રેડિયન્ટ્સ (gradients), લેયર્સ (layers) અને ડેટા ફ્લો વિશે તમે કેવી રીતે વિચારો છો તેને આકાર આપે છે. જો તમે ખોટી લાઇબ્રેરી પસંદ કરશો, તો તમે ન્યુરલ નેટવર્ક ખરેખર કેવી રીતે વર્તે છે તે શીખવાને બદલે બૉઇલરપ્લેટ (boilerplate) કોડ સાથે લડવામાં અઠવાડિયા વિતાવી દેશો. જો તમે સાચી લાઇબ્રેરી પસંદ કરશો, તો ખ્યાલો આપમેળે સ્પષ્ટ થઈ જશે કારણ કે કોડ તમારા રસ્તામાં અવરોધ બનશે નહીં.
મોટાભાગના શિખનારાઓ પસંદગીને ત્રણ લાઇબ્રેરીઓ સુધી મર્યાદિત રાખે છે: Keras, PyTorch, અને TensorFlow. JAX પણ છે, પરંતુ જ્યાં સુધી તમે જાણતા ન હોવ કે 'Jacobian' શું છે, ત્યાં સુધી તમારે તેને અવગણવું જોઈએ.
"Beginner-Friendly" (શરૂઆત કરનારાઓ માટે અનુકૂળ) નો ખરેખર અર્થ શું છે
કોઈ લાઇબ્રેરી માત્ર એટલા માટે અનુકૂળ નથી હોતી કારણ કે તેનું ડોક્યુમેન્ટેશન ઘણું મોટું છે. તે ત્યારે અનુકૂળ ગણાય છે જ્યારે કોડ એવા ગણિત જેવો લાગે જે તમે ટ્યુટોરિયલમાં જોયું હોય, અને જ્યારે એરર મેસેજ (error message) C++ બેકએન્ડમાંથી સ્ટેક ટ્રેસ (stack trace) ફેંકવાને બદલે તમારી ભૂલ તરફ નિર્દેશ કરે. તમે લર્નિંગ રેટ (learning rates) અને એક્ટિવેશન ફંક્શન્સ (activation functions) વિશે વિચારવા માંગો છો, ફ્રેમવર્કના આંતરિક ભાગોમાં ઊંડે સુધી દબાયેલા ટેન્સર શેપ મિસમેચ (tensor shape mismatches) વિશે નહીં.
Keras: પરિણામો જોવા માટે અહીંથી શરૂઆત કરો
Keras એક સરળ વિચાર પર બનાવવામાં આવ્યું હતું. તમારે એક વિચારથી લઈને તાલીમબદ્ધ (trained) મોડેલ સુધી પહોંચવા માટે એટલો જ સમય લાગવો જોઈએ જેટલો કોફી પીવામાં લાગે છે. તે બેકપ્રોપેગેશન (backpropagation) અને ગ્રાફ ઓપ્ટિમાઇઝેશન (graph optimization) ની જટિલતાઓને એક સ્વચ્છ API પાછળ છુપાવે છે, જેથી સંપૂર્ણ રીતે કાર્યરત ઇમેજ ક્લાસિફાયર (image classifier) ઘણીવાર પાંક્કી-બાર Python લાઇન્સમાં સમાઈ જાય છે.
તમે Sequential ઓબ્જેક્ટની અંદર લેયર્સ ગોઠવીને મોડેલ વ્યાખ્યાયિત કરો છો, ઓપ્ટિમાઇઝર અને લોસ ફંક્શન (loss function) જોડવા માટે model.compile() કોલ કરો છો, અને પછી તાલીમ આપવા માટે model.fit() કોલ કરો છો. તેની સિન્ટેક્સ (syntax) એક ચેકલિસ્ટ જેવી લાગે છે. ઇનપુટ શેપ? થઈ ગયું. ડેન્સ લેયર (Dense layer)? થઈ ગયું. ટ્રેનિંગ લૂપ? સંભાળી લેવામાં આવ્યું. આ તમને શરૂઆતમાં ખરેખર મહત્વની બાબતો સાથે પ્રયોગ કરવા દે છે. શું બીજું લેયર ઉમેરવાથી મદદ મળે છે? શું તમારે ReLU ને બદલે sigmoid વાપરવું જોઈએ? જ્યારે તમે બેચ સાઈઝ (batch size) બદલો ત્યારે શું થાય છે?
જો તમારો ધ્યેય કન્ફિગરેશન ફાઇલોમાં ડૂબ્યા વગર લેયર્સ અને ઓપ્ટિમાઇઝર્સ શું કરે છે તે શીખવાનો હોય, તો Keras તે અવરોધ દૂર કરે છે. તમે પેકેજ ઇન્સ્ટોલ કર્યાના એક કલાકની અંદર વાસ્તવિક છબીઓ પર કન્વોલ્યુશનલ નેટવર્ક (convolutional network) ચલાવી શકો છો. કારણ કે Keras ડિફોલ્ટ રીતે TensorFlow ની ઉપર કામ કરે છે, તેથી તમને હાઇ-લેવલ API છોડ્યા વિના પ્રોડક્શન-ગ્રેડ ડેટા પાઇપલાઇન્સનો ઉપયોગ કરવાની સુવિધા પણ મળે છે.
તેની મર્યાદાઓ ત્યારે દેખાય છે જ્યારે તમે નિર્ધારિત માર્ગની બહાર નીકળો છો. જો તમારે ઇન્ટરમીડિયેટ એક્ટિવેશન (intermediate activations) પર આધારિત કસ્ટમ લોસ ફંક્શન લખવું હોય, અથવા જો તમે તાલીમ દરમિયાન બેકવર્ડ પાસ (backward pass) બદલવા માંગતા હોવ, તો Keras પ્રતિબંધિત લાગી શકે છે. તેમાં બહાર નીકળવાના રસ્તાઓ (escape hatches) છે, પરંતુ તેનો ઉપયોગ કરવાનો અર્થ ઘણીવાર સીધો ફ્રેમવર્ક કોડમાં ઉતરવું એવો થાય છે. કસ્ટમ રિસર્ચ લોજિક માટે, આ મર્યાદા વાસ્તવિક છે.
PyTorch: તેની આંતરિક કાર્યપદ્ધતિ જોઈને શીખો
PyTorch ન્યુરલ નેટવર્કને એક સામાન્ય Python પ્રોગ્રામ તરીકે ગણે છે. તમે torch.nn.Module ને સબક્લાસિંગ (subclassing) કરીને મોડેલ વ્યાખ્યાયિત કરો છો. ફોરવર્ડ પાસ (forward pass) એ માત્ર એક Python મેથડ છે જે વર્ણવે છે કે ઇનપુટ કેવી રીતે આઉટપુટ બને છે. તમે loss.backward() કોલ કરો છો, અને PyTorch તરત જ ગ્રેડિયન્ટ્સની ગણતરી કરે છે.
આ એટલા માટે થાય છે કારણ કે PyTorch તેનું કમ્પ્યુટેશન ગ્રાફ (computation graph) ડાયનેમિકલી બનાવે છે. કેટલાક ફ્રેમવર્ક એવી માંગ કરે છે કે તમે કોઈપણ ડેટાના ઉપયોગ પહેલાં આખું મોડેલ સ્ટ્રક્ચર વ્યાખ્યાયિત કરો. PyTorch ત્યાં સુધી રાહ જુએ છે જ્યાં સુધી તમે ખરેખર નેટવર્ક દ્વારા બેચ પસાર ન કરો. જો બેચ વચ્ચે તમારો ઇનપુટ સાઈઝ બદલાય, અથવા જો તમે શેપ મિસમેચને ડિબગ કરવા માટે ફોરવર્ડ પાસની વચ્ચે ટેન્સર પ્રિન્ટ કરવા માંગતા હોવ, તો ફ્રેમવર્ક કોઈ ફરિયાદ કરતું નથી. તમે સ્ટાન્ડર્ડ ડિબગરમાં (debugger) ઉપયોગ કરી શકો છો. તમે તમારા મોડેલ ક્લાસની અંદર print() સ્ટેટમેન્ટ્સ મૂકી શકો છો. જ્યારે દરેક ટેન્સર ડાયમેન્શન એક કોયડા જેવું લાગે છે, ત્યારે તે સરળતા મહત્વની છે, કારણ કે તે ડિબગિંગને સામાન્ય પ્રોગ્રામિંગ જેવું બનાવે છે.
જો તમે સમજવા માંગતા હોવ કે તાલીમ ખરેખર કેવી રીતે કામ કરે છે—કેવી રીતે ફોરવર્ડ પાસ આગાહીઓ (predictions) કરે છે, કેવી રીતે બેકવર્ડ પાસ ભૂલ (error) વહેંચે છે, કેવી રીતે ઓપ્ટિમાઇઝર વજન (weights) અપડેટ કરે છે—તો PyTorch તમને તેની આંતરિક કાર્યપદ્ધતિ જોવા માટે મજબૂર કરે છે. તે પારદર્શિતાને કારણે તે હાલમાં રિસર્ચમાં અગ્રેસર છે અને મોટાભાગની નવી AI જોબ પોસ્ટિંગમાં જોવા મળે છે. જ્યારે તમે arXiv પર કોઈ પેપર વાંચો છો, ત્યારે શક્યતા વધુ છે કે તેનું સત્તાવાર અમલીકરણ (implementation) PyTorch માં લખાયેલું હોય.
TensorFlow: મોડેલ ક્યાં રહે છે તેના વિશે વિચારો
TensorFlow ની છાપ એવી હતી કે તે ખૂબ જ લાંબુ (verbose) અને શીખવામાં અઘરું હતું. જ્યારે Keras તેનું સત્તાવાર હાઇ-લેવલ API બન્યું ત્યારે તેમાં ઘણો ફેરફાર આવ્યો. આધુનિક વર્ઝનમાં, જ્યારે તમે Keras ઇમ્પોર્ટ કરો છો, ત્યારે તમે સામાન્ય રીતે TensorFlow પર જ ચલાવી રહ્યા હોવ છો, પછી ભલે તમે તે નોંધ્યું હોય કે નહીં. પરંતુ મોડેલ તાલીમ પામે તે પછી શું થાય છે તેના કારણે TensorFlow હજુ પણ એક અલગ પસંદગી તરીકે મહત્વ ધરાવે છે.
આ ઇકોસિસ્ટમ ડિપ્લોયમેન્ટ માટે બનાવવામાં આવી છે. TensorFlow Lite મોડેલ્સને કોમ્પ્રેસ કરે છે જેથી તેને ફોન, માઇક્રોકન્ટ્રોલર્સ અને મર્યાદિત મેમરી ધરાવતા ઇન્ડસ્ટ્રિયલ સેન્સર્સ પર ચલાવી શકાય. TensorFlow.js ડેટાને સર્વર પર મોકલ્યા વિના સીધું બ્રાઉઝરની અંદર ઇન્ફરન્સ (inference) ચલાવે છે. TensorFlow Serving મોટા પ્રોડક્શન એન્વાયરમેન્ટ્સમાં મોડેલ વર્ઝનિંગ અને બેચ પ્રેડિક્શનનું સંચાલન કરે છે.
જ્યારે તમારા પ્રોજેક્ટમાં કઠિન ભૌતિક