பொருளடக்கம்[மறை][காட்டு]
தகவல் தொடர்புத் துறையில் உரை மற்றும் காட்சிகளுக்கு ஆதரவாக குரல் அழைப்புகள் படிப்படியாக நிறுத்தப்படுகின்றன. ஃபேஸ்புக் கருத்துக்கணிப்பின்படி, வாங்குபவர்களில் பாதிக்கும் மேற்பட்டவர்கள் தாங்கள் பேசக்கூடிய நிறுவனத்திடம் இருந்து வாங்க விரும்புகிறார்கள். அரட்டை என்பது சமூகம் ஏற்கும் புதிய தகவல் தொடர்பு முறையாக மாறியுள்ளது.
வணிகங்கள் தங்கள் வாடிக்கையாளர்களுடன் எந்த நேரத்திலும் எந்த இடத்திலிருந்தும் தொடர்பு கொள்ள இது உதவுகிறது. சாட்போட்களின் எளிமை மற்றும் காத்திருப்பு நேரம் குறைவதால் நிறுவனங்கள் மற்றும் வாடிக்கையாளர்களிடையே பிரபலமடைந்து வருகிறது.
Chatbots அல்லது தானியங்கு உரையாடல் நிரல்கள், உரை அடிப்படையிலான இடைமுகம் மூலம் சேவைகளை அணுகுவதற்கு வாடிக்கையாளர்களுக்கு மிகவும் தனிப்பயனாக்கப்பட்ட முறையை வழங்குகிறது. புதிய AI-இயங்கும் சாட்போட்கள் ஒரு குறிப்பிட்ட சூழலில் ஒரு நபரால் (கேள்வி, கட்டளை, வரிசை, முதலியன) வினவலை அடையாளம் கண்டு சரியான முறையில் பதிலளிக்கலாம் (பதில், செயல் போன்றவை).
இந்த இடுகையில், சாட்போட்கள் என்றால் என்ன, அவற்றின் பலன்கள், பயன்பாட்டு வழக்குகள் மற்றும் உங்கள் சொந்தமாக எப்படி உருவாக்குவது என்பதைப் பற்றி பார்ப்போம் ஆழமான கற்றல் பைத்தானில் உள்ள சாட்போட், மற்றவற்றுடன்.
தொடங்குவோம்.
எனவே, சாட்போட்கள் என்றால் என்ன?
மனித-இயந்திர தொடர்புகளின் மிகவும் மேம்பட்ட மற்றும் நம்பிக்கைக்குரிய வடிவங்களில் ஒன்றாக சாட்போட் அடிக்கடி குறிப்பிடப்படுகிறது. இந்த டிஜிட்டல் உதவியாளர்கள் மக்கள் மற்றும் சேவைகளுக்கு இடையேயான தொடர்புகளை ஒழுங்குபடுத்துவதன் மூலம் வாடிக்கையாளர் அனுபவத்தை மேம்படுத்துகின்றனர்.
அதே நேரத்தில், வாடிக்கையாளர் தொடர்பு செயல்முறையை செயல்திறனுக்காக மேம்படுத்த புதிய விருப்பங்களை வணிகங்களுக்கு வழங்குகின்றன, இது வழக்கமான ஆதரவு செலவுகளைக் குறைக்கும்.
சுருக்கமாக, இது AI- அடிப்படையிலான மென்பொருளாகும், இது மனிதர்களுடன் அவர்களின் இயல்பான மொழிகளில் தொடர்பு கொள்ள வேண்டும். இந்த சாட்போட்கள் பெரும்பாலும் ஆடியோ அல்லது எழுதப்பட்ட நுட்பங்கள் வழியாக தொடர்பு கொள்கின்றன, மேலும் அவை மனிதர்களுடன் மனிதனைப் போன்ற முறையில் இணைக்க மனித மொழிகளை எளிதாகப் பிரதிபலிக்கும்.
சாட்போட்கள் பயனர்களுடனான அவர்களின் தொடர்புகளிலிருந்து கற்றுக்கொள்கின்றன, காலப்போக்கில் மிகவும் யதார்த்தமாகவும் திறமையாகவும் மாறும். செலவினங்களை அங்கீகரிப்பது, ஆன்லைனில் நுகர்வோருடன் ஈடுபடுவது மற்றும் முன்னணிகளை உருவாக்குவது போன்ற பரந்த அளவிலான வணிக நடவடிக்கைகளை அவர்களால் கையாள முடியும்.
பைதான் மூலம் உங்கள் சொந்த ஆழமான கற்றல் சாட்போட்டை உருவாக்குதல்
துறையில் பல தனித்துவமான சாட்போட்கள் உள்ளன இயந்திர கற்றல் மற்றும் AI. சில சாட்போட்கள் மெய்நிகர் உதவியாளர்கள், மற்றவை உரையாடலுக்காக மட்டுமே உள்ளன, மற்றவை வாடிக்கையாளர் சேவை முகவர்கள்.
விசாரணைகளுக்குப் பதிலளிக்க வணிகங்களால் பணியமர்த்தப்பட்டவர்களில் சிலரை நீங்கள் பார்த்திருக்கலாம். அடிக்கடி கேட்கப்படும் கேள்விகளுக்குப் பதிலளிக்க இந்தப் பயிற்சியில் ஒரு சிறிய சாட்போட்டை உருவாக்குவோம்.
1. தொகுப்புகளை நிறுவுதல்
எங்கள் முதல் படி பின்வரும் தொகுப்புகளை நிறுவ வேண்டும்.
2. பயிற்சி தரவு
எங்கள் சாட்போட்டுக்கு எந்த வகையான தகவலை வழங்க வேண்டும் என்பதைக் கண்டுபிடிக்கும் நேரம் இது. இது ஒரு எளிய சாட்பாட் என்பதால் பெரிய டேட்டாசெட்களை நாங்கள் பதிவிறக்க வேண்டியதில்லை.
நாமே உருவாக்கிய தகவலை மட்டுமே பயன்படுத்துவோம். பாடத்துடன் திறம்பட பின்பற்ற, கீழே உள்ள வடிவமைப்பில் உள்ள அதே வடிவமைப்பில் .JSON கோப்பை உருவாக்க வேண்டும். எனது கோப்பு "intents.json" என்று பெயரிடப்பட்டுள்ளது.
JSON கோப்பு, பயனர் உள்ளீடு செய்யக்கூடிய செய்திகளின் தொகுப்பை உருவாக்கப் பயன்படுகிறது மற்றும் தொடர்புடைய பதில்களின் தொகுப்பை வரைபடமாக்குகிறது. கோப்பில் உள்ள ஒவ்வொரு அகராதியிலும் ஒவ்வொரு செய்தியும் எந்தக் குழுவைச் சேர்ந்தது என்பதைக் குறிக்கும் குறிச்சொல்லைக் கொண்டுள்ளது.
ஒரு பயிற்சிக்கு இந்தத் தகவலைப் பயன்படுத்துவோம் நரம்பு நெட்வொர்க் எங்கள் கோப்பில் உள்ள குறிச்சொற்களில் ஒன்றாக வார்த்தைகளின் சொற்றொடரை வகைப்படுத்த.
நாம் அந்தக் குழுக்களிடமிருந்து பதிலைப் பெற்று பயனருக்கு வழங்கலாம். கூடுதல் குறிச்சொற்கள், பதில்கள் மற்றும் வடிவங்களுடன் நீங்கள் வழங்கினால், சாட்போட் சிறப்பாகவும் சிக்கலானதாகவும் இருக்கும்.
3. JSON தரவு ஏற்றப்படுகிறது
எங்கள் .json தரவை ஏற்றி சில தொகுதிகளை இறக்குமதி செய்வதன் மூலம் தொடங்குவோம். உங்களுடைய அதே கோப்பகத்தில் your.json கோப்பை இணைக்கவும் பைதான் ஸ்கிரிப்ட். எங்கள் .json தரவு இப்போது தரவு மாறியில் சேமிக்கப்படும்.
4. தரவு பிரித்தெடுத்தல்
எங்கள் JSON கோப்பிலிருந்து நமக்குத் தேவையான தகவலைப் பிரித்தெடுக்க வேண்டிய நேரம் இது. அனைத்து வடிவங்களும், அவை சார்ந்த வகுப்பு/குறிச்சொல்லும் தேவை.
எங்கள் பேட்டர்ன்களில் உள்ள அனைத்து தனித்துவமான சொற்களின் பட்டியலையும் எங்களுக்குத் தேவைப்படும் (காரணங்களுக்காக நாங்கள் பின்னர் விளக்குவோம்), எனவே இந்த மதிப்புகளைக் கண்காணிக்க சில வெற்றுப் பட்டியல்களை உருவாக்குவோம்.
இப்போது நாங்கள் எங்கள் JSON தரவு மூலம் லூப் செய்து நமக்குத் தேவையான தகவலைப் பெறுவோம். அவற்றை சரங்களாகக் கொண்டிருப்பதற்குப் பதிலாக, ஒவ்வொரு வடிவத்தையும் சொற்களின் பட்டியலாக மாற்ற nltk.word டோக்கனைசரைப் பயன்படுத்துவோம்.
பின்னர், எங்கள் docs_x பட்டியலில், ஒவ்வொரு வடிவத்தையும் அதனுடன் தொடர்புடைய குறிச்சொல்லையும் docs_y பட்டியலில் சேர்ப்போம்.
5. வேர்ட் ஸ்டெமிங்
ஒரு வார்த்தையின் மூலத்தைக் கண்டறிவது ஸ்டெமிங் எனப்படும். உதாரணமாக, "அது" என்ற வார்த்தையின் தண்டு "அது" ஆக இருக்கலாம், அதே சமயம் "நடக்கும்" என்ற வார்த்தையின் தண்டு "நடக்கும்" ஆக இருக்கலாம்.
எங்கள் மாதிரியின் சொற்களஞ்சியத்தை குறைக்க இந்த ஸ்டெம்மிங் நுட்பத்தைப் பயன்படுத்துவோம் மற்றும் பொதுவாக வாக்கியங்கள் என்ன என்பதைக் கண்டறிய முயற்சிப்போம். இந்தக் குறியீடு, எங்கள் தரவுத் தயாரிப்பின் அடுத்த கட்டத்தில் பயன்படுத்தப்படும் ஸ்டெம்டு வார்த்தைகளின் தனித்துவமான பட்டியலை உருவாக்கும்.
6. வார்த்தைகளின் பை
நாங்கள் எங்கள் தரவை இறக்குமதி செய்து, ஒரு சொற்களஞ்சியத்தை உருவாக்கிவிட்டதால், சொற்களின் பையைப் பற்றி பேச வேண்டிய நேரம் இது. நரம்பியல் வலையமைப்புகள் மற்றும் இயந்திர கற்றல் வழிமுறைகள், நாம் அனைவரும் அறிந்தபடி, எண்ணியல் உள்ளீடு தேவைப்படுகிறது. எனவே எங்கள் சரம் பட்டியல் அதை குறைக்க போவதில்லை. நமது வாக்கியங்களில் எண்களைக் குறிக்கும் ஒரு பொறிமுறை நமக்குத் தேவை, அங்குதான் ஒரு பை வார்த்தைகள் வருகின்றன.
ஒவ்வொரு சொற்றொடரும் எங்கள் மாதிரியின் சொற்களஞ்சியத்தில் உள்ள சொற்களின் எண்ணிக்கையின் நீளத்தின் பட்டியலால் குறிப்பிடப்படும். எங்கள் சொற்களஞ்சியத்தில் உள்ள ஒவ்வொரு வார்த்தையும் பட்டியலில் உள்ள ஒரு இடத்தால் குறிப்பிடப்படும். பட்டியலில் உள்ள நிலை 1 எனில், அந்த வார்த்தை எங்கள் அறிக்கையில் தோன்றும்; அது 0 என்றால், அந்த வார்த்தை நம் வாக்கியத்தில் தோன்றாது.
சொற்றொடரில் சொற்கள் வரும் வரிசையை அறியாததால் அதைச் சொற்களின் பை என்கிறோம்; எங்கள் மாதிரியின் சொற்களஞ்சியத்தில் அவை உள்ளன என்பது எங்களுக்குத் தெரியும்.
நமது உள்ளீட்டை கட்டமைப்பதைத் தவிர, நரம்பியல் நெட்வொர்க் அதை புரிந்துகொள்ளும் வகையில் நமது வெளியீட்டையும் வடிவமைக்க வேண்டும். எங்கள் தரவுத்தொகுப்பில் உள்ள லேபிள்கள்/குறிச்சொற்களின் எண்ணிக்கையின் நீளம் கொண்ட வெளியீடு பட்டியல்களை உருவாக்குவோம், இது ஒரு பை வார்த்தைகளைப் போன்றது. பட்டியலில் உள்ள ஒவ்வொரு இடமும் ஒரு தனித்துவமான லேபிள்/குறிச்சொல்லைக் குறிக்கிறது, மேலும் அந்த இடங்களில் ஏதேனும் ஒன்றில் 1 என்பது எந்த லேபிள்/டேக் குறிப்பிடப்படுகிறது என்பதைக் குறிக்கிறது.
இறுதியாக, எங்கள் பயிற்சித் தரவு மற்றும் வெளியீட்டைச் சேமிக்க NumPy வரிசைகளைப் பயன்படுத்துவோம்.
7. மாதிரி வளர்ச்சி
எங்களின் எல்லா தரவையும் முன்கூட்டியே செயலாக்கிவிட்டதால், ஒரு மாதிரியை உருவாக்கவும் பயிற்சி செய்யவும் நாங்கள் தயாராக உள்ளோம். எங்கள் நோக்கங்களுக்காக இரண்டு மறைக்கப்பட்ட அடுக்குகளுடன் கூடிய அடிப்படை ஃபீட்-ஃபார்வர்டு நியூரல் நெட்வொர்க்கைப் பயன்படுத்துவோம்.
எங்கள் நெட்வொர்க்கின் நோக்கம் வார்த்தைகளின் தொகுப்பைப் பார்த்து அவற்றை ஒரு வகுப்பிற்கு ஒதுக்குவது (JSON கோப்பில் இருந்து எங்கள் குறிச்சொற்களில் ஒன்று). எங்கள் மாதிரியின் கட்டமைப்பை நிறுவுவதன் மூலம் தொடங்குவோம். ஒரு சிறந்த மாடலைக் கொண்டு வர சில எண்களுடன் நீங்கள் விளையாடலாம் என்பதை நினைவில் கொள்ளுங்கள்! இயந்திர கற்றல் பெரும்பாலும் சோதனை மற்றும் பிழையை அடிப்படையாகக் கொண்டது.
8. மாதிரி பயிற்சி & சேமிப்பு
எங்கள் தரவை நாங்கள் அமைத்துவிட்டதால், எங்கள் மாதிரியைப் பயிற்றுவிப்பதற்கான நேரம் இது! எங்கள் தரவை மாதிரியுடன் பொருத்துவதன் மூலம் இதை அடைவோம். நாங்கள் வழங்கும் சகாப்தங்களின் எண்ணிக்கையானது, பயிற்சியின் போது அதே தரவுகளுக்கு மாடல் எத்தனை முறை வெளிப்படும்.
பயிற்சியை முடித்தவுடன், மாதிரியை கோப்பு மாதிரியில் சேமிக்க முடியும். tflearn என்பது மற்ற ஸ்கிரிப்ட்களில் பயன்படுத்தக்கூடிய ஒரு ஸ்கிரிப்ட் ஆகும்.
9. சாட்போட்டைப் பயன்படுத்துதல்
இப்போது நீங்கள் உங்கள் போட்டுடன் அரட்டையடிக்கத் தொடங்கலாம்.
சாட்போட்டின் நன்மைகள்
- போட்கள் வருடத்தில் 365 நாட்களும், 24 மணிநேரமும், ஊதியம் இல்லாமல் செயல்படும் என எதிர்பார்க்கப்படுவதால், கிடைக்கும் தன்மை மற்றும் எதிர்வினை வேகம் அதிகரிக்கும்.
- பெரிய தரவுகளின் மூன்று முக்கிய Vs: தொகுதி, வேகம் மற்றும் பல்வேறு வகைகளைக் கையாள்வதற்கான சரியான கருவிகள் இந்த போட்கள்.
- சாட்போட்கள் ஒரு நிறுவனத்தின் நுகர்வோரைப் பற்றி அறிந்துகொள்ளவும் புரிந்துகொள்ளவும் பயன்படும் மென்பொருள்.
- சிறந்த பலன்களைப் பெற்ற பிறகு மலிவான பராமரிப்புச் செலவைக் கொண்டிருப்பதற்கு இது உயர்ந்த சக்தியைக் கொண்டுள்ளது.
- சாட்போட் பயன்பாடுகள் தரவுகளை உருவாக்குகின்றன, அவை பகுப்பாய்வு மற்றும் முன்னறிவிப்புகளுக்குப் பாதுகாக்கப்பட்டு பயன்படுத்தப்படலாம்.
பயன்பாட்டு வழக்கு
- வாடிக்கையாளர் கேள்விகளைத் தீர்ப்பது
- அடிக்கடி கேட்கப்படும் கேள்விகளுக்கு பதில்
- ஆதரவு குழுவிற்கு வாடிக்கையாளர்களை நியமித்தல்
- வாடிக்கையாளர் கருத்துக்களை சேகரித்தல்
- புதிய சலுகைகளை பரிந்துரைக்கிறது
- உரையாடல் வணிகத்துடன் ஷாப்பிங் செய்யுங்கள்
- தகவல் தொழில்நுட்ப உதவி மையம்
- தங்குமிடங்களை முன்பதிவு செய்தல்
- பணம் பரிமாற்றம்
தீர்மானம்
மற்ற AI தொழில்நுட்பங்களைப் போலவே, சாட்போட்களும், மனித திறன்களை அதிகரிக்கவும், தந்திரோபாயப் பணிகளுக்குப் பதிலாக, தந்திரோபாயத்தில் அதிக நேரத்தைச் செலவிட அனுமதிப்பதன் மூலம், மனிதர்களை மேலும் ஆக்கப்பூர்வமான மற்றும் கற்பனைத்திறன் கொண்டவர்களாக விடுவிக்கவும் பயன்படுத்தப்படும்.
வணிகங்கள், பணியாளர்கள் மற்றும் நுகர்வோர்கள், விரைவான பரிந்துரைகள் மற்றும் கணிப்புகள் போன்ற மேம்படுத்தப்பட்ட சாட்பாட் அம்சங்களால் பயனடைவார்கள். 5ஜி தொழில்நுட்பம்.
இவை மற்றும் பிற சாத்தியக்கூறுகள் இன்னும் ஆராயப்பட்டு வருகின்றன, ஆனால் இணைய இணைப்பு, AI, NLP மற்றும் இயந்திர கற்றல் முன்னேற்றம் போன்றவற்றில், அவை மிகவும் பரவலாகிவிடும்.
ச்சூ
வணக்கம்,
இந்த நிகழ்ச்சிக்கு நன்றி.
எனக்கு ஒரு கேள்வி.
“bag_of_words” வரையறுக்கப்படவில்லை. இந்த பிழையை என்னால் புரிந்து கொள்ள முடியவில்லை.
இந்த பிழையை நான் எப்படி தீர்க்க முடியும் என்று சொல்ல முடியுமா??
இந்த திட்டத்திற்கு நன்றி!! இந்த நாள் இனிய நாளாகட்டும்
ஜே
சாட்பாட் பகுதியைப் பயன்படுத்துவதற்கு முன், ஒரு செயல்பாட்டைச் சேர்க்கவும்:
////////////////////////////////////////////// ////////////////////////////
def bag_of_words(கள், வார்த்தைகள்):
பை = [0க்கு _ வரம்பில்(லென்(சொற்கள்))]
s_words = nltk.word_tokenize(s)
s_words = [s_words இல் உள்ள வார்த்தைக்கு stemmer.stem(word.lower())
s_words இல் பார்க்க:
i, w in numerate(words):
w == se என்றால்:
பை[i] = 1
numpy.array(bag) திரும்ப
//அது நிச்சயம் உங்கள் பிரச்சனையை தீர்க்கும். //
//////////////////////////////////////////////// ////////////////////////////
நான் உங்களுடன் முழுமையான குறியீட்டைப் பகிர்கிறேன், இதன் மூலம் நீங்கள் தெளிவான படத்தைப் பெறுவீர்கள்.
////////////////////////////////////////////// ////////
இறக்குமதி nltk
nltk.stem.lancaster இலிருந்து LancasterStemmer இறக்குமதி
ஸ்டெம்மர் = லான்காஸ்டர்ஸ்டெம்மர்()
நம்பி இறக்குமதி
இறக்குமதி tflearn
இறக்குமதி tensorflow
சீரற்ற இறக்குமதி
இறக்குமதி json
ஊறுகாய் இறக்குமதி
திறந்த (“intents.json”) கோப்பாக:
தரவு = json.load(கோப்பு)
முயற்சி:
திறந்த ("data.pickle", "rb") f ஆக:
வார்த்தைகள், லேபிள்கள், பயிற்சி, வெளியீடு = pickle.load(f)
தவிர:
வார்த்தைகள் = []
லேபிள்கள் = []
docs_x = []
docs_y = []
தரவு உள்ள நோக்கத்திற்காக[“இன்டென்ட்ஸ்”]:
உள்நோக்கத்தில் உள்ள வடிவத்திற்காக[“வடிவங்கள்”]:
wrds = nltk.word_tokenize(மாதிரி)
word.extend(wrds)
docs_x.append(wrds)
docs_y.append(நோக்கம்[“டேக்”])
நோக்கம் [“டேக்”] லேபிள்களில் இல்லை என்றால்:
labels.append(நோக்கம்[“டேக்”])
வார்த்தைகள் = [stemmer.stem(w.lower()) for w க்கு வார்த்தைகளில் w != “?”]
வார்த்தைகள் = வரிசைப்படுத்தப்பட்ட (பட்டியல் (தொகுப்பு (சொற்கள்)))
லேபிள்கள் = வரிசைப்படுத்தப்பட்ட (லேபிள்கள்)
பயிற்சி = []
வெளியீடு = []
out_empty = [0 க்கு _ வரம்பில் (len(லேபிள்கள்))]
x க்கு, doc in enumerate(docs_x):
பை = []
wrds = [stemmer.stem(w.lower()) for w in doc]
வார்த்தைகளில் w க்கு:
wrdகளில் w என்றால்:
bag.append(1)
வேறு:
bag.append(0)
output_row = out_empty[:]
output_row[labels.index(docs_y[x])] = 1
பயிற்சி.சேர்க்கை(பை)
output.append(output_row)
பயிற்சி = numpy.array(பயிற்சி)
வெளியீடு = numpy.array(வெளியீடு)
திறந்த ("data.pickle", "wb") f ஆக:
pickle.dump((சொற்கள், லேபிள்கள், பயிற்சி, வெளியீடு), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(வடிவம்=[எதுவும் இல்லை, லென்(பயிற்சி[0])])
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, len(output[0]), activation=”softmax”)
நிகர = tflearn.regression(net)
மாதிரி = tflearn.DNN(net)
முயற்சி:
model.load("model.tflearn")
தவிர:
model.fit(பயிற்சி, வெளியீடு, n_epoch=1500, batch_size=8, show_metric=True)
model.save ("model.tflearn")
def bag_of_words(கள், வார்த்தைகள்):
பை = [0க்கு _ வரம்பில்(லென்(சொற்கள்))]
s_words = nltk.word_tokenize(s)
s_words = [s_words இல் உள்ள வார்த்தைக்கு stemmer.stem(word.lower())
s_words இல் பார்க்க:
i, w in numerate(words):
w == se என்றால்:
பை[i] = 1
numpy.array(bag) திரும்ப
டெஃப் அரட்டை():
அச்சு (“போட்டுடன் பேசத் தொடங்கு (நிறுத்த வெளியேறு என தட்டச்சு செய்க)!”)
உண்மை என்றாலும்:
inp = உள்ளீடு ("நீங்கள்:")
inp.lower() == “வெளியேறு” என்றால்:
இடைவெளி
முடிவுகள் = model.predict([bag_of_words(inp, words)])
results_index = numpy.argmax(முடிவுகள்)
குறி = லேபிள்கள்[results_index]
தரவுகளில் tgக்கு[“இன்டென்ட்ஸ்”]:
tg['tag'] == குறிச்சொல்:
பதில்கள் = tg['பதில்கள்']
அச்சு(ரேண்டம்.தேர்வு(பதில்கள்))
அரட்டை ()
////////////////////////////////////////////// //////////////
நன்றி,
மகிழ்ச்சியான குறியீட்டு!
Lu
வணக்கம்,
python இல் chatbot ஐ உருவாக்க விரும்பும் போது மேற்கொள்ள வேண்டிய செயல்முறை பற்றி எனக்கு ஒரு யோசனை கொடுக்க முடியுமா, ஆனால் தகவல் எக்செல் இல் ஒரு கணக்கெடுப்பில் இருந்து பெறப்பட்டது. நன்றி!