આર્ટિફિશિયલ ઇન્ટેલિજન્સ (AI) એ તાજેતરના વર્ષોમાં નોંધપાત્ર પ્રમાણમાં લોકપ્રિયતા મેળવી છે.
જો તમે સામાન્ય રીતે સોફ્ટવેર એન્જિનિયર, કોમ્પ્યુટર સાયન્ટિસ્ટ અથવા ડેટા સાયન્સના ઉત્સાહી છો, તો તમે કદાચ આ ક્ષેત્ર દ્વારા પૂરી પાડવામાં આવેલ ઇમેજ પ્રોસેસિંગ, પેટર્ન રેકગ્નિશન અને ઑબ્જેક્ટ ડિટેક્શનની અદ્ભુત એપ્લિકેશનોથી રસપ્રદ છો.
AI નું સૌથી મહત્વપૂર્ણ સબફિલ્ડ જેના વિશે તમે કદાચ સાંભળ્યું હશે તે ડીપ લર્નિંગ છે. આ ક્ષેત્ર શક્તિશાળી અલ્ગોરિધમ્સ (કમ્પ્યુટર પ્રોગ્રામ સૂચનાઓ) પર ધ્યાન કેન્દ્રિત કરે છે જે માનવ મગજની કાર્યક્ષમતા તરીકે ઓળખાય છે ન્યુરલ નેટવર્ક્સ.
આ લેખમાં, અમે ન્યુરલ નેટવર્ક્સની વિભાવના પર જઈશું અને આ મોડલ્સનો ઉપયોગ કરીને કેવી રીતે બિલ્ડ, કમ્પાઇલ, ફિટ અને મૂલ્યાંકન કરવું. પાયથોન.
ન્યુરલ નેટવર્ક્સ
ન્યુરલ નેટવર્ક્સ, અથવા NNs, માનવ મગજની જૈવિક પ્રવૃત્તિ પછી મોડલ કરેલ એલ્ગોરિધમ્સની શ્રેણી છે. ન્યુરલ નેટવર્કમાં ગાંઠો હોય છે, જેને ન્યુરોન્સ પણ કહેવાય છે.
વર્ટિકલ નોડ્સનો સંગ્રહ સ્તરો તરીકે ઓળખાય છે. મોડેલમાં એક ઇનપુટ, એક આઉટપુટ અને સંખ્યાબંધ છુપાયેલા સ્તરોનો સમાવેશ થાય છે. દરેક સ્તરમાં ગાંઠો હોય છે, જેને ન્યુરોન્સ પણ કહેવાય છે, જ્યાં ગણતરીઓ થાય છે.
નીચેના રેખાકૃતિમાં, વર્તુળો ગાંઠોનું પ્રતિનિધિત્વ કરે છે અને ગાંઠોનો ઊભી સંગ્રહ સ્તરોનું પ્રતિનિધિત્વ કરે છે. આ મોડેલમાં ત્રણ સ્તરો છે.
નીચે બતાવ્યા પ્રમાણે એક સ્તરના ગાંઠો ટ્રાન્સમિશન લાઇન દ્વારા બીજા સ્તર સાથે જોડાયેલા છે.
અમારા ડેટાસેટમાં લેબલ કરેલા ડેટાનો સમાવેશ થાય છે. આનો અર્થ એ છે કે દરેક ડેટા એન્ટિટીને ચોક્કસ નામ મૂલ્ય અસાઇન કરવામાં આવ્યું છે.
તેથી પ્રાણી વર્ગીકરણ ડેટાસેટ માટે અમારી પાસે અમારા ડેટા તરીકે બિલાડીઓ અને કૂતરાઓની છબીઓ હશે, જેમાં અમારા લેબલ તરીકે 'બિલાડી' અને 'કૂતરો' હશે.
એ નોંધવું અગત્યનું છે કે લેબલોને અમારા મોડેલ માટે સંખ્યાત્મક મૂલ્યોમાં રૂપાંતરિત કરવાની જરૂર છે જેથી કરીને તે સમજવામાં આવે, તેથી અમારા પ્રાણી લેબલ્સ બિલાડી માટે '0' અને કૂતરા માટે '1' બને છે. ડેટા અને લેબલ્સ બંને મોડેલમાંથી પસાર થાય છે.
લર્નિંગ
ડેટા એક સમયે મોડેલ એક એન્ટિટીને આપવામાં આવે છે. આ ડેટા ભાગોમાં વિભાજિત થાય છે અને મોડેલના દરેક નોડમાંથી પસાર થાય છે. ગાંઠો આ હિસ્સા પર ગાણિતિક ક્રિયાઓ કરે છે.
તમારે આ ટ્યુટોરીયલ માટે ગાણિતિક કાર્યો અથવા ગણતરીઓ જાણવાની જરૂર નથી, પરંતુ આ મોડેલો કેવી રીતે કાર્ય કરે છે તેનો સામાન્ય ખ્યાલ હોવો જરૂરી છે. એક સ્તરમાં ગણતરીઓની શ્રેણી પછી, ડેટાને આગલા સ્તર પર પસાર કરવામાં આવે છે અને તેથી વધુ.
એકવાર પૂર્ણ થઈ ગયા પછી, અમારું મોડેલ આઉટપુટ સ્તર પર ડેટા લેબલની આગાહી કરે છે (ઉદાહરણ તરીકે, પ્રાણી વર્ગીકરણની સમસ્યામાં અમને બિલાડી માટે '0' આગાહી મળે છે).
મોડેલ પછી આ અનુમાનિત મૂલ્યની વાસ્તવિક લેબલ મૂલ્ય સાથે સરખામણી કરવા આગળ વધે છે.
જો મૂલ્યો મેળ ખાય છે, તો અમારું મોડેલ આગલું ઇનપુટ લેશે પરંતુ જો મૂલ્યો અલગ હશે તો મોડેલ બંને મૂલ્યો વચ્ચેના તફાવતની ગણતરી કરશે, જેને નુકશાન કહેવાય છે, અને આગલી વખતે મેચિંગ લેબલ્સ બનાવવા માટે નોડ ગણતરીઓને સમાયોજિત કરશે.
ડીપ લર્નિંગ ફ્રેમવર્ક
કોડમાં ન્યુરલ નેટવર્ક બનાવવા માટે, આપણે આયાત કરવાની જરૂર છે ડીપ લર્નિંગ ફ્રેમવર્ક અમારા સંકલિત વિકાસ પર્યાવરણ (IDE) નો ઉપયોગ કરીને પુસ્તકાલયો તરીકે ઓળખાય છે.
આ ફ્રેમવર્ક પૂર્વ-લેખિત કાર્યોનો સંગ્રહ છે જે અમને આ ટ્યુટોરીયલમાં મદદ કરશે. અમે અમારા મોડલને બનાવવા માટે કેરાસ ફ્રેમવર્કનો ઉપયોગ કરીશું.
કેરાસ એ પાયથોન લાઇબ્રેરી છે જે ડીપ લર્નિંગ અને આર્ટિફિશિયલ ઇન્ટેલિજન્સ બેકએન્ડનો ઉપયોગ કરે છે. ટેન્સરફ્લો સરળ સિક્વન્શિયલ મોડલના રૂપમાં NN બનાવવા માટે.
કેરાસ તેના પોતાના પહેલાથી અસ્તિત્વમાં રહેલા મોડેલો સાથે પણ આવે છે જેનો ઉપયોગ પણ કરી શકાય છે. આ ટ્યુટોરીયલ માટે, આપણે Keras નો ઉપયોગ કરીને આપણું પોતાનું મોડેલ બનાવીશું.
તમે આ ડીપ લર્નિંગ ફ્રેમવર્ક વિશે વધુ શીખી શકો છો કેરાસ વેબસાઇટ.
ન્યુરલ નેટવર્ક બનાવવું (ટ્યુટોરીયલ)
ચાલો Python નો ઉપયોગ કરીને ન્યુરલ નેટવર્ક બનાવવા તરફ આગળ વધીએ.
સમસ્યા નિવેદન
ન્યુરલ નેટવર્ક એ એઆઈ-આધારિત સમસ્યાઓના ઉકેલનો એક પ્રકાર છે. આ ટ્યુટોરીયલ માટે આપણે Pima Indians ડાયાબિટીસ ડેટા પર જઈશું, જે ઉપલબ્ધ છે અહીં.
આઈ.સી.યુ. મશીન લર્નિંગે આ ડેટાસેટનું સંકલન કર્યું છે અને ભારતીય દર્દીઓનો મેડિકલ રેકોર્ડ ધરાવે છે. અમારા મૉડેલમાં દર્દીને 5 વર્ષની અંદર ડાયાબિટીસની શરૂઆત થઈ છે કે નહીં તેની આગાહી કરવાની હોય છે.
ડેટાસેટ લોડ કરી રહ્યું છે
અમારું ડેટાસેટ 'diabetes.csv' નામની એક CSV ફાઇલ છે જેને Microsoft Excel નો ઉપયોગ કરીને સરળતાથી ચાલાકી કરી શકાય છે.
અમારું મોડેલ બનાવતા પહેલા, અમારે અમારા ડેટાસેટને આયાત કરવાની જરૂર છે. નીચેના કોડનો ઉપયોગ કરીને તમે આ કરી શકો છો:
પીડી તરીકે આયાત પાંડા
ડેટા = pd.read_csv('diabetes.csv')
x = data.drop("પરિણામ")
y = ડેટા[“પરિણામ”]
અહીં આપણે ઉપયોગ કરી રહ્યા છીએ પાંડા અમારી CSV ફાઇલ ડેટાની હેરફેર કરવા માટે સક્ષમ થવા માટે લાઇબ્રેરી, read_csv() એ પાંડાનું બિલ્ટ-ઇન ફંક્શન છે જે અમને 'ડેટા' નામના ચલમાં અમારી ફાઇલમાંના મૂલ્યોને સંગ્રહિત કરવાની મંજૂરી આપે છે.
ચલ x પરિણામ (લેબલ્સ) ડેટા વિના આપણો ડેટાસેટ ધરાવે છે. અમે data.drop() ફંક્શન વડે આ હાંસલ કરીએ છીએ જે x માટેના લેબલ્સ દૂર કરે છે, જ્યારે y માત્ર પરિણામ (લેબલ) ડેટા ધરાવે છે.
બિલ્ડીંગ સિક્વન્શિયલ મોડલ
પગલું 1: પુસ્તકાલયોની આયાત કરવી
સૌપ્રથમ, અમારે અમારા મોડલ માટે જરૂરી અમુક પરિમાણો સાથે ટેન્સરફ્લો અને કેરાસ આયાત કરવાની જરૂર છે. નીચેનો કોડ અમને આ કરવાની મંજૂરી આપે છે:
tf તરીકે ટેન્સરફ્લો આયાત કરો
ટેન્સરફ્લો આયાત કેરામાંથી
tensorflow.keras.models માંથી ક્રમિક આયાત કરો
tensorflow.keras.layers માંથી આયાત સક્રિયકરણ, ગાઢ
tensorflow.keras.optimizers માંથી આદમ આયાત કરો
tensorflow.keras.metrics માંથી categorical_crossentropy આયાત કરો
અમારા મોડલ માટે અમે ગાઢ સ્તરો આયાત કરી રહ્યા છીએ. આ સંપૂર્ણપણે જોડાયેલા સ્તરો છે; એટલે કે, લેયરમાં દરેક નોડ બીજા લેયરમાં બીજા નોડ સાથે સંપૂર્ણ રીતે જોડાયેલ છે.
અમે એક આયાત પણ કરી રહ્યા છીએ સક્રિયકરણ નોડ્સ પર મોકલવામાં આવેલ ડેટાને માપવા માટે જરૂરી કાર્ય. ઑપ્ટિમાઇઝર્સ નુકસાન ઘટાડવા માટે પણ આયાત કરવામાં આવી છે.
એડમ એક પ્રખ્યાત ઑપ્ટિમાઇઝર છે જે અમારા મોડલ અપડેટ નોડ ગણતરીઓને વધુ કાર્યક્ષમ રીતે બનાવે છે. વર્ગીકૃત_ક્રોસેન્ટ્રોપી જે છે નુકશાન કાર્યનો પ્રકાર (વાસ્તવિક અને અનુમાનિત લેબલ મૂલ્યો વચ્ચેના તફાવતની ગણતરી કરે છે) જેનો આપણે ઉપયોગ કરીશું.
પગલું 2: અમારું મોડેલ ડિઝાઇન કરવું
હું જે મોડેલ બનાવી રહ્યો છું તેમાં એક ઇનપુટ (16 એકમો સાથે), એક છુપાયેલ (32 એકમો સાથે) અને એક આઉટપુટ (2 એકમો સાથે) સ્તર છે. આ સંખ્યાઓ નિશ્ચિત નથી અને આપેલ સમસ્યા પર સંપૂર્ણપણે નિર્ભર રહેશે.
એકમો અને સ્તરોની યોગ્ય સંખ્યા સેટ કરવી એ એક પ્રક્રિયા છે જેને પ્રેક્ટિસ દ્વારા ઓવરટાઇમ સુધારી શકાય છે. સક્રિયકરણ એ સ્કેલિંગના પ્રકારને અનુરૂપ છે જે અમે અમારા ડેટાને નોડમાંથી પસાર કરતા પહેલા પરફોર્મ કરીશું.
Relu અને Softmax આ કાર્ય માટે જાણીતા સક્રિયકરણ કાર્યો છે.
મોડલ = ક્રમિક([
ગાઢ(એકમો = 16, ઇનપુટ_આકાર = (1,), સક્રિયકરણ = 'રેલુ'),
ગાઢ (એકમો = 32, સક્રિયકરણ = 'રેલુ'),
ગાઢ (એકમો = 2, સક્રિયકરણ = 'સોફ્ટમેક્સ')
])
મોડેલનો સારાંશ કેવો હોવો જોઈએ તે અહીં છે:
મોડેલની તાલીમ
અમારા મૉડલને બે પગલાંમાં તાલીમ આપવામાં આવશે, પહેલું મૉડલનું સંકલન કરવું (મૉડલને એકસાથે મૂકવું) અને પછીનું મોડલને આપેલ ડેટાસેટ પર ફિટ કરવું.
આ model.compile() ફંક્શન અને model.fit() ફંક્શનનો ઉપયોગ કરીને કરી શકાય છે.
model.compile(ઑપ્ટિમાઇઝર = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', metrics = ['ચોક્કસતા'])
model.fit(x, y, epochs = 30, batch_size = 10)
'ચોક્કસતા' મેટ્રિકનો ઉલ્લેખ કરવાથી અમને તાલીમ દરમિયાન અમારા મોડલની ચોકસાઈનું અવલોકન કરવાની મંજૂરી મળે છે.
અમારા લેબલ્સ 1 અને 0 ના સ્વરૂપમાં હોવાથી, અમે વાસ્તવિક અને અનુમાનિત લેબલ્સ વચ્ચેના તફાવતની ગણતરી કરવા માટે દ્વિસંગી નુકશાન કાર્યનો ઉપયોગ કરીશું.
ડેટાસેટને 10 (બેચ_સાઇઝ) ના બેચમાં પણ વિભાજિત કરવામાં આવી રહ્યું છે અને 30 વખત (યુગ) મોડલમાંથી પસાર થશે. આપેલ ડેટાસેટ માટે, x એ ડેટા હશે અને y એ ડેટાને અનુરૂપ લેબલ્સ હશે.
અનુમાનોનો ઉપયોગ કરીને પરીક્ષણ મોડેલ
અમારા મોડલનું મૂલ્યાંકન કરવા માટે, અમે predict() ફંક્શનનો ઉપયોગ કરીને ટેસ્ટ ડેટા પર અનુમાનો બનાવીએ છીએ.
આગાહીઓ = મોડેલ.અનુમાન(x)
અને તે છે!
તમને હવે સારી સમજ હોવી જોઈએ ડીપ લર્નિંગ એપ્લિકેશન, ન્યુરલ નેટવર્ક્સ, તેઓ સામાન્ય રીતે કેવી રીતે કાર્ય કરે છે અને પાયથોન કોડમાં મોડેલ કેવી રીતે બનાવવું, તાલીમ અને પરીક્ષણ કરવું.
હું આશા રાખું છું કે આ ટ્યુટોરીયલ તમને તમારા પોતાના ડીપ લર્નિંગ મોડલ્સ બનાવવા અને જમાવવા માટે કિકસ્ટાર્ટ આપશે.
જો લેખ મદદરૂપ હતો તો અમને ટિપ્પણીઓમાં જણાવો.
એક જવાબ છોડો