Membuat Matriks Jarak Levenshtein yang Tidak Peka Huruf Besar-kecil dengan Python

Melepaskan Potensi Python untuk Kesamaan String

Bayangkan Anda bekerja dengan kumpulan data frasa yang tampak identik tetapi berbeda dalam urutan kata atau huruf besar-kecil. Membandingkan string seperti "Halo Dunia" dan "halo dunia" menjadi tantangan ketika metode konvensional gagal mengidentifikasi keduanya sebagai hal yang sama. Di situlah jarak Levenshtein bisa bersinar.

Jarak Levenshtein mengukur berapa banyak pengeditan yang diperlukan untuk mengubah satu string menjadi string lainnya. Namun apa jadinya jika urutan kata dan huruf menjadi tidak relevan? Ini merupakan tantangan yang sering terjadi dalam pemrosesan teks dan tugas bahasa alami, terutama bila Anda menginginkan presisi. 📊

Banyak pengembang beralih ke alat seperti FuzzyWuzzy untuk menghitung kesamaan string. Meskipun kuat, keluaran perpustakaan sering kali memerlukan transformasi lebih lanjut untuk memenuhi persyaratan tertentu, seperti membuat matriks Levenshtein yang tepat. Langkah ekstra ini dapat mempersulit alur kerja Anda, terutama saat memproses kumpulan data yang luas. 🤔

Dalam artikel ini, kita akan menjelajahi cara yang dioptimalkan untuk menghitung matriks jarak Levenshtein yang mengabaikan urutan kata dan huruf besar/kecil. Kami juga akan membahas pustaka alternatif yang mungkin membuat tugas Anda lebih mudah, memastikan algoritme pengelompokan Anda bekerja secara lancar dengan data yang akurat. Mari selami! 🚀

Memahami Mekanisme Kemiripan dan Pengelompokan String

Dalam skrip Python kami, fokus utamanya adalah menghitung matriks jarak Levenshtein yang tidak peka terhadap urutan kata dan huruf besar/kecil. Hal ini penting untuk tugas pemrosesan teks di mana frasa seperti "Halo Dunia" dan "halo dunia" harus diperlakukan sama. Langkah prapemrosesan mengurutkan kata-kata dalam setiap string berdasarkan abjad dan mengubahnya menjadi huruf kecil, memastikan bahwa perbedaan dalam urutan kata atau kapitalisasi tidak mempengaruhi hasil. Matriks yang dihitung berfungsi sebagai dasar untuk tugas-tugas tingkat lanjut seperti mengelompokkan string serupa. 📊

Skrip pertama menggunakan Levenshtein perpustakaan, yang menyediakan cara efisien untuk menghitung jumlah pengeditan yang diperlukan untuk mengubah satu string menjadi string lainnya. Jarak ini kemudian disimpan dalam matriks, yang merupakan format terstruktur ideal untuk merepresentasikan kesamaan berpasangan dalam kumpulan data. Penggunaan NomorPy memastikan bahwa operasi pada matriks ini dioptimalkan untuk kecepatan dan skalabilitas, terutama ketika berhadapan dengan kumpulan data yang lebih besar.

Dalam skrip kedua, fokusnya beralih ke pengelompokan string menggunakan Propagasi Afinitas algoritma. Teknik ini mengelompokkan string berdasarkan kemiripannya, yang ditentukan oleh jarak Levenshtein negatif. Dengan mengubah jarak menjadi kemiripan, kami memungkinkan algoritme membuat cluster yang bermakna tanpa memerlukan jumlah cluster sebagai masukan. Pendekatan ini sangat berguna untuk tugas pembelajaran tanpa pengawasan, seperti mengkategorikan kumpulan teks berukuran besar. 🤖

Untuk memastikan kebenarannya, skrip ketiga memperkenalkan pengujian unit. Pengujian ini memvalidasi bahwa matriks yang dihitung secara akurat mencerminkan aturan pra-pemrosesan yang diinginkan dan bahwa pengelompokan selaras dengan pengelompokan yang diharapkan. Misalnya, string seperti "kertas tipis" dan "kertas tipis" akan muncul di cluster yang sama. Desain modular skrip ini memungkinkannya untuk digunakan kembali dan diintegrasikan ke dalam berbagai proyek, seperti klasifikasi teks, deduplikasi dokumen, atau optimasi mesin pencari. 🚀

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()

Memperluas Teknik Perbandingan String yang Dioptimalkan

Saat bekerja dengan kumpulan data informasi tekstual yang besar, membandingkan string secara efisien sangatlah penting. Di luar penghitungan jarak dasar Levenshtein, prapemrosesan memainkan peran penting dalam memastikan akurasi. Misalnya, pertimbangkan skenario di mana string dapat menyertakan tanda baca, banyak spasi, atau bahkan karakter non-alfanumerik. Untuk menangani kasus ini, penting untuk menghapus karakter yang tidak diinginkan dan menormalkan spasi sebelum menerapkan algoritma kesamaan apa pun. Perpustakaan seperti ulang (untuk ekspresi reguler) dapat membantu membersihkan data secara efisien, membuat langkah-langkah prapemrosesan menjadi lebih cepat dan konsisten. 🧹

Aspek berharga lainnya adalah memberi bobot pada skor kesamaan berdasarkan konteks. Misalkan Anda sedang memproses masukan pengguna untuk kueri mesin pencari. Kata-kata seperti "hotel" dan "hotel" secara kontekstual sangat mirip, meskipun jarak Levenshteinnya kecil. Algoritma yang memungkinkan pembobotan token, seperti TF-IDF, dapat memberikan presisi tambahan dengan memasukkan frekuensi dan pentingnya istilah tertentu. Kombinasi metrik jarak dan pembobotan istilah ini sangat bermanfaat dalam pengelompokan teks dan tugas deduplikasi.

Terakhir, mengoptimalkan kinerja untuk aplikasi skala besar merupakan pertimbangan penting lainnya. Misalnya, jika Anda perlu memproses kumpulan data dengan ribuan string, pemrosesan paralel dengan Python multiproses perpustakaan dapat secara signifikan mengurangi waktu komputasi. Dengan membagi penghitungan matriks ke beberapa inti, Anda dapat memastikan bahwa tugas yang membutuhkan banyak sumber daya seperti pengelompokan tetap dapat diskalakan dan efisien. 🚀 Menggabungkan teknik-teknik ini menghasilkan solusi yang lebih kuat untuk perbandingan string dan analisis teks.