பைத்தானில் கேஸ்-இன்சென்சிட்டிவ் லெவன்ஸ்டைன் டிஸ்டன்ஸ் மேட்ரிக்ஸை உருவாக்குதல்

சரம் ஒற்றுமைக்கான பைத்தானின் சாத்தியத்தை கட்டவிழ்த்து விடுதல்

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

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

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

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

சரம் ஒற்றுமை மற்றும் கிளஸ்டரிங் இயக்கவியலைப் புரிந்துகொள்வது

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

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

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

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

import numpy as np
import Levenshtein as lev
# Function to calculate the Levenshtein distance matrix
def levenshtein_matrix(strings):
    # Preprocess strings to ignore case and word order
    preprocessed = [" ".join(sorted(s.lower().split())) for s in strings]
    n = len(preprocessed)
    matrix = np.zeros((n, n), dtype=float)
    
    # Populate the matrix with Levenshtein distances
    for i in range(n):
        for j in range(n):
            matrix[i, j] = lev.distance(preprocessed[i], preprocessed[j])
    
    return matrix
    
# Example usage
if __name__ == "__main__":
    lst_words = ['Hello world', 'world hello', 'all hello',
                'peace word', 'Word hello', 'thin paper', 'paper thin']
    matrix = levenshtein_matrix(lst_words)
    print(matrix)

import numpy as np
from sklearn.cluster import AffinityPropagation
import Levenshtein as lev
# Function to calculate the similarity matrix
def similarity_matrix(strings):
    preprocessed = [" ".join(sorted(s.lower().split())) for s in strings]
    n = len(preprocessed)
    matrix = np.zeros((n, n), dtype=float)
    
    for i in range(n):
        for j in range(n):
            # Convert distance to similarity
            distance = lev.distance(preprocessed[i], preprocessed[j])
            matrix[i, j] = -distance  # Negative for affinity propagation
    
    return matrix
    
# Function to perform affinity propagation
def cluster_strings(strings):
    sim_matrix = similarity_matrix(strings)
    affprop = AffinityPropagation(affinity="precomputed")
    affprop.fit(sim_matrix)
    
    # Display results
    for cluster_id in np.unique(affprop.labels_):
        cluster = np.where(affprop.labels_ == cluster_id)[0]
        print(f"Cluster {cluster_id}: {[strings[i] for i in cluster]}")
    
# Example usage
if __name__ == "__main__":
    lst_words = ['Hello world', 'world hello', 'all hello',
                'peace word', 'Word hello', 'thin paper', 'paper thin']
    cluster_strings(lst_words)

import unittest
class TestLevenshteinMatrix(unittest.TestCase):
    def test_levenshtein_matrix(self):
        strings = ['Hello world', 'world hello']
        matrix = levenshtein_matrix(strings)
        self.assertEqual(matrix[0, 1], 0)
        self.assertEqual(matrix[1, 0], 0)
    
class TestClustering(unittest.TestCase):
    def test_cluster_strings(self):
        strings = ['Hello world', 'world hello', 'peace word']
        # Expect similar strings in the same cluster
        cluster_strings(strings)
if __name__ == "__main__":
    unittest.main()

மேம்படுத்தப்பட்ட சரம் ஒப்பீட்டு நுட்பங்களை விரிவுபடுத்துதல்

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

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

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