பைத்தானுடன் ஆழமான கற்றல்: ஆழ்ந்த கற்றலுக்கான தொடக்க வழிகாட்டி

இந்த கட்டுரை பைத்தானுடன் ஆழமான கற்றல் பற்றிய விரிவான மற்றும் விரிவான அறிவை உங்களுக்கு வழங்கும் மற்றும் இது அன்றாட வாழ்க்கையில் எவ்வளவு பயனுள்ளதாக இருக்கும்.

என்பது 2018-19 ஆம் ஆண்டின் வெப்பமான தலைப்புகளில் ஒன்றாகும் மற்றும் ஒரு நல்ல காரணத்திற்காக. தொழில்துறையில் பல முன்னேற்றங்கள் ஏற்பட்டுள்ளன, அதில் இயந்திரங்கள் அல்லது கணினி நிரல்கள் உண்மையில் மனிதர்களை மாற்றும் நேரம் வந்துவிட்டது. இது பைத்தானுடன் ஆழமான கற்றல் ஆழமான கற்றல் என்றால் என்ன, இந்த மாற்றம் எவ்வாறு சாத்தியமானது என்பதைப் புரிந்துகொள்ள கட்டுரை உங்களுக்கு உதவும். இந்த கட்டுரையில் பின்வரும் தலைப்புகளை நான் உள்ளடக்குவேன்:

தரவு அறிவியல் மற்றும் இது கூறுகள்

சரி, தரவு அறிவியல் என்பது பல ஆண்டுகளாக இருந்த ஒன்று. தரவு அறிவியல் வெவ்வேறு நுட்பங்கள் மற்றும் வழிமுறைகளைப் பயன்படுத்தி தரவிலிருந்து அறிவைப் பிரித்தெடுப்பது.





AI காலவரிசை - பைத்தானுடன் ஆழமான கற்றல் - எடுரேகா

மனித நடத்தைகளைப் பிரதிபலிக்கும் இயந்திரங்களை இயக்கும் ஒரு நுட்பமாகும். AI க்குப் பின்னால் உள்ள யோசனை மிகவும் எளிமையானது, ஆனால் கவர்ச்சிகரமானதாகும், இது புத்திசாலித்தனமான இயந்திரங்களை அதன் சொந்த முடிவுகளை எடுக்க முடியும். கணினிகள் மனித மூளையின் சக்தியுடன் ஒருபோதும் பொருந்தாது என்று பல ஆண்டுகளாக கருதப்பட்டது.



சரி, பின்னர் எங்களிடம் போதுமான தரவு மற்றும் கணக்கீட்டு சக்தி இல்லை, ஆனால் இப்போது பெரிய தரவு ஜி.பீ.யுகளின் வருகையுடன், செயற்கை நுண்ணறிவு சாத்தியமாகும்.

AI நுட்பத்தின் துணைக்குழு ஆகும், இது அனுபவங்களை மேம்படுத்த இயந்திரங்களை இயக்க புள்ளிவிவர முறைகளைப் பயன்படுத்துகிறது.



ஆழமான கற்றல் எம்.எல் இன் துணைக்குழு ஆகும், இது பல அடுக்கு நரம்பியல் வலையமைப்பின் கணக்கீட்டை சாத்தியமாக்குகிறது. இது மனிதனைப் போன்ற முடிவெடுப்பதை உருவகப்படுத்த நியூரல் நெட்வொர்க்குகளைப் பயன்படுத்துகிறது.

ஆழமான கற்றலின் தேவை

செயற்கை நுண்ணறிவை நோக்கி ஒரு படி இயந்திர கற்றல். இயந்திர கற்றல் என்பது AI இன் துணைக்குழு ஆகும், மேலும் இயந்திரங்களுக்கு தரவுக்கான அணுகல் வழங்கப்பட வேண்டும் என்ற கருத்தை அடிப்படையாகக் கொண்டது, மேலும் அவற்றைக் கற்றுக் கொள்ளவும் ஆராயவும் விடப்பட வேண்டும். பெரிய தரவுத் தொகுப்புகளிலிருந்து வடிவங்களை பிரித்தெடுப்பதை இது கையாள்கிறது. பெரிய தரவு தொகுப்புகளைக் கையாள்வது ஒரு சிக்கலாக இருக்கவில்லை.

  • இயந்திர கற்றல் வழிமுறைகள் உயர் பரிமாண தரவைக் கையாள முடியாது - எங்களிடம் ஏராளமான உள்ளீடுகள் மற்றும் வெளியீடுகள் உள்ளன: ஆயிரக்கணக்கான பரிமாணங்கள். அத்தகைய வகை தரவைக் கையாளுதல் மற்றும் செயலாக்குவது மிகவும் சிக்கலானதாகவும், வள முழுமையானதாகவும் மாறும். இது என அழைக்கப்படுகிறது பரிமாணத்தின் சாபம்.

  • எதிர்கொண்ட மற்றொரு சவால், குறிப்பிட பிரித்தெடுக்க வேண்டிய அம்சங்கள் . முடிவை முன்னறிவிப்பதிலும், சிறந்த துல்லியத்தை அடைவதிலும் இது முக்கிய பங்கு வகிக்கிறது. எனவே, அம்சம் பிரித்தெடுத்தல் இல்லாமல், புரோகிராமருக்கான சவால் அதிகரிக்கிறது, ஏனெனில் வழிமுறையின் செயல்திறன் புரோகிராமர் எவ்வளவு நுண்ணறிவுடையது என்பதைப் பொறுத்தது.

இப்போது, ​​ஆழமான கற்றல் மீட்புக்கு வந்தது இங்குதான். ஆழமான கற்றல் உயர் பரிமாண தரவைக் கையாளும் திறன் கொண்டது மற்றும் திறமையாகவும் உள்ளது சரியான அம்சங்களில் கவனம் செலுத்துகிறது சொந்தமாக.

ஆழமான கற்றல் என்றால் என்ன?

ஆழமான கற்றல் என்பது இயந்திர கற்றலின் துணைக்குழு ஆகும், அங்கு ஒத்த இயந்திர கற்றல் வழிமுறைகள் பயிற்சிக்கு பயன்படுத்தப்படுகின்றன முன்னாள் மதிப்பெண் வரை செயல்படாத சந்தர்ப்பங்களில் சிறந்த துல்லியத்தை அடைய. அடிப்படையில், ஆழ்ந்த கற்றல் நமது மூளை செயல்படும் முறையைப் பிரதிபலிக்கிறது அதாவது இது அனுபவத்திலிருந்து கற்றுக்கொள்கிறது.

உங்களுக்குத் தெரியும்,எங்கள் மூளை ஆனது பில்லியன் கணக்கான நியூரான்கள் இது அற்புதமான விஷயங்களைச் செய்ய எங்களுக்கு அனுமதிக்கிறது. ஒரு சிறு குழந்தையின் மூளை கூட சிக்கலான சிக்கல்களைத் தீர்க்கும் திறன் கொண்டது, அவை சூப்பர்-கம்ப்யூட்டர்களைப் பயன்படுத்துவதைக் கூட தீர்க்க மிகவும் கடினம். எனவே, ஒரு நிரலில் அதே செயல்பாட்டை எவ்வாறு அடையலாம்? இப்போது, ​​இங்குதான் நாம் புரிந்துகொள்கிறோம் செயற்கை நியூரான் (பெர்செப்டிரான்) மற்றும் செயற்கை நரம்பியல் வலையமைப்பு.

பெர்செப்டிரான் மற்றும் செயற்கை நரம்பியல் நெட்வொர்க்குகள்

ஆழ்ந்த கற்றல் மூளையின் அடிப்படை அலகு மூளை செல் அல்லது நியூரான் என அழைக்கப்படுகிறது. இப்போது, ​​உயிரியல் நியூரான்களின் செயல்பாட்டைப் புரிந்துகொள்வோம், இந்த செயல்பாட்டை நாம் எவ்வாறு கருதுகிறோம் அல்லது ஒரு செயற்கை நியூரானைப் பிரதிபலிக்கிறோம்.

  • டென்ட்ரைட்: பிற நியூரான்களிலிருந்து சமிக்ஞைகளைப் பெறுகிறது
  • செல் உடல்: அனைத்து உள்ளீடுகளையும் தொகுக்கிறது
  • ஆக்சன்: இது மற்ற கலங்களுக்கு சமிக்ஞைகளை அனுப்ப பயன்படுகிறது

ஒரு செயற்கை நியூரான் அல்லது ஒரு பெர்செப்டிரான் பைனரி வகைப்பாட்டிற்கு பயன்படுத்தப்படும் ஒரு நேரியல் மாதிரி. இது ஒரு நியூரானை மாதிரியாகக் கொண்டுள்ளது, இது உள்ளீடுகளின் தொகுப்பைக் கொண்டுள்ளது, ஒவ்வொன்றிற்கும் ஒரு குறிப்பிட்ட எடை வழங்கப்படுகிறது. நியூரான் இவற்றில் சில செயல்பாட்டைக் கணக்கிடுகிறது எடையுள்ள உள்ளீடுகள் மற்றும் வெளியீட்டை வழங்குகிறது.

இது n உள்ளீடுகளைப் பெறுகிறது (ஒவ்வொரு அம்சத்திற்கும் பொருந்தும்). அது அந்த உள்ளீடுகளைச் சுருக்கி, ஒரு உருமாற்றத்தைப் பயன்படுத்துகிறது மற்றும் வெளியீட்டை உருவாக்குகிறது. இது இரண்டு செயல்பாடுகளைக் கொண்டுள்ளது:

  • சுருக்கம்
  • மாற்றம் (செயல்படுத்தல்)

எடை ஒரு குறிப்பிட்ட உள்ளீட்டின் செயல்திறனைக் காட்டுகிறது. உள்ளீட்டின் எடை அதிகமாக, அது நரம்பியல் வலையமைப்பில் தாக்கத்தை ஏற்படுத்தும் . மறுபுறம், சார்பு ஒரு கூடுதல் அளவுரு பெர்செப்டிரானில், நியூரானுக்கு உள்ளீடுகளின் எடையுள்ள தொகையுடன் வெளியீட்டை சரிசெய்யப் பயன்படுகிறது, இது கொடுக்கப்பட்ட தரவுகளுக்கு மிகவும் பொருத்தமாக இருக்கும் வகையில் மாதிரிக்கு உதவுகிறது.

செயல்படுத்தும் செயல்பாடுகள் உள்ளீடுகளை வெளியீடுகளாக மொழிபெயர்க்கிறது. இது ஒரு வெளியீட்டை உருவாக்க ஒரு வாசலைப் பயன்படுத்துகிறது. செயல்படுத்தும் செயல்பாடுகளாகப் பயன்படுத்தப்படும் பல செயல்பாடுகள் உள்ளன:

  • நேரியல் அல்லது அடையாளம்
  • அலகு அல்லது பைனரி படி
  • சிக்மாய்டு அல்லது லாஜிஸ்டிக்
  • தன்
  • ரெலு
  • சாஃப்ட்மேக்ஸ்

சரி. பெர்செப்டிரான் சிக்கலை தீர்க்கிறது என்று நீங்கள் நினைத்தால், நீங்கள் தவறு செய்கிறீர்கள். இரண்டு பெரிய சிக்கல்கள் இருந்தன:

  • ஒற்றை அடுக்கு பெர்செப்டிரான்கள் நேரியல் அல்லாத பிரிக்கக்கூடிய தரவு புள்ளிகளை வகைப்படுத்த முடியாது .
  • சிக்கலான சிக்கல்கள், இதில் அடங்கும் அளவுருக்கள் நிறைய ஒற்றை அடுக்கு பெர்செப்டிரான்களால் தீர்க்க முடியாது.

இங்குள்ள எடுத்துக்காட்டு மற்றும் சந்தைப்படுத்தல் குழுவின் முடிவை எடுக்க சம்பந்தப்பட்ட அளவுருக்களின் சிக்கலைக் கவனியுங்கள்.

ஒரு நியூரான், பல உள்ளீடுகளை எடுக்க முடியாது, அதனால்தான் இந்த சிக்கலை தீர்க்க ஒன்றுக்கு மேற்பட்ட நியூரான்கள் பயன்படுத்தப்படும். நரம்பியல் நெட்வொர்க் உண்மையில் ஒரு பெர்செப்டிரான்களின் கலவை, வெவ்வேறு வழிகளில் இணைக்கப்பட்டுள்ளது மற்றும் வெவ்வேறு செயல்படுத்தும் செயல்பாடுகளில் இயங்குகிறது.

  • உள்ளீட்டு முனைகள் வெளி உலகத்திலிருந்து நெட்வொர்க்கிற்கு தகவல்களை வழங்குதல் மற்றும் அவை ஒன்றாக “உள்ளீட்டு அடுக்கு” ​​என குறிப்பிடப்படுகின்றன.
  • மறைக்கப்பட்ட முனைகள் கணக்கீடுகளைச் செய்து உள்ளீட்டு முனைகளிலிருந்து வெளியீட்டு முனைகளுக்கு தகவல்களை மாற்றவும். மறைக்கப்பட்ட முனைகளின் தொகுப்பு “மறைக்கப்பட்ட அடுக்கு” ​​ஐ உருவாக்குகிறது.
  • வெளியீட்டு முனைகள் கூட்டாக “வெளியீட்டு அடுக்கு” ​​என்று குறிப்பிடப்படுகின்றன, மேலும் அவை கணக்கீடுகள் மற்றும் பிணையத்திலிருந்து தகவல்களை வெளி உலகிற்கு மாற்றுவதற்கு பொறுப்பாகும்.

ஒரு பெர்செப்டிரான் எவ்வாறு செயல்படுகிறது, சம்பந்தப்பட்ட வெவ்வேறு அளவுருக்கள் மற்றும் ஒரு நியூரல் நெட்வொர்க்கின் வெவ்வேறு அடுக்குகள் குறித்து இப்போது உங்களுக்கு ஒரு யோசனை உள்ளது, பைதான் வலைப்பதிவுடன் இந்த ஆழமான கற்றலைத் தொடரலாம் மற்றும் ஆழமான கற்றலின் சில சிறந்த பயன்பாடுகளைப் பார்ப்போம்.

ஆழமான கற்றலின் பயன்பாடுகள்

தொழில்துறையில் ஆழமான கற்றலின் பல்வேறு பயன்பாடுகள் உள்ளன, நம்முடைய அன்றாட பணிகளில் முக்கியமான சிலவற்றை இங்கே காணலாம்.

  • பேச்சு அங்கீகாரம்

  • இயந்திர மொழிபெயர்ப்பு

  • முக அங்கீகாரம் மற்றும் தானியங்கி குறிச்சொல்

  • மெய்நிகர் தனிப்பட்ட உதவியாளர்கள்

  • சுய ஓட்டுநர் கார்

  • சாட்போட்கள்

ஆழமான கற்றலுக்கான பைதான் ஏன்?

  • ஒரு தனித்துவமான பண்புக்கூறு கொண்ட ஒரு கருவியாகும் பொது நோக்கம் நிரலாக்க மொழி இருப்பது போல பயன்படுத்த எளிதானது பகுப்பாய்வு மற்றும் அளவு கணிப்பீடு என்று வரும்போது.
  • இது மிகவும் எளிதில் புரியக்கூடிய
  • பைதான் உள்ளது மாறும் தட்டச்சு
  • மிகப்பெரியது
  • போன்ற பல்வேறு நோக்கங்களுக்காக பரந்த அளவிலான நூலகங்கள் Numpy, Seaborn, Matplotlib, Pandas, and Scikit-learn

இப்போது போதுமான கோட்பாடு, பைத்தானுடன் ஆழ்ந்த கற்றலை ஒரு சிறிய மற்றும் அற்புதமான எடுத்துக்காட்டுடன் எவ்வாறு தொடங்கலாம் என்று பார்ப்போம்.

பைத்தானுடன் ஆழமான கற்றல்: பெர்செப்டிரான் எடுத்துக்காட்டு

இப்போது நீங்கள் வேலை செய்வதை நன்கு அறிந்திருக்க வேண்டும் என்று நான் நம்புகிறேன் அல்லது' வாயில். வெளியீடு ஒன்று உள்ளீடுகள் ஏதேனும் இருந்தால் ஒன்று.

ஆகையால், ஒரு பெர்செப்டிரானை ஒரு பிரிப்பான் அல்லது OR கேட்டின் உள்ளீட்டு தொகுப்பை இரண்டு வகுப்புகளாகப் பிரிக்கும் ஒரு முடிவு வரியாகப் பயன்படுத்தலாம்:

வகுப்பு 1: 0 என வெளியீட்டைக் கொண்ட உள்ளீடுகள் முடிவுக் கோட்டிற்குக் கீழே உள்ளன.
வகுப்பு 2: 1 என வெளியீட்டைக் கொண்ட உள்ளீடுகள் முடிவுக் கோடு அல்லது பிரிப்பானுக்கு மேலே உள்ளன.

உள்ளீட்டு தரவை இரண்டு வகுப்புகளாக வகைப்படுத்த ஒரு நேரியல் பெர்செப்டிரான் பயன்படுத்தப்படலாம் என்பதை இப்போது வரை புரிந்துகொண்டோம். ஆனால், இது உண்மையில் தரவை எவ்வாறு வகைப்படுத்துகிறது?

கணித ரீதியாக ஒரு பெர்செப்டிரான் எடைகள், உள்ளீடுகள் மற்றும் சார்புகளின் சமன்பாடு போல கருதப்படலாம்.

படி 1: தேவையான அனைத்து நூலகத்தையும் இறக்குமதி செய்க

இங்கே நான் ஒரே ஒரு நூலகத்தை மட்டுமே இறக்குமதி செய்யப் போகிறேன், அதாவது. டென்சர்ஃப்ளோ

டென்சர்ஃப்ளோவை tf ஆக இறக்குமதி செய்க

படி 2: உள்ளீடு மற்றும் வெளியீட்டிற்கான திசையன் மாறுபாடுகளை வரையறுக்கவும்

அடுத்து, பெர்செப்டிரானுக்கான உள்ளீடு, வெளியீடு மற்றும் சார்பு ஆகியவற்றை சேமிப்பதற்கான மாறிகள் உருவாக்க வேண்டும்.

லினக்ஸில் கிளாஸ் பாதை அமைப்பது எப்படி
train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

படி 3: எடை மாறுபாட்டை வரையறுக்கவும்

இங்கே நாம் எங்கள் எடைகளுக்கு 3 × 1 வடிவத்தின் டென்சர் மாறியை வரையறுத்து ஆரம்பத்தில் சில சீரற்ற மதிப்புகளை ஒதுக்குவோம்.

w = tf.Variable (tf.random_normal ([3, 1], விதை = 15%)

படி 4: உள்ளீடு மற்றும் வெளியீட்டிற்கான ஒதுக்கிடங்களை வரையறுக்கவும்

இருப்பிடங்களை நாம் வரையறுக்க வேண்டும், இதனால் அவர்கள் வெளிப்புற உள்ளீடுகளை இயக்கத்தில் ஏற்றுக்கொள்ள முடியும்.

x = tf.placeholder (tf.float32, [எதுவுமில்லை, 3]) y = tf.placeholder (tf.float32, [எதுவுமில்லை, 1])

படி 5: வெளியீடு மற்றும் செயல்படுத்தும் செயல்பாட்டைக் கணக்கிடுங்கள்

முன்னர் விவாதித்தபடி, ஒரு பெர்செப்டிரானால் பெறப்பட்ட உள்ளீடு முதலில் அந்தந்த எடைகளால் பெருக்கப்படுகிறது, பின்னர், இந்த எடையுள்ள உள்ளீடுகள் அனைத்தும் ஒன்றாகச் சுருக்கப்படுகின்றன. இந்த சுருக்கமான மதிப்பு பின்னர் இறுதி முடிவைப் பெறுவதற்கான செயல்பாட்டிற்கு அளிக்கப்படுகிறது.

வெளியீடு = tf.nn.relu (tf.matmul (x, w))

குறிப்பு: இந்த வழக்கில், நான் பயன்படுத்தினேன் relu எனது செயல்படுத்தும் செயல்பாடாக. உங்கள் தேவைக்கேற்ப செயல்படுத்தும் செயல்பாடுகளை நீங்கள் பயன்படுத்த இலவசம்.

படி 6: செலவு அல்லது பிழையைக் கணக்கிடுங்கள்

பெர்செப்டிரான் வெளியீடு மற்றும் விரும்பிய வெளியீட்டின் வேறுபாட்டின் சதுரத்தைத் தவிர வேறொன்றுமில்லாத செலவு = சராசரி சதுரப் பிழையை நாம் கணக்கிட வேண்டும்.

இழப்பு = tf.reduce_sum (tf.square (வெளியீடு - y))

படி 7: பிழையைக் குறைத்தல்

இழப்பு அல்லது செலவு அல்லது பிழையை குறைப்பதே பெர்செப்டிரானின் குறிக்கோள். எனவே இங்கே நாம் கிரேடியண்ட் டீசண்ட் ஆப்டிமைசரைப் பயன்படுத்தப் போகிறோம்.

optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (இழப்பு)

படி 8: அனைத்து மாறிகள் துவக்க

மாறிகள் மட்டுமே வரையறுக்கப்படுகின்றன tf. மாறக்கூடியது. எனவே, வரையறுக்கப்பட்ட மாறிகளை நாம் துவக்க வேண்டும்.

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

படி 9: மறு செய்கைகளில் பயிற்சி பெர்செப்டிரான்

பிழை அல்லது இழப்பைக் குறைக்க எங்கள் பெர்செப்டிரானை அதாவது அடுத்தடுத்த மறு செய்கையில் எடைகள் மற்றும் சார்புகளின் புதுப்பிப்பு மதிப்புகளைப் பயிற்றுவிக்க வேண்டும். இங்கே, எங்கள் பெர்செப்டிரானை 100 சகாப்தங்களில் பயிற்றுவிப்பேன்.

நான் வரம்பில் (100): sess.run (ரயில், {x: train_in, y: train_out}) cost = sess.run (இழப்பு, feed_dict = {x: train_in, y: train_out}) அச்சு ('சகாப்தம் - ', i,' - இழப்பு - ', செலவு)

படி 10: வெளியீடு

……

……

நீங்கள் இங்கே பார்க்க முடியும் என, இழப்பு தொடங்கியது 2.07 மற்றும் முடிந்தது 0.27

.

பைத்தானுடன் ஆழமான கற்றல்: ஆழமான நரம்பியல் வலையமைப்பை உருவாக்குதல்

இப்போது நாம் வெற்றிகரமாக ஒரு பெர்செப்டிரானை உருவாக்கி OR வாயிலுக்கு பயிற்சி அளித்துள்ளோம். இந்த கட்டுரையைத் தொடரலாம் மற்றும் கீறலில் இருந்து எங்கள் சொந்த நரம்பியல் வலையமைப்பை எவ்வாறு உருவாக்கலாம் என்பதைப் பார்ப்போம், அங்கு உள்ளீட்டு அடுக்கு, மறைக்கப்பட்ட அடுக்குகள் மற்றும் வெளியீட்டு அடுக்கு ஆகியவற்றை உருவாக்குவோம்.

நாங்கள் MNIST தரவு-தொகுப்பைப் பயன்படுத்தப் போகிறோம். MNIST தரவு-தொகுப்பு கொண்டுள்ளது 60,000 பயிற்சி மாதிரிகள் மற்றும் 10,000 சோதனை கையால் எழுதப்பட்ட இலக்க படங்களின் மாதிரிகள். படங்கள் அளவு கொண்டவை 28 × 28 பிக்சல்கள் மற்றும் வெளியீடு இடையில் இருக்கலாம் 0-9 .

படத்தில் உள்ள இலக்கத்தை துல்லியமாக அடையாளம் காணக்கூடிய ஒரு மாதிரியைப் பயிற்றுவிப்பதே இங்குள்ள பணி

முதலாவதாக, பைதான் 3 இலிருந்து அச்சு செயல்பாட்டை பைதான் 2.6+ க்கு கொண்டு வர கீழேயுள்ள இறக்குமதியைப் பயன்படுத்த உள்ளோம். __ எதிர்கால__ அறிக்கைகள் கோப்பின் மேற்புறத்தில் இருக்க வேண்டும், ஏனெனில் அவை மொழியைப் பற்றிய அடிப்படை விஷயங்களை மாற்றுகின்றன, எனவே தொகுப்பான் அவற்றைப் பற்றி ஆரம்பத்தில் இருந்தே தெரிந்து கொள்ள வேண்டும்

__ எதிர்கால__ இறக்குமதி அச்சு_ செயல்பாட்டிலிருந்து

ஒவ்வொரு அடியிலும் கருத்துகளுடன் கூடிய குறியீடு பின்வருமாறு

# Tensorflow.examples.tutorials.mnist இலிருந்து MNIST தரவை இறக்குமதி செய்க input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = true) இறக்குமதி டென்சர்ஃப்ளோவை tf இறக்குமதி matplotlib.pyplot ஆக plt # அளவுருக்கள் learning_poch = 0.001 பயிற்சி_ batch_size = 100 display_step = 1 # நெட்வொர்க் அளவுருக்கள் n_hidden_1 = 256 # 1 வது அடுக்கு அம்சங்களின் எண்ணிக்கை n_hidden_2 = 256 # 2 வது அடுக்கு அம்சங்களின் எண்ணிக்கை n_input = 784 # MNIST தரவு உள்ளீடு (img வடிவம்: 28 * 28) n_classes = 10 # MNIST மொத்த வகுப்புகள் ( 0-9 இலக்கங்கள்) # tf வரைபட உள்ளீடு x = tf.placeholder ('மிதவை', [எதுவுமில்லை, n_input]) y = tf.placeholder ('மிதவை', [எதுவுமில்லை, n_classes]) # மாதிரி டெஃப் மல்டிலேயர்_பெர்செப்டிரான் (x, எடைகள் , சார்பு): # RELU செயல்படுத்தும் அடுக்குடன் மறைக்கப்பட்ட அடுக்கு_1 = tf.add (tf.matmul (x, எடைகள் ['h1']), சார்பு ['b1']) layer_1 = tf.nn.relu (layer_1) # மறைக்கப்பட்ட அடுக்கு RELU செயல்படுத்தும் அடுக்கு_2 = tf.add (tf.matmul (layer_1, எடைகள் ['h2']), சார்பு ['b2']) layer_2 = tf.nn.relu (layer_2) # நேரியல் செயல்படுத்தலுடன் வெளியீட்டு அடுக்கு out_layer = tf. matmul (அடுக்கு _2, எடைகள் ['அவுட்']) + சார்பு ['அவுட்'] திரும்ப அவுட்_லேயர் # ஸ்டோர் அடுக்குகள் எடை & சார்பு எடைகள் = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biases = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))} # மாதிரியை உருவாக்குதல் pred = multilayer_perceptron (x, எடைகள், சார்பு) # இழப்பு மற்றும் உகப்பாக்கி செலவு = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate). வரையறுக்கவும் (செலவு) # மாறிகள் துவக்குதல் init = tf.global_variables_initializer () # செலவு வரலாறு மற்றும் துல்லிய வரலாற்றை சேமிக்க ஒரு வெற்று பட்டியலை உருவாக்கவும் cost_history = [] துல்லியம்_ வரலாறு = [] # வரைபடத்தை tf.Session () உடன் sess: sess.run (init ) # காலகட்டத்தில் சகாப்தத்திற்கான பயிற்சி சுழற்சி (பயிற்சி_எபோச்ச்கள்): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # நான் வரம்பில் உள்ள அனைத்து தொகுதிகளுக்கும் மேலாக சுழற்று (மொத்த_பாட்ச்): batch_x, batch_y = mnist.train.next_batch (batch_size) # உகப்பாக்கம் ஒப் (பேக் பிராப்) மற்றும் செலவு op (இழப்பு மதிப்பைப் பெற) _, c = sess.run ([உகப்பாக்கி, செலவு], feed_dict = {x: batch_x, y: batch_y}) # சராசரி இழப்பைக் கணக்கிடு avg_cost + = c / total_batch # ஒரு சகாப்த படிக்கு பதிவுகள் காண்பி என்றால் சகாப்தம்% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # துல்லியம் துல்லியத்தைக் கணக்கிடுங்கள் = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = துல்லியம்.அவல் ({x: mnist.test.images, y: mnist.test.labels}) # பட்டியலுக்கு துல்லியத்தை சேர்க்கவும் துல்லியம்_ஹிஸ்டரி.அப்பண்ட் (acu_temp) # செலவு வரலாற்றைச் சேர்க்கவும் cost_history.append (avg_cost) அச்சு ('சகாப்தம்:', '% 04d'% (சகாப்தம் + 1), '- செலவு =', '{: .9f}'. வடிவம் (avg_cost), '- துல்லியம் =', acu_temp) அச்சு ('உகப்பாக்கம் முடிந்தது! ') # செலவு வரலாற்றை plt.plot (cost_history) plt.show () # துல்லிய வரலாற்றை plt.plot (துல்லியம் _history) plt.show () # சோதனை மாதிரி correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # துல்லியம் துல்லியத்தை கணக்கிடுங்கள் = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) அச்சு (' துல்லியம்: ', துல்லியம்.இவல் ({x: mnist.test.images, y: mnist.test.labels}))

வெளியீடு:

இப்போது இதன் மூலம், இந்த ஆழமான கற்றல் பைதான் கட்டுரையின் முடிவுக்கு வருகிறோம். ஆழமான கற்றலின் பல்வேறு கூறுகள், இது எவ்வாறு தொடங்கியது மற்றும் பைத்தானைப் பயன்படுத்தி ஒரு எளிய பெர்செப்டிரான் மற்றும் ஆழமான நரம்பியல் வலையமைப்பை எவ்வாறு புரிந்துகொள்வது என்பது உங்களுக்குப் புரிந்தது என்று நம்புகிறேன்.

எடுரேகா தொழில் தேவைகள் மற்றும் கோரிக்கைகளுக்கு ஏற்ப தொழில் வல்லுநர்களால் நிர்வகிக்கப்படுகிறது. சாஃப்ட்மேக்ஸ் செயல்பாடு, ஆட்டோஎன்கோடர் நியூரல் நெட்வொர்க்குகள், கட்டுப்படுத்தப்பட்ட போல்ட்ஜ்மேன் மெஷின் (ஆர்.பி.எம்) போன்ற கருத்துக்களை நீங்கள் மாஸ்டர் செய்வீர்கள், மேலும் கெராஸ் & டி.எஃப்.லெர்ன் போன்ற நூலகங்களுடன் பணிபுரிவீர்கள். நிகழ்நேர வழக்கு ஆய்வுகள் மூலம் தொழில் வல்லுநர்களால் இந்த பாடநெறி சிறப்பாக வடிவமைக்கப்பட்டுள்ளது.

எங்களுக்கு ஒரு கேள்வி கிடைத்ததா? தயவுசெய்து 'பைத்தானுடன் ஆழமான கற்றல்' இன் கருத்துகள் பிரிவில் குறிப்பிடவும், நாங்கள் உங்களிடம் திரும்புவோம்.