ML-For-Beginners/translations/ml/6-NLP/4-Hotel-Reviews-1

ഹോട്ടൽ റിവ്യൂവുകളുമായി സെന്റിമെന്റ് വിശകലനം - ഡാറ്റ പ്രോസസ്സ് ചെയ്യൽ

ഈ വിഭാഗത്തിൽ നിങ്ങൾ മുമ്പത്തെ പാഠങ്ങളിൽ ഉപയോഗിച്ച സാങ്കേതിക വിദ്യകൾ ഉപയോഗിച്ച് ഒരു വലിയ ഡാറ്റാസെറ്റിന്റെ എക്സ്പ്ലോറട്ടറി ഡാറ്റ അനാലിസിസ് നടത്തും. വിവിധ കോളങ്ങളുടെയും പ്രയോജനത്തെക്കുറിച്ച് നല്ലൊരു ബോധം ലഭിച്ച ശേഷം, നിങ്ങൾ പഠിക്കും:

• അനാവശ്യ കോളങ്ങൾ എങ്ങനെ നീക്കം ചെയ്യാം
• നിലവിലുള്ള കോളങ്ങൾ അടിസ്ഥാനമാക്കി പുതിയ ഡാറ്റ എങ്ങനെ കണക്കാക്കാം
• ഫൈനൽ ചലഞ്ചിൽ ഉപയോഗിക്കാൻ ഫലമായ ഡാറ്റാസെറ്റ് എങ്ങനെ സേവ് ചെയ്യാം

പ്രീ-ലെക്ചർ ക്വിസ്

പരിചയം

ഇതുവരെ നിങ്ങൾ പഠിച്ചത് ടെക്സ്റ്റ് ഡാറ്റ സംഖ്യാത്മക ഡാറ്റയുമായി വളരെ വ്യത്യസ്തമാണെന്ന് ആണ്. മനുഷ്യൻ എഴുതിയതോ സംസാരിച്ചതോ ആയ ടെക്സ്റ്റ് പാറ്റേണുകളും ആവൃത്തി, സെന്റിമെന്റ്, അർത്ഥം കണ്ടെത്താൻ വിശകലനം ചെയ്യാവുന്നതാണ്. ഈ പാഠം നിങ്ങൾക്ക് യഥാർത്ഥ ഡാറ്റാസെറ്റും യഥാർത്ഥ വെല്ലുവിളിയും നൽകുന്നു: 515K Hotel Reviews Data in Europe, കൂടാതെ CC0: Public Domain ലൈസൻസ് ഉൾക്കൊള്ളുന്നു. ഇത് Booking.com-ൽ നിന്നുള്ള പൊതു ഉറവിടങ്ങളിൽ നിന്നാണ് സ്ക്രാപ്പ് ചെയ്തിരിക്കുന്നത്. ഡാറ്റാസെറ്റ് സൃഷ്ടിച്ചത് ജിയാഷൻ ലിയു ആണ്.

തയ്യാറെടുപ്പ്

നിങ്ങൾക്ക് ആവശ്യമായത്:

• Python 3 ഉപയോഗിച്ച് .ipynb നോട്ട്‌ബുക്കുകൾ ഓടിക്കാൻ കഴിവ്
• pandas
• NLTK, ഇത് നിങ്ങൾക്ക് ലോക്കലായി ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതാണ്
• Kaggle-ൽ ലഭ്യമായ ഡാറ്റാസെറ്റ് 515K Hotel Reviews Data in Europe. ഇത് അന്ജിപ്പിച്ചപ്പോൾ ഏകദേശം 230 MB ആണ്. ഈ NLP പാഠങ്ങളുമായി ബന്ധപ്പെട്ട /data റൂട്ട് ഫോൾഡറിൽ ഡൗൺലോഡ് ചെയ്യുക.

എക്സ്പ്ലോറട്ടറി ഡാറ്റ അനാലിസിസ്

ഈ വെല്ലുവിളി നിങ്ങൾ സെന്റിമെന്റ് അനാലിസിസും ഗസ്റ്റ് റിവ്യൂ സ്കോറുകളും ഉപയോഗിച്ച് ഹോട്ടൽ ശുപാർശ ബോട്ട് നിർമ്മിക്കുന്നതായി കരുതുന്നു. നിങ്ങൾ ഉപയോഗിക്കുന്ന ഡാറ്റാസെറ്റിൽ 6 നഗരങ്ങളിലെ 1493 വ്യത്യസ്ത ഹോട്ടലുകളുടെ റിവ്യൂവുകൾ ഉൾക്കൊള്ളുന്നു.

Python, ഹോട്ടൽ റിവ്യൂ ഡാറ്റാസെറ്റ്, NLTK സെന്റിമെന്റ് അനാലിസിസ് ഉപയോഗിച്ച് നിങ്ങൾ കണ്ടെത്താൻ കഴിയും:

• റിവ്യൂവുകളിൽ ഏറ്റവും അധികം ഉപയോഗിക്കുന്ന വാക്കുകളും വാചകങ്ങളും എന്തൊക്കെയാണ്?
• ഹോട്ടലിനെ വിവരണാത്മകമായി അടയാളപ്പെടുത്തുന്ന ഔദ്യോഗിക ടാഗുകൾ റിവ്യൂ സ്കോറുകളുമായി (ഉദാ: കുട്ടികളോടുള്ള കുടുംബം എന്ന ടാഗ് ഉള്ള ഹോട്ടലിൽ സോളോ ട്രാവലർ എന്ന ടാഗുള്ളവരെക്കാൾ കൂടുതൽ നെഗറ്റീവ് റിവ്യൂവുണ്ടോ?) ബന്ധമുണ്ടോ?
• NLTK സെന്റിമെന്റ് സ്കോറുകൾ ഹോട്ടൽ റിവ്യൂവറുടെ സംഖ്യാത്മക സ്കോറുമായി 'ഒത്തുപോകുന്നുണ്ടോ'?

ഡാറ്റാസെറ്റ്

നിങ്ങൾ ഡൗൺലോഡ് ചെയ്ത് ലോക്കലായി സേവ് ചെയ്ത ഡാറ്റാസെറ്റ് പരിശോധിക്കാം. VS Code പോലുള്ള എഡിറ്റർ അല്ലെങ്കിൽ Excel-ൽ ഫയൽ തുറക്കുക.

ഡാറ്റാസെറ്റിലെ ഹെഡറുകൾ ഇപ്രകാരമാണ്:

Hotel_Address, Additional_Number_of_Scoring, Review_Date, Average_Score, Hotel_Name, Reviewer_Nationality, Negative_Review, Review_Total_Negative_Word_Counts, Total_Number_of_Reviews, Positive_Review, Review_Total_Positive_Word_Counts, Total_Number_of_Reviews_Reviewer_Has_Given, Reviewer_Score, Tags, days_since_review, lat, lng

ഇവയെ ഒരു എളുപ്പത്തിൽ പരിശോധിക്കാൻ കഴിയുന്ന വിധത്തിൽ ഗ്രൂപ്പുചെയ്തിരിക്കുന്നു:

ഹോട്ടൽ കോളങ്ങൾ

• Hotel_Name, Hotel_Address, lat (അക്ഷാംശം), lng (രേഖാംശം)
  • lat ഉം lng ഉം ഉപയോഗിച്ച് Python-ൽ ഹോട്ടലുകളുടെ സ്ഥാനം കാണിക്കുന്ന ഒരു മാപ്പ് പ്ലോട്ട് ചെയ്യാം (നെഗറ്റീവ്, പോസിറ്റീവ് റിവ്യൂവുകൾ നിറംകൊണ്ട് വ്യത്യാസപ്പെടുത്താം)
  • Hotel_Address നമുക്ക് വ്യക്തമായി പ്രയോജനകരമല്ല, അതിനാൽ അത് രാജ്യമായി മാറ്റി എളുപ്പത്തിൽ സോർട്ട് ചെയ്യാനും തിരയാനും കഴിയും

ഹോട്ടൽ മെറ്റാ-റിവ്യൂ കോളങ്ങൾ

• Average_Score

  • ഡാറ്റാസെറ്റ് സൃഷ്ടിച്ചവന്റെ പ്രകാരം, ഈ കോളം കഴിഞ്ഞ വർഷം ഏറ്റവും പുതിയ കമന്റിന്റെ അടിസ്ഥാനത്തിൽ കണക്കാക്കിയ ഹോട്ടലിന്റെ ശരാശരി സ്കോർ ആണ്. ഇത് സ്കോർ കണക്കാക്കാനുള്ള അസാധാരണമായ രീതിയാണെന്ന് തോന്നുന്നു, പക്ഷേ ഡാറ്റ സ്ക്രാപ്പ് ചെയ്തതാണെന്നതിനാൽ ഇപ്പോൾ ഇതിനെ വിശ്വസിക്കാം.

  ✅ ഈ ഡാറ്റയിലെ മറ്റ് കോളങ്ങൾ അടിസ്ഥാനമാക്കി ശരാശരി സ്കോർ കണക്കാക്കാനുള്ള മറ്റൊരു മാർഗം നിങ്ങൾക്ക് തോന്നുന്നുണ്ടോ?

• Total_Number_of_Reviews

  • ഈ ഹോട്ടലിന് ലഭിച്ച മൊത്തം റിവ്യൂവുകളുടെ എണ്ണം - ഇത് ഡാറ്റാസെറ്റിലെ റിവ്യൂവുകളെ സൂചിപ്പിക്കുന്നതാണോ എന്ന് (കൂടുതൽ കോഡ് എഴുതാതെ) വ്യക്തമല്ല.

• Additional_Number_of_Scoring

  • റിവ്യൂവറുടെ റിവ്യൂ എഴുതാതെ റിവ്യൂ സ്കോർ നൽകിയിട്ടുള്ളത്

റിവ്യൂ കോളങ്ങൾ

• Reviewer_Score
  • ഏറ്റവും കൂടുതൽ 1 ദശാംശം വരെ ഉള്ള സംഖ്യാത്മക മൂല്യം, കുറഞ്ഞത് 2.5, ഉയരം 10 വരെ
  • 2.5 ഏറ്റവും കുറഞ്ഞ സ്കോർ ആണെന്ന് എന്തുകൊണ്ട് എന്ന് വിശദീകരിച്ചിട്ടില്ല
• Negative_Review
  • റിവ്യൂവർ ഒന്നും എഴുതിയില്ലെങ്കിൽ ഈ ഫീൽഡിൽ "No Negative" ഉണ്ടാകും
  • റിവ്യൂവർ നെഗറ്റീവ് റിവ്യൂ കോളത്തിൽ പോസിറ്റീവ് റിവ്യൂ എഴുതിയിരിക്കാം (ഉദാ: "ഈ ഹോട്ടലിൽ ഒന്നും തെറ്റില്ല")
• Review_Total_Negative_Word_Counts
  • ഉയർന്ന നെഗറ്റീവ് വാക്കുകളുടെ എണ്ണം കുറഞ്ഞ സ്കോർ സൂചിപ്പിക്കുന്നു (സെന്റിമെന്റ് പരിശോധിക്കാതെ)
• Positive_Review
  • റിവ്യൂവർ ഒന്നും എഴുതിയില്ലെങ്കിൽ "No Positive" കാണിക്കും
  • റിവ്യൂവർ പോസിറ്റീവ് റിവ്യൂ കോളത്തിൽ നെഗറ്റീവ് റിവ്യൂ എഴുതിയിരിക്കാം (ഉദാ: "ഈ ഹോട്ടലിൽ ഒന്നും നല്ലതല്ല")
• Review_Total_Positive_Word_Counts
  • ഉയർന്ന പോസിറ്റീവ് വാക്കുകളുടെ എണ്ണം ഉയർന്ന സ്കോർ സൂചിപ്പിക്കുന്നു (സെന്റിമെന്റ് പരിശോധിക്കാതെ)
• Review_Date and days_since_review
  • ഒരു റിവ്യൂവിന്റെ പുതുമ അല്ലെങ്കിൽ പഴക്കം അളക്കാൻ ഉപയോഗിക്കാം (പഴയ റിവ്യൂകൾ പുതിയവയെക്കാൾ കൃത്യമല്ലാതിരിക്കാം, കാരണം ഹോട്ടൽ മാനേജ്മെന്റ് മാറിയിരിക്കാം, നവീകരണങ്ങൾ നടന്നിരിക്കാം, പൂൾ ചേർത്തിരിക്കാം തുടങ്ങിയവ)
• Tags
  • റിവ്യൂവർ തങ്ങൾ എങ്ങനെ ഗസ്റ്റ് ആയിരുന്നുവെന്ന് (ഉദാ: സോളോ അല്ലെങ്കിൽ കുടുംബം), റൂം തരം, താമസ കാലാവധി, റിവ്യൂ സമർപ്പിച്ച ഉപകരണം എന്നിവ വിവരിക്കാൻ തിരഞ്ഞെടുക്കുന്ന ചെറിയ വിവരണങ്ങൾ
  • ദുർഭാഗ്യവശാൽ, ഈ ടാഗുകൾ ഉപയോഗിക്കുന്നത് പ്രശ്നകരമാണ്, താഴെ അവയുടെ പ്രയോജനത്തെക്കുറിച്ച് ചർച്ച ചെയ്തിട്ടുണ്ട്

റിവ്യൂവർ കോളങ്ങൾ

• Total_Number_of_Reviews_Reviewer_Has_Given
  • ശുപാർശ മോഡലിൽ ഇത് ഒരു ഘടകമായിരിക്കാം, ഉദാ: നൂറുകണക്കിന് റിവ്യൂവുകൾ എഴുതുന്നവർക്കു നെഗറ്റീവ് റിവ്യൂവുകൾ കൂടുതലായിരിക്കാം. എന്നാൽ ഓരോ റിവ്യൂവറെയും ഒരു പ്രത്യേക കോഡിൽ തിരിച്ചറിയുന്നില്ല, അതിനാൽ റിവ്യൂസെറ്റുമായി ബന്ധിപ്പിക്കാൻ കഴിയില്ല. 100-ൽ കൂടുതൽ റിവ്യൂവുകൾ ഉള്ള 30 റിവ്യൂവർമാർ ഉണ്ട്, പക്ഷേ ഇത് ശുപാർശ മോഡലിന് എങ്ങനെ സഹായകരമാകുമെന്ന് വ്യക്തമല്ല.
• Reviewer_Nationality
  • ചിലർ കരുതാം ചില ദേശീയതകൾ പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് റിവ്യൂ നൽകാൻ കൂടുതൽ സാധ്യതയുള്ളവരാണ്. ഇത്തരം അനുകരണങ്ങൾ നിങ്ങളുടെ മോഡലുകളിൽ ഉൾപ്പെടുത്തുമ്പോൾ ജാഗ്രത പാലിക്കുക. ഇവ ദേശീയ (കൂടാതെ ചിലപ്പോൾ ജാതി) സ്റ്റെറിയോട്ടൈപ്പുകളാണ്, ഓരോ റിവ്യൂവറും അവരുടെ അനുഭവത്തെ അടിസ്ഥാനമാക്കി റിവ്യൂ എഴുതിയ വ്യക്തിയാണ്. അവരുടെ മുൻ ഹോട്ടൽ stays, യാത്ര ദൂരം, വ്യക്തിഗത സ്വഭാവം തുടങ്ങിയവ വഴി ഫിൽട്ടർ ചെയ്തിരിക്കാം. അവരുടെ ദേശീയത റിവ്യൂ സ്കോറിന്റെ കാരണം ആണെന്ന് കരുതുന്നത് ന്യായീകരിക്കാൻ ബുദ്ധിമുട്ടാണ്.

ഉദാഹരണങ്ങൾ

ശരാശരി സ്കോർ	മൊത്തം റിവ്യൂവുകളുടെ എണ്ണം	റിവ്യൂവർ സ്കോർ	നെഗറ്റീവ് റിവ്യൂ	പോസിറ്റീവ് റിവ്യൂ	ടാഗുകൾ
7.8	1945	2.5	ഇത് ഇപ്പോൾ ഹോട്ടൽ അല്ല, ഒരു കൺസ്ട്രക്ഷൻ സൈറ്റ് ആണ്. ഞാൻ രാവിലെ മുതൽ വൈകിട്ട് വരെ അസഹ്യമായ കെട്ടിട ശബ്ദത്തിൽ പീഡിപ്പിക്കപ്പെട്ടു, ഒരു ദീർഘയാത്ര കഴിഞ്ഞ് മുറിയിൽ വിശ്രമിക്കുമ്പോൾ. ആളുകൾ മുഴുവൻ ദിവസം ജാക്ക്‌ഹാമറുകൾ ഉപയോഗിച്ച് സമീപ മുറികളിൽ ജോലി ചെയ്തു. ഞാൻ മുറി മാറ്റം ആവശ്യപ്പെട്ടു, പക്ഷേ ശാന്തമായ മുറി ലഭ്യമല്ലായിരുന്നു. കാര്യങ്ങൾ കൂടുതൽ മോശമാക്കി, ഞാൻ അധിക ചാർജ് ചെയ്തു. വൈകിട്ട് ഞാൻ ചെക്ക് ഔട്ട് ചെയ്തു, കാരണം എനിക്ക് വളരെ പെട്ടെന്ന് പുറപ്പെടേണ്ടി വന്നു, അനുയോജ്യമായ ബിൽ ലഭിച്ചു. ഒരു ദിവസം കഴിഞ്ഞ് ഹോട്ടൽ എന്റെ സമ്മതം കൂടാതെ ബുക്ക് ചെയ്ത വിലക്ക് മുകളിൽ മറ്റൊരു ചാർജ് ചെയ്തു. ഇത് ഭയങ്കരമായ സ്ഥലം ആണ്. ഇവിടെ ബുക്ക് ചെയ്ത് സ്വയം ശിക്ഷിക്കരുത്	ഒന്നും ഭയങ്കരമായ സ്ഥലം, അകലം പാലിക്കുക	ബിസിനസ് യാത്ര, ദമ്പതികൾ, സ്റ്റാൻഡേർഡ് ഡബിൾ റൂം, 2 രാത്രി താമസിച്ചു

ഇവിടെ കാണുന്നതുപോലെ, ഈ ഗസ്റ്റ് ഹോട്ടലിൽ സന്തോഷകരമായ താമസം ഉണ്ടായില്ല. ഹോട്ടലിന് 7.8 എന്ന നല്ല ശരാശരി സ്കോർ ഉണ്ട്, 1945 റിവ്യൂവുകൾ ഉണ്ട്, പക്ഷേ ഈ റിവ്യൂവർ 2.5 സ്കോർ നൽകി, അവരുടെ നെഗറ്റീവ് താമസത്തെക്കുറിച്ച് 115 വാക്കുകൾ എഴുതിയിട്ടുണ്ട്. അവർ പോസിറ്റീവ്_റിവ്യൂ കോളത്തിൽ ഒന്നും എഴുതിയില്ലെങ്കിൽ, പോസിറ്റീവ് ഒന്നും ഇല്ലെന്ന് നമുക്ക് തോന്നാമായിരുന്നു, പക്ഷേ അവർ മുന്നറിയിപ്പായി 7 വാക്കുകൾ എഴുതിയിട്ടുണ്ട്. വാക്കുകളുടെ അർത്ഥം അല്ലെങ്കിൽ സെന്റിമെന്റ് പരിശോധിക്കാതെ വാക്കുകൾ മാത്രം എണ്ണിയാൽ റിവ്യൂവറുടെ ഉദ്ദേശം തെറ്റായി മനസ്സിലാക്കാം. അതിശയകരമായി, 2.5 എന്ന സ്കോർ ആശയക്കുഴപ്പമാണ്, കാരണം ഹോട്ടൽ താമസം അത്ര മോശമായിരുന്നെങ്കിൽ എന്തുകൊണ്ട് ഏതെങ്കിലും പോയിന്റ് നൽകുന്നു? ഡാറ്റാസെറ്റ് നന്നായി പരിശോധിച്ചാൽ, ഏറ്റവും കുറഞ്ഞ സ്കോർ 2.5 ആണ്, 0 അല്ല. ഏറ്റവും ഉയർന്ന സ്കോർ 10 ആണ്.

ടാഗുകൾ

മുകളിൽ പറഞ്ഞതുപോലെ, ആദ്യം നോക്കുമ്പോൾ Tags ഉപയോഗിച്ച് ഡാറ്റ വർഗ്ഗീകരിക്കാനുള്ള ആശയം ശരിയാണെന്ന് തോന്നും. ദുർഭാഗ്യവശാൽ, ഈ ടാഗുകൾ സ്റ്റാൻഡേർഡൈസ് ചെയ്തിട്ടില്ല, അതായത് ഒരു ഹോട്ടലിൽ Single room, Twin room, Double room എന്നിങ്ങനെ ഓപ്ഷനുകൾ ഉണ്ടാകാം, അടുത്ത ഹോട്ടലിൽ Deluxe Single Room, Classic Queen Room, Executive King Room എന്നിങ്ങനെ. ഇവ ഒരേ കാര്യങ്ങളായിരിക്കാം, പക്ഷേ വ്യത്യാസങ്ങൾ വളരെ കൂടുതലാണ്, അതിനാൽ തിരഞ്ഞെടുപ്പ്:

1. എല്ലാ പദങ്ങളും ഒരു സ്റ്റാൻഡേർഡ് രൂപത്തിലേക്ക് മാറ്റാൻ ശ്രമിക്കുക, ഇത് വളരെ പ്രയാസമാണ്, കാരണം ഓരോ കേസിലും മാറ്റം എങ്ങനെ വരുമെന്ന് വ്യക്തമല്ല (ഉദാ: Classic single room Single room ആയി മാപ്പ് ചെയ്യാം, പക്ഷേ Superior Queen Room with Courtyard Garden or City View മാപ്പ് ചെയ്യുന്നത് വളരെ പ്രയാസമാണ്)

2. NLP സമീപനം സ്വീകരിച്ച് Solo, Business Traveller, Family with young kids പോലുള്ള പദങ്ങളുടെ ആവൃത്തി ഓരോ ഹോട്ടലിലും എങ്ങനെ ഉണ്ടെന്ന് അളക്കുക, അത് ശുപാർശയിൽ ഉൾപ്പെടുത്തുക

ടാഗുകൾ സാധാരണയായി (എല്ലാവരും അല്ല) ഒരു ഫീൽഡിൽ 5-6 കോമ കൊണ്ട് വേർതിരിച്ച മൂല്യങ്ങളുടെ പട്ടികയാണുള്ളത്, അവ യാത്രയുടെ തരം, ഗസ്റ്റ് തരം, റൂം തരം, താമസ നൈറ്റ് എണ്ണം, റിവ്യൂ സമർപ്പിച്ച ഉപകരണം എന്നിവയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. എന്നാൽ ചില റിവ്യൂവർമാർ ഓരോ ഫീൽഡും പൂരിപ്പിക്കാത്തതിനാൽ (ഒന്ന് ഒഴിവാക്കാം), മൂല്യങ്ങൾ എല്ലായ്പ്പോഴും ഒരേ ക്രമത്തിൽ ഇല്ല.

ഉദാഹരണമായി, Type of group എടുത്തു നോക്കാം. Tags കോളത്തിൽ ഈ ഫീൽഡിൽ 1025 വ്യത്യസ്ത സാധ്യതകൾ ഉണ്ട്, ദുർഭാഗ്യവശാൽ അവയിൽ ചിലത് ഗ്രൂപ്പിനെ സൂചിപ്പിക്കുന്നവ മാത്രമാണ് (ചിലത് റൂം തരം മുതലായവ). കുടുംബം എന്ന പദം ഉൾപ്പെടുന്നവ മാത്രം ഫിൽട്ടർ ചെയ്താൽ, ഫലങ്ങളിൽ Family room തരം ഫലങ്ങൾ കൂടുതലാണ്. with എന്ന പദം ഉൾപ്പെടുത്തുമ്പോൾ, ഉദാ: Family with മൂല്യങ്ങൾ എണ്ണുമ്പോൾ, ഫലങ്ങൾ മെച്ചമാണ്, 515,000 ഫലങ്ങളിൽ 80,000-ത്തിലധികം "Family with young children" അല്ലെങ്കിൽ "Family with older children" എന്ന വാചകങ്ങൾ ഉൾക്കൊള്ളുന്നു.

ഇത് ടാഗ് കോളം നമുക്ക് പൂർണ്ണമായും ഉപകാരമില്ലാത്തതല്ല, പക്ഷേ ഉപയോഗപ്രദമാക്കാൻ കുറച്ച് ജോലി വേണം.

ശരാശരി ഹോട്ടൽ സ്കോർ

ഡാറ്റാസെറ്റിൽ ചില അസാധാരണതകളും വ്യത്യാസങ്ങളും ഉണ്ട്, ഞാൻ കണ്ടെത്താനായില്ല, പക്ഷേ നിങ്ങൾക്ക് അവ അറിയാമാകാൻ ഇവിടെ കാണിക്കുന്നു. നിങ്ങൾ കണ്ടെത്തിയാൽ, ദയവായി ചർച്ചാ വിഭാഗത്തിൽ അറിയിക്കുക!

ഡാറ്റാസെറ്റിൽ ശരാശരി സ്കോർ, റിവ്യൂവുകളുടെ എണ്ണം സംബന്ധിച്ച കോളങ്ങൾ:

1. Hotel_Name
2. Additional_Number_of_Scoring
3. Average_Score
4. Total_Number_of_Reviews
5. Reviewer_Score

ഈ ഡാറ്റാസെറ്റിലെ ഏറ്റവും കൂടുതൽ റിവ്യൂവുകൾ ഉള്ള ഹോട്ടൽ Britannia International Hotel Canary Wharf ആണ്, 515,000-ൽ 4789 റിവ്യൂവുകൾ. എന്നാൽ ഈ ഹോട്ടലിന്റെ Total_Number_of_Reviews മൂല്യം 9086 ആണ്. റിവ്യൂ ഇല്ലാതെ സ്കോർ നൽകിയവ കൂടുതലാണെന്ന് കരുതാം, അതിനാൽ Additional_Number_of_Scoring മൂല്യം ചേർക്കാം. അത് 2682 ആണ്, 4789-ൽ ചേർത്താൽ 7,471 ആകുന്നു, ഇത് Total_Number_of_Reviews-നേക്കാൾ 1615 കുറവാണ്.

Average_Score കോളം നോക്കുമ്പോൾ, ഇത് ഡാറ്റാസെറ്റിലെ റിവ്യൂവുകളുടെ ശരാശരി ആണെന്ന് കരുതാം, പക്ഷേ Kaggle-ൽ വിവരണം "കഴിഞ്ഞ വർഷം ഏറ്റവും പുതിയ കമന്റിന്റെ അടിസ്ഥാനത്തിൽ കണക്കാക്കിയ ഹോട്ടലിന്റെ ശരാശരി സ്കോർ" എന്നാണ്. ഇത് പ്രയോജനകരമല്ലെന്ന് തോന്നുന്നു, പക്ഷേ നമുക്ക് ഡാറ്റാസെറ്റിലെ റിവ്യൂ സ്കോറുകൾ അടിസ്ഥാനമാക്കി നമ്മുടെ സ്വന്തം ശരാശരി കണക്കാക്കാം. അതേ ഹോട്ടൽ ഉദാഹരണമായി എടുത്താൽ, ശരാശരി ഹോട്ടൽ സ്കോർ 7.1 ആണ്, പക്ഷേ കണക്കാക്കിയ സ്കോർ (ഡാറ്റാസെറ്റിലെ ശരാശരി റിവ്യൂവർ സ്കോർ) 6.8 ആണ്. ഇത് അടുത്തതാണ്, പക്ഷേ സമാനമല്ല, Additional_Number_of_Scoring റിവ്യൂവുകൾ ശരാശരിയിൽ 7.1 വരെ വർദ്ധിപ്പിച്ചിരിക്കാമെന്ന് നമുക്ക് കരുതാം. എന്നാൽ അത് പരിശോധിക്കാനോ തെളിയിക്കാനോ കഴിയാത്തതിനാൽ, Average_Score, Additional_Number_of_Scoring, Total_Number_of_Reviews എന്നിവ ഉപയോഗിക്കാനും വിശ്വസിക്കാനും ബുദ്ധിമുട്ടാണ്, കാരണം അവ ഡാറ്റ നമുക്ക് ഇല്ലാത്തതിൽ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.

കൂടുതൽ സങ്കീർണ്ണമാക്കാൻ, രണ്ടാമത്തെ ഏറ്റവും കൂടുതൽ റിവ്യൂവുകൾ ഉള്ള ഹോട്ടലിന്റെ കണക്കാക്കിയ ശരാശരി സ്കോർ 8.12 ആണ്, ഡാറ്റാസെറ്റിലെ Average_Score 8.1 ആണ്. ഇത് യാദൃച്ഛികമാണോ, ആദ്യ ഹോട്ടലിലെ വ്യത്യാസമാണോ? ഈ ഹോട്ടൽ ഒരു ഔട്ട്‌ലൈയർ ആകാമെന്ന സാധ്യതയും, മിക്ക മൂല്യങ്ങളും പൊരുത്തപ്പെടുന്നുണ്ടാകാം (പക്ഷേ ചിലത് എന്തോ കാരണത്താൽ പൊരുത്തപ്പെടുന്നില്ല) എന്നതിനാൽ, ഡാറ്റാസെറ്റിലെ മൂല്യങ്ങൾ പരിശോധിച്ച് ശരിയായ ഉപയോഗം (അഥവാ ഉപയോഗം ഇല്ലാതാക്കൽ) നിർണയിക്കാൻ അടുത്തതായി ഒരു ചെറിയ പ്രോഗ്രാം എഴുതും.

🚨 ഒരു ജാഗ്രതാ കുറിപ്പ്

ഈ ഡാറ്റാസെറ്റുമായി ജോലി ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് ടെക്സ്റ്റിൽ നിന്ന് എന്തെങ്കിലും കണക്കാക്കുന്ന കോഡ് എഴുതേണ്ടി വരും, എന്നാൽ നിങ്ങൾക്ക് ടെക്സ്റ്റ് വായിക്കുകയോ വിശകലനം ചെയ്യുകയോ ചെയ്യേണ്ടതില്ല. ഇത് NLP യുടെ സാരാംശമാണ്, മനുഷ്യൻ ചെയ്യാതെ അർത്ഥം അല്ലെങ്കിൽ മനോഭാവം വ്യാഖ്യാനിക്കുന്നത്. എങ്കിലും, നിങ്ങൾ ചില നെഗറ്റീവ് റിവ്യൂകൾ വായിക്കേണ്ടി വരാം. ഞാൻ നിങ്ങളോട് അത് ചെയ്യാതിരിക്കാൻ അഭ്യർത്ഥിക്കുന്നു, കാരണം അതിന് ആവശ്യമില്ല. ചിലത് മണ്ടത്തരം അല്ലെങ്കിൽ പ്രസക്തമല്ലാത്ത നെഗറ്റീവ് ഹോട്ടൽ റിവ്യൂകൾ ആണ്, ഉദാഹരണത്തിന് "കാലാവസ്ഥ നല്ലതായിരുന്നില്ല", ഹോട്ടലിന്റെ നിയന്ത്രണത്തിന് പുറത്തുള്ള കാര്യം, അല്ലെങ്കിൽ യാതൊരു വ്യക്തിയുടെയും. എന്നാൽ ചില റിവ്യൂകളിൽ ഇരുണ്ട വശവും ഉണ്ട്. ചിലപ്പോൾ നെഗറ്റീവ് റിവ്യൂകൾ ജാതിവാദപരമായോ, ലിംഗവാദപരമായോ, പ്രായഭേദപരമായോ ആയിരിക്കും. ഇത് ദുർഭാഗ്യകരമാണ്, പക്ഷേ പൊതുജന വെബ്സൈറ്റിൽ നിന്നുള്ള ഡാറ്റാസെറ്റിൽ പ്രതീക്ഷിക്കാവുന്നതാണ്. ചില റിവ്യൂവഴി നിങ്ങൾക്ക് അസ്വസ്ഥതയോ, അസ്വസ്ഥതയോ, വിഷമതയോ ഉണ്ടാകാം. കോഡ് മനോഭാവം അളക്കട്ടെ, നിങ്ങൾ തന്നെ വായിച്ച് വിഷമിക്കേണ്ടതില്ല. എന്നാൽ ഇത്തരത്തിലുള്ളവ കുറവാണ്, പക്ഷേ അവ ഉണ്ടെന്നതാണ്.

അഭ്യാസം - ഡാറ്റാ എക്സ്പ്ലോറേഷൻ

ഡാറ്റ ലോഡ് ചെയ്യുക

ഡാറ്റ ദൃശ്യമായി പരിശോധിക്കാൻ ഇത്രയും മതി, ഇനി നിങ്ങൾക്ക് കോഡ് എഴുതിയും ചില ഉത്തരങ്ങൾ കണ്ടെത്തിയും നോക്കാം! ഈ ഭാഗം pandas ലൈബ്രറി ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ ആദ്യത്തെ ജോലി CSV ഡാറ്റ ലോഡ് ചെയ്ത് വായിക്കാൻ കഴിയുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക. pandas ലൈബ്രറിയിൽ വേഗത്തിലുള്ള CSV ലോഡർ ഉണ്ട്, ഫലം ഒരു ഡാറ്റാഫ്രെയിമിൽ സൂക്ഷിക്കുന്നു, മുമ്പത്തെ പാഠങ്ങളിലുപോലെ. ലോഡ് ചെയ്യുന്ന CSV-യിൽ അർധമില്യൺ ലൈനുകൾക്കു മുകളിൽ ഉണ്ട്, പക്ഷേ 17 കോളങ്ങൾ മാത്രം. pandas ഡാറ്റാഫ്രെയിമുമായി ഇടപഴകാൻ ശക്തമായ മാർഗങ്ങൾ നൽകുന്നു, ഓരോ വരിയിലും പ്രവർത്തനങ്ങൾ നടത്താനുള്ള കഴിവ് ഉൾപ്പെടെ.

ഇവിടെ നിന്നു തുടർന്നുള്ള പാഠത്തിൽ, കോഡ് സ്നിപ്പറ്റുകളും ചില വിശദീകരണങ്ങളും ഫലങ്ങളുടെ അർത്ഥം സംബന്ധിച്ച ചർച്ചകളും ഉണ്ടാകും. നിങ്ങളുടെ കോഡിനായി ഉൾപ്പെടുത്തിയ notebook.ipynb ഉപയോഗിക്കുക.

നിങ്ങൾ ഉപയോഗിക്കുന്ന ഡാറ്റ ഫയൽ ലോഡ് ചെയ്യുന്നതിൽ നിന്ന് തുടങ്ങാം:

# CSV-ൽ നിന്ന് ഹോട്ടൽ റിവ്യൂകൾ ലോഡ് ചെയ്യുക
import pandas as pd
import time
# ഫയൽ ലോഡിംഗ് സമയം കണക്കാക്കാൻ ആരംഭവും അവസാനവും സമയങ്ങൾ ഉപയോഗിക്കാൻ time ഇംപോർട്ട് ചെയ്യുന്നു
print("Loading data file now, this could take a while depending on file size")
start = time.time()
# df 'DataFrame' ആണ് - ഫയൽ data ഫോൾഡറിൽ ഡൗൺലോഡ് ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക
df = pd.read_csv('../../data/Hotel_Reviews.csv')
end = time.time()
print("Loading took " + str(round(end - start, 2)) + " seconds")

ഇപ്പോൾ ഡാറ്റ ലോഡ് ചെയ്തതിനുശേഷം, അതിൽ ചില പ്രവർത്തനങ്ങൾ നടത്താം. അടുത്ത ഭാഗത്തിനായി ഈ കോഡ് നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ മുകളിൽ സൂക്ഷിക്കുക.

ഡാറ്റ എക്സ്പ്ലോർ ചെയ്യുക

ഈ കേസിൽ, ഡാറ്റ ഇതിനകം ശുദ്ധമാണ്, അതായത് ഇത് ഉപയോഗിക്കാൻ തയ്യാറാണ്, ഇംഗ്ലീഷ് അക്ഷരങ്ങൾ മാത്രമേ പ്രതീക്ഷിക്കുന്നുള്ള ആൽഗോരിതങ്ങൾ തടസ്സപ്പെടാതിരിക്കാൻ മറ്റ് ഭാഷകളിലെ അക്ഷരങ്ങൾ ഇല്ല.

✅ ചിലപ്പോൾ നിങ്ങൾക്ക് NLP സാങ്കേതികവിദ്യകൾ പ്രയോഗിക്കുന്നതിന് മുമ്പ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യേണ്ടി വരാം, പക്ഷേ ഈ തവണ അതില്ല. നിങ്ങൾ ചെയ്യേണ്ടി വന്നിരുന്നെങ്കിൽ, നിങ്ങൾ എങ്ങനെ ഇംഗ്ലീഷ് അല്ലാത്ത അക്ഷരങ്ങൾ കൈകാര്യം ചെയ്യുമായിരുന്നു?

ഡാറ്റ ലോഡ് ചെയ്ത ശേഷം, കോഡിലൂടെ അത് എങ്ങനെ എക്സ്പ്ലോർ ചെയ്യാമെന്ന് ഉറപ്പാക്കാൻ ഒരു നിമിഷം ചെലവഴിക്കുക. Negative_Review ഉം Positive_Review ഉം കോളങ്ങൾക്കു മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ എളുപ്പമാണ്. അവ നിങ്ങളുടെ NLP ആൽഗോരിതങ്ങൾ പ്രോസസ്സ് ചെയ്യാൻ സ്വാഭാവിക ടെക്സ്റ്റ് നിറച്ചിരിക്കുന്നു. പക്ഷേ കാത്തിരിക്കുക! NLP-യിലും മനോഭാവത്തിലും ചാടുന്നതിന് മുമ്പ്, ഡാറ്റാസെറ്റിൽ നൽകിയ മൂല്യങ്ങൾ pandas ഉപയോഗിച്ച് നിങ്ങൾ കണക്കാക്കിയ മൂല്യങ്ങളുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് താഴെ കൊടുത്തിരിക്കുന്ന കോഡ് പിന്തുടർന്ന് പരിശോധിക്കുക.

ഡാറ്റാഫ്രെയിം പ്രവർത്തനങ്ങൾ

ഈ പാഠത്തിലെ ആദ്യത്തെ ജോലി, ഡാറ്റാഫ്രെയിം പരിശോധിക്കുന്ന (മാറ്റം വരുത്താതെ) ചില കോഡ് എഴുതിയാണ് താഴെ കൊടുത്തിരിക്കുന്ന അവകാശവാദങ്ങൾ ശരിയാണോ എന്ന് പരിശോധിക്കുക.

പല പ്രോഗ്രാമിംഗ് ജോലികളിലും, ഇത് പൂർത്തിയാക്കാനുള്ള പല മാർഗ്ഗങ്ങളുണ്ട്, പക്ഷേ നല്ല ഉപദേശം, ഇത് എളുപ്പവും മനസ്സിലാക്കാൻ എളുപ്പവുമായ രീതിയിൽ ചെയ്യുക, പ്രത്യേകിച്ച് ഈ കോഡിലേക്ക് വീണ്ടും വരുമ്പോൾ. ഡാറ്റാഫ്രെയിമുകളിൽ, നിങ്ങൾക്ക് സാധാരണയായി ആവശ്യമായ കാര്യങ്ങൾ കാര്യക്ഷമമായി ചെയ്യാനുള്ള സമഗ്ര API ഉണ്ട്.

താഴെ കൊടുത്തിരിക്കുന്ന ചോദ്യങ്ങളെ കോഡിംഗ് ടാസ്കുകളായി പരിഗണിച്ച് പരിഹാരമില്ലാതെ അവയ്ക്ക് ശ്രമിക്കുക.

1. നിങ്ങൾ ഇപ്പോൾ ലോഡ് ചെയ്ത ഡാറ്റാഫ്രെയിമിന്റെ ആകൃതി പ്രിന്റ് ചെയ്യുക (ആകൃതി എന്നത് വരികളും കോളങ്ങളുമാണ്)
2. റിവ്യൂവറുടെ ദേശീയതയുടെ ഫ്രീക്വൻസി കണക്കാക്കുക:
   1. Reviewer_Nationality കോളത്തിനുള്ള വ്യത്യസ്ത മൂല്യങ്ങൾ എത്രയും എന്തെല്ലാം?
   2. ഡാറ്റാസെറ്റിൽ ഏറ്റവും സാധാരണമായ റിവ്യൂവർ ദേശീയത ഏതാണ് (രാജ്യവും റിവ്യൂവുകളുടെ എണ്ണവും പ്രിന്റ് ചെയ്യുക)?
   3. അടുത്ത 10 ഏറ്റവും സാധാരണമായ ദേശീയതകളും അവയുടെ ഫ്രീക്വൻസി കണക്കുകളും എന്തെല്ലാം?
3. ടോപ്പ് 10 റിവ്യൂവർ ദേശീയതകളിൽ ഓരോന്നിനും ഏറ്റവും കൂടുതൽ റിവ്യൂ ലഭിച്ച ഹോട്ടൽ ഏതാണ്?
4. ഡാറ്റാസെറ്റിൽ ഓരോ ഹോട്ടലിനും എത്ര റിവ്യൂവുകൾ ഉണ്ട് (ഹോട്ടലിന്റെ ഫ്രീക്വൻസി കണക്കുകൾ)?
5. ഡാറ്റാസെറ്റിൽ ഓരോ ഹോട്ടലിനും Average_Score കോളം ഉണ്ടെങ്കിലും, നിങ്ങൾക്ക് ഓരോ ഹോട്ടലിനും ഡാറ്റാസെറ്റിലെ എല്ലാ റിവ്യൂവറുടെ സ്കോറുകളുടെ ശരാശരി കണക്കാക്കാം. കണക്കാക്കിയ ശരാശരി അടങ്ങിയ Calc_Average_Score എന്ന പുതിയ കോളം നിങ്ങളുടെ ഡാറ്റാഫ്രെയിമിൽ ചേർക്കുക.
6. ഏതെങ്കിലും ഹോട്ടലുകൾക്ക് (1 ദശാംശ സ്ഥാനം വരെ വട്ടംചുറ്റിയപ്പോൾ) Average_Score ഉം Calc_Average_Score ഉം ഒരുപോലെയുണ്ടോ?
   1. ഒരു Python ഫംഗ്ഷൻ എഴുതാൻ ശ്രമിക്കുക, അത് ഒരു Series (വരി) аргументായി സ്വീകരിച്ച് മൂല്യങ്ങൾ താരതമ്യം ചെയ്ത്, മൂല്യങ്ങൾ തുല്യമായില്ലെങ്കിൽ സന്ദേശം പ്രിന്റ് ചെയ്യുന്നു. പിന്നീട് .apply() മെത്തഡ് ഉപയോഗിച്ച് എല്ലാ വരികളും പ്രോസസ്സ് ചെയ്യുക.
7. Negative_Review കോളത്തിൽ "No Negative" ഉള്ള വരികളുടെ എണ്ണം കണക്കാക്കി പ്രിന്റ് ചെയ്യുക
8. Positive_Review കോളത്തിൽ "No Positive" ഉള്ള വരികളുടെ എണ്ണം കണക്കാക്കി പ്രിന്റ് ചെയ്യുക
9. Positive_Review കോളത്തിൽ "No Positive" ഉം Negative_Review കോളത്തിൽ "No Negative" ഉള്ള വരികളുടെ എണ്ണം കണക്കാക്കി പ്രിന്റ് ചെയ്യുക

കോഡ് ഉത്തരങ്ങൾ

1. നിങ്ങൾ ഇപ്പോൾ ലോഡ് ചെയ്ത ഡാറ്റാഫ്രെയിമിന്റെ ആകൃതി പ്രിന്റ് ചെയ്യുക (ആകൃതി എന്നത് വരികളും കോളങ്ങളുമാണ്)

   print("The shape of the data (rows, cols) is " + str(df.shape))
   > The shape of the data (rows, cols) is (515738, 17)
   

2. റിവ്യൂവർ ദേശീയതയുടെ ഫ്രീക്വൻസി കണക്കാക്കുക:

   1. Reviewer_Nationality കോളത്തിനുള്ള വ്യത്യസ്ത മൂല്യങ്ങൾ എത്രയും എന്തെല്ലാം?
   2. ഡാറ്റാസെറ്റിൽ ഏറ്റവും സാധാരണമായ റിവ്യൂവർ ദേശീയത ഏതാണ് (രാജ്യവും റിവ്യൂവുകളുടെ എണ്ണവും പ്രിന്റ് ചെയ്യുക)?

   # value_counts() ഒരു സീരീസ് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു, ഇതിൽ ഇൻഡക്സ് കൂടാതെ മൂല്യങ്ങളും ഉണ്ടാകുന്നു, ഈ കേസിൽ, രാജ്യവും അവ അവലോകനകാരന്റെ ദേശീയതയിൽ ഉണ്ടാകുന്ന ആവർത്തനവും ആണ്
   nationality_freq = df["Reviewer_Nationality"].value_counts()
   print("There are " + str(nationality_freq.size) + " different nationalities")
   # സീരീസിന്റെ ആദ്യവും അവസാനവും വരികൾ പ്രിന്റ് ചെയ്യുക. എല്ലാ ഡാറ്റയും പ്രിന്റ് ചെയ്യാൻ nationality_freq.to_string() ആയി മാറ്റുക
   print(nationality_freq) 
   
   There are 227 different nationalities
    United Kingdom               245246
    United States of America      35437
    Australia                     21686
    Ireland                       14827
    United Arab Emirates          10235
                                  ...  
    Comoros                           1
    Palau                             1
    Northern Mariana Islands          1
    Cape Verde                        1
    Guinea                            1
   Name: Reviewer_Nationality, Length: 227, dtype: int64
   

   3. അടുത്ത 10 ഏറ്റവും സാധാരണമായ ദേശീയതകളും അവയുടെ ഫ്രീക്വൻസി കണക്കുകളും എന്തെല്ലാം?

      print("The highest frequency reviewer nationality is " + str(nationality_freq.index[0]).strip() + " with " + str(nationality_freq[0]) + " reviews.")
      # മൂല്യങ്ങളിൽ ഒരു മുൻനിര സ്ഥലം കാണുക, പ്രിന്റ് ചെയ്യുന്നതിനായി strip() അത് നീക്കം ചെയ്യുന്നു
      # ഏറ്റവും സാധാരണമായ 10 ദേശീയതകളും അവയുടെ ആവർത്തനങ്ങളും എന്തൊക്കെയാണ്?
      print("The next 10 highest frequency reviewer nationalities are:")
      print(nationality_freq[1:11].to_string())
      
      The highest frequency reviewer nationality is United Kingdom with 245246 reviews.
      The next 10 highest frequency reviewer nationalities are:
       United States of America     35437
       Australia                    21686
       Ireland                      14827
       United Arab Emirates         10235
       Saudi Arabia                  8951
       Netherlands                   8772
       Switzerland                   8678
       Germany                       7941
       Canada                        7894
       France                        7296
      

3. ടോപ്പ് 10 റിവ്യൂവർ ദേശീയതകളിൽ ഓരോന്നിനും ഏറ്റവും കൂടുതൽ റിവ്യൂ ലഭിച്ച ഹോട്ടൽ ഏതാണ്?

   # മുകളിൽ 10 ദേശീയതകളിൽ ഏറ്റവും അധികം അവലോകനം ചെയ്ത ഹോട്ടൽ ഏതാണ്
   # സാധാരണയായി pandas ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾ വ്യക്തമായ ലൂപ്പ് ഒഴിവാക്കും, പക്ഷേ മാനദണ്ഡങ്ങൾ ഉപയോഗിച്ച് പുതിയ ഡാറ്റാഫ്രെയിം സൃഷ്ടിക്കുന്നത് കാണിക്കാൻ ആഗ്രഹിച്ചു (വലിയ ഡാറ്റയുമായി ഇത് ചെയ്യരുത് കാരണം ഇത് വളരെ മന്ദഗതിയാകാം)
   for nat in nationality_freq[:10].index:
      # ആദ്യം, മാനദണ്ഡങ്ങൾ പാലിക്കുന്ന എല്ലാ വരികളും പുതിയ ഡാറ്റാഫ്രെയിമിലേക്ക് എടുക്കുക
      nat_df = df[df["Reviewer_Nationality"] == nat]   
      # ഇപ്പോൾ ഹോട്ടലിന്റെ ആവർത്തനസംഖ്യ നേടുക
      freq = nat_df["Hotel_Name"].value_counts()
      print("The most reviewed hotel for " + str(nat).strip() + " was " + str(freq.index[0]) + " with " + str(freq[0]) + " reviews.") 
   
   The most reviewed hotel for United Kingdom was Britannia International Hotel Canary Wharf with 3833 reviews.
   The most reviewed hotel for United States of America was Hotel Esther a with 423 reviews.
   The most reviewed hotel for Australia was Park Plaza Westminster Bridge London with 167 reviews.
   The most reviewed hotel for Ireland was Copthorne Tara Hotel London Kensington with 239 reviews.
   The most reviewed hotel for United Arab Emirates was Millennium Hotel London Knightsbridge with 129 reviews.
   The most reviewed hotel for Saudi Arabia was The Cumberland A Guoman Hotel with 142 reviews.
   The most reviewed hotel for Netherlands was Jaz Amsterdam with 97 reviews.
   The most reviewed hotel for Switzerland was Hotel Da Vinci with 97 reviews.
   The most reviewed hotel for Germany was Hotel Da Vinci with 86 reviews.
   The most reviewed hotel for Canada was St James Court A Taj Hotel London with 61 reviews.
   

4. ഡാറ്റാസെറ്റിൽ ഓരോ ഹോട്ടലിനും എത്ര റിവ്യൂവുകൾ ഉണ്ട് (ഹോട്ടലിന്റെ ഫ്രീക്വൻസി കണക്കുകൾ)?

   # പഴയ ഡാറ്റാഫ്രെയിമിനെ അടിസ്ഥാനമാക്കി പുതിയ ഒരു ഡാറ്റാഫ്രെയിം സൃഷ്ടിക്കുക, ആവശ്യമില്ലാത്ത കോളങ്ങൾ നീക്കംചെയ്യുക
   hotel_freq_df = df.drop(["Hotel_Address", "Additional_Number_of_Scoring", "Review_Date", "Average_Score", "Reviewer_Nationality", "Negative_Review", "Review_Total_Negative_Word_Counts", "Positive_Review", "Review_Total_Positive_Word_Counts", "Total_Number_of_Reviews_Reviewer_Has_Given", "Reviewer_Score", "Tags", "days_since_review", "lat", "lng"], axis = 1)
   
   # Hotel_Name പ്രകാരം വരികൾ ഗ്രൂപ്പുചെയ്യുക, അവയുടെ എണ്ണം കണക്കാക്കുക, ഫലം Total_Reviews_Found എന്ന പുതിയ കോളത്തിൽ ഇടുക
   hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count')
   
   # എല്ലാ പുനരാവൃത വരികളും നീക്കംചെയ്യുക
   hotel_freq_df = hotel_freq_df.drop_duplicates(subset = ["Hotel_Name"])
   display(hotel_freq_df) 
   

   Hotel_Name	Total_Number_of_Reviews	Total_Reviews_Found
   Britannia International Hotel Canary Wharf	9086	4789
   Park Plaza Westminster Bridge London	12158	4169
   Copthorne Tara Hotel London Kensington	7105	3578
   ...	...	...
   Mercure Paris Porte d Orleans	110	10
   Hotel Wagner	135	10
   Hotel Gallitzinberg	173	8

   നിങ്ങൾ ശ്രദ്ധിക്കാം, ഡാറ്റാസെറ്റിൽ കണക്കാക്കിയ ഫലങ്ങൾ Total_Number_of_Reviews-നുള്ള മൂല്യവുമായി പൊരുത്തപ്പെടുന്നില്ല. ഈ മൂല്യം ഹോട്ടലിന് ഉണ്ടായ മൊത്തം റിവ്യൂവുകളുടെ എണ്ണം പ്രതിനിധീകരിക്കുന്നുണ്ടോ, അല്ലെങ്കിൽ എല്ലാം സ്ക്രാപ്പ് ചെയ്തിട്ടില്ല, അല്ലെങ്കിൽ മറ്റേതെങ്കിലും കണക്കുകൂട്ടലാണോ എന്ന് വ്യക്തമല്ല. ഈ അനിശ്ചിതത്വം കാരണം Total_Number_of_Reviews മോഡലിൽ ഉപയോഗിക്കുന്നില്ല.

5. ഡാറ്റാസെറ്റിൽ ഓരോ ഹോട്ടലിനും Average_Score കോളം ഉണ്ടെങ്കിലും, നിങ്ങൾക്ക് ഓരോ ഹോട്ടലിനും ഡാറ്റാസെറ്റിലെ എല്ലാ റിവ്യൂവറുടെ സ്കോറുകളുടെ ശരാശരി കണക്കാക്കാം. കണക്കാക്കിയ ശരാശരി അടങ്ങിയ Calc_Average_Score എന്ന പുതിയ കോളം നിങ്ങളുടെ ഡാറ്റാഫ്രെയിമിൽ ചേർക്കുക. Hotel_Name, Average_Score, Calc_Average_Score കോളങ്ങൾ പ്രിന്റ് ചെയ്യുക.

   # ഒരു വരി സ്വീകരിച്ച് അതുമായി ചില കണക്കുകൂട്ടലുകൾ നടത്തുന്ന ഒരു ഫംഗ്ഷൻ നിർവചിക്കുക
   def get_difference_review_avg(row):
     return row["Average_Score"] - row["Calc_Average_Score"]
   
   # 'mean' എന്നത് 'ശരാശരി' എന്ന ഗണിതപരമായ പദമാണ്
   df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1)
   
   # രണ്ട് ശരാശരി സ്കോറുകൾ തമ്മിലുള്ള വ്യത്യാസം ഉൾപ്പെടുന്ന ഒരു പുതിയ കോളം ചേർക്കുക
   df["Average_Score_Difference"] = df.apply(get_difference_review_avg, axis = 1)
   
   # Hotel_Name ന്റെ എല്ലാ പകർപ്പുകളും ഇല്ലാത്ത ഒരു df സൃഷ്ടിക്കുക (അതായത് ഓരോ ഹോട്ടലിനും 1 വരി മാത്രം)
   review_scores_df = df.drop_duplicates(subset = ["Hotel_Name"])
   
   # ഏറ്റവും കുറഞ്ഞതും ഏറ്റവും ഉയർന്നതുമായ ശരാശരി സ്കോർ വ്യത്യാസം കണ്ടെത്താൻ ഡാറ്റാഫ്രെയിം സോർട്ട് ചെയ്യുക
   review_scores_df = review_scores_df.sort_values(by=["Average_Score_Difference"])
   
   display(review_scores_df[["Average_Score_Difference", "Average_Score", "Calc_Average_Score", "Hotel_Name"]])
   

   നിങ്ങൾക്ക് Average_Score മൂല്യത്തെക്കുറിച്ച് സംശയമുണ്ടാകാം, ചിലപ്പോൾ കണക്കാക്കിയ ശരാശരിയുമായി വ്യത്യാസമുണ്ടാകുന്നത് എന്തുകൊണ്ടാണെന്ന്. ചില മൂല്യങ്ങൾ പൊരുത്തപ്പെടുന്നില്ലെങ്കിൽ എന്തുകൊണ്ടാണെന്ന് അറിയാനാകാത്തതിനാൽ, ഈ സാഹചര്യത്തിൽ ഞങ്ങൾക്കുള്ള റിവ്യൂ സ്കോറുകൾ ഉപയോഗിച്ച് ശരാശരി സ്വയം കണക്കാക്കുന്നത് സുരക്ഷിതമാണ്. എന്നാൽ വ്യത്യാസങ്ങൾ സാധാരണയായി വളരെ ചെറിയതാണ്, താഴെ ഡാറ്റാസെറ്റിലെ ശരാശരിയിലും കണക്കാക്കിയ ശരാശരിയിലും ഏറ്റവും വലിയ വ്യത്യാസമുള്ള ഹോട്ടലുകൾ കാണിക്കുന്നു:

   Average_Score_Difference	Average_Score	Calc_Average_Score	Hotel_Name
   -0.8	7.7	8.5	Best Western Hotel Astoria
   -0.7	8.8	9.5	Hotel Stendhal Place Vend me Paris MGallery
   -0.7	7.5	8.2	Mercure Paris Porte d Orleans
   -0.7	7.9	8.6	Renaissance Paris Vendome Hotel
   -0.5	7.0	7.5	Hotel Royal Elys es
   ...	...	...	...
   0.7	7.5	6.8	Mercure Paris Op ra Faubourg Montmartre
   0.8	7.1	6.3	Holiday Inn Paris Montparnasse Pasteur
   0.9	6.8	5.9	Villa Eugenie
   0.9	8.6	7.7	MARQUIS Faubourg St Honor Relais Ch teaux
   1.3	7.2	5.9	Kube Hotel Ice Bar

   ഒരു ഹോട്ടലിനും 1-ലധികം വ്യത്യാസമുണ്ടായിട്ടില്ലാത്തതിനാൽ, വ്യത്യാസം അവഗണിച്ച് കണക്കാക്കിയ ശരാശരി സ്കോർ ഉപയോഗിക്കാം.

6. Negative_Review കോളത്തിൽ "No Negative" ഉള്ള വരികളുടെ എണ്ണം കണക്കാക്കി പ്രിന്റ് ചെയ്യുക

7. Positive_Review കോളത്തിൽ "No Positive" ഉള്ള വരികളുടെ എണ്ണം കണക്കാക്കി പ്രിന്റ് ചെയ്യുക

8. Positive_Review കോളത്തിൽ "No Positive" ഉം Negative_Review കോളത്തിൽ "No Negative" ഉള്ള വരികളുടെ എണ്ണം കണക്കാക്കി പ്രിന്റ് ചെയ്യുക

   # ലാംബ്ഡാസിനൊപ്പം:
   start = time.time()
   no_negative_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" else False , axis=1)
   print("Number of No Negative reviews: " + str(len(no_negative_reviews[no_negative_reviews == True].index)))
   
   no_positive_reviews = df.apply(lambda x: True if x['Positive_Review'] == "No Positive" else False , axis=1)
   print("Number of No Positive reviews: " + str(len(no_positive_reviews[no_positive_reviews == True].index)))
   
   both_no_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" and x['Positive_Review'] == "No Positive" else False , axis=1)
   print("Number of both No Negative and No Positive reviews: " + str(len(both_no_reviews[both_no_reviews == True].index)))
   end = time.time()
   print("Lambdas took " + str(round(end - start, 2)) + " seconds")
   
   Number of No Negative reviews: 127890
   Number of No Positive reviews: 35946
   Number of both No Negative and No Positive reviews: 127
   Lambdas took 9.64 seconds
   

മറ്റൊരു മാർഗ്ഗം

ലാംബ്ഡകൾ ഇല്ലാതെ ഇനങ്ങൾ എണ്ണാനുള്ള മറ്റൊരു മാർഗ്ഗം, വരികൾ എണ്ണാൻ sum ഉപയോഗിക്കുക:

# ലാംബ്ഡകൾ ഇല്ലാതെ (രണ്ടും ഉപയോഗിക്കാമെന്ന് കാണിക്കാൻ വിവിധ നോട്ടേഷനുകളുടെ മിശ്രിതം ഉപയോഗിച്ച്)
start = time.time()
no_negative_reviews = sum(df.Negative_Review == "No Negative")
print("Number of No Negative reviews: " + str(no_negative_reviews))

no_positive_reviews = sum(df["Positive_Review"] == "No Positive")
print("Number of No Positive reviews: " + str(no_positive_reviews))

both_no_reviews = sum((df.Negative_Review == "No Negative") & (df.Positive_Review == "No Positive"))
print("Number of both No Negative and No Positive reviews: " + str(both_no_reviews))

end = time.time()
print("Sum took " + str(round(end - start, 2)) + " seconds")

Number of No Negative reviews: 127890
Number of No Positive reviews: 35946
Number of both No Negative and No Positive reviews: 127
Sum took 0.19 seconds

നിങ്ങൾ ശ്രദ്ധിച്ചിരിക്കാം, Negative_Review-ലും Positive_Review-ലും "No Negative" ഉം "No Positive" ഉം ഉള്ള 127 വരികൾ ഉണ്ട്. അതായത് റിവ്യൂവർ ഹോട്ടലിന് സംഖ്യാത്മക സ്കോർ നൽകിയിട്ടുണ്ട്, പക്ഷേ പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് റിവ്യൂ എഴുതാൻ തയാറായില്ല. ഭാഗ്യവശാൽ ഇത് ചെറിയ എണ്ണം മാത്രമാണ് (127/515738, 0.02%), അതിനാൽ ഇത് നമ്മുടെ മോഡലിനോ ഫലങ്ങളിലോ പ്രത്യേകമായി ബാധിക്കില്ല. എന്നാൽ റിവ്യൂ ഇല്ലാത്ത വരികൾ ഉള്ള ഡാറ്റാസെറ്റ് ഉണ്ടാകുമെന്ന് നിങ്ങൾ പ്രതീക്ഷിക്കാത്തതായിരിക്കും, അതിനാൽ ഇത്തരത്തിലുള്ള വരികൾ കണ്ടെത്താൻ ഡാറ്റ എക്സ്പ്ലോർ ചെയ്യുന്നത് മൂല്യവത്താണ്.

ഇപ്പോൾ നിങ്ങൾ ഡാറ്റാസെറ്റ് എക്സ്പ്ലോർ ചെയ്തു കഴിഞ്ഞു, അടുത്ത പാഠത്തിൽ നിങ്ങൾ ഡാറ്റ ഫിൽട്ടർ ചെയ്ത് ചില മനോഭാവ വിശകലനം ചേർക്കും.

---

🚀ചലഞ്ച്

ഈ പാഠം, മുമ്പത്തെ പാഠങ്ങളിൽ കണ്ടതുപോലെ, നിങ്ങളുടെ ഡാറ്റയും അതിന്റെ പ്രത്യേകതകളും മനസ്സിലാക്കുന്നത് എത്രത്തോളം പ്രധാനമാണെന്ന് കാണിക്കുന്നു. പ്രത്യേകിച്ച് ടെക്സ്റ്റ് അടിസ്ഥാനമാക്കിയ ഡാറ്റ വളരെ സൂക്ഷ്മ പരിശോധന ആവശ്യമാണ്. വിവിധ ടെക്സ്റ്റ്-ഭാരിത ഡാറ്റാസെറ്റുകൾ പരിശോധിച്ച്, മോഡലിൽ പകുതി വയ്ക്കുന്ന ബയാസുകൾ അല്ലെങ്കിൽ വക്രമായ മനോഭാവം ഉണ്ടാക്കാവുന്ന മേഖലകൾ കണ്ടെത്താൻ ശ്രമിക്കുക.

പോസ്റ്റ്-ലെക്ചർ ക്വിസ്

അവലോകനം & സ്വയം പഠനം

ഈ NLP ലേണിംഗ് പാത്ത് സ്വീകരിച്ച്, സ്പീച്ച്, ടെക്സ്റ്റ്-ഭാരിത മോഡലുകൾ നിർമ്മിക്കുമ്പോൾ പരീക്ഷിക്കാവുന്ന ഉപകരണങ്ങൾ കണ്ടെത്തുക.

അസൈൻമെന്റ്

NLTK

---

അസൂയാ:
ഈ രേഖ AI വിവർത്തന സേവനം Co-op Translator ഉപയോഗിച്ച് വിവർത്തനം ചെയ്തതാണ്. നാം കൃത്യതയ്ക്ക് ശ്രമിച്ചിട്ടുണ്ടെങ്കിലും, സ്വയം പ്രവർത്തിക്കുന്ന വിവർത്തനങ്ങളിൽ പിശകുകൾ അല്ലെങ്കിൽ തെറ്റുകൾ ഉണ്ടാകാമെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിന്റെ മാതൃഭാഷയിലുള്ള യഥാർത്ഥ രേഖയാണ് പ്രാമാണികമായ ഉറവിടം എന്ന് പരിഗണിക്കേണ്ടതാണ്. നിർണായകമായ വിവരങ്ങൾക്ക്, പ്രൊഫഷണൽ മനുഷ്യ വിവർത്തനം ശുപാർശ ചെയ്യപ്പെടുന്നു. ഈ വിവർത്തനം ഉപയോഗിക്കുന്നതിൽ നിന്നുണ്ടാകുന്ന ഏതെങ്കിലും തെറ്റിദ്ധാരണകൾക്കോ തെറ്റായ വ്യാഖ്യാനങ്ങൾക്കോ ഞങ്ങൾ ഉത്തരവാദികളല്ല.