Hướng dẫn tf-idf implementation in python without library - triển khai tf-idf trong python không có thư viện

Sklearn thực hiện một vài điều chỉnh trong việc triển khai phiên bản vectorizer TFIDF, để sao chép các kết quả chính xác, bạn sẽ cần thêm những điều sau đây để triển khai Vectorizer TFIDF tùy chỉnh:

1. Sklearn có vốn từ vựng được tạo ra từ IDF SROT theo thứ tự bảng chữ cái

2. Công thức Sklearn của IDF khác với công thức sách giáo khoa tiêu chuẩn. Ở đây, hằng số "1" được thêm vào tử số và mẫu số của IDF như thể một tài liệu bổ sung được nhìn thấy chứa mọi thuật ngữ trong bộ sưu tập chính xác một lần, ngăn chặn các phân chia bằng không. IDF (t) = 1+(loge ((1+tổng số tài liệu trong thu thập)/(1+số lượng tài liệu có thuật ngữ t trong đó)).

3. Sklearn áp dụng L2-Normalization vào ma trận đầu ra của nó.

4. Đầu ra cuối cùng của vectorizer sklearn tfidf là một ma trận thưa thớt.

Tôi đã cố gắng thực hiện nó mà không sử dụng thư viện nhưng gặp lỗi mà tôi không thể gỡ lỗi.without using libraries but getting an error which I'm unable to debug.

Code:

corpus = [
         'this is the first document',
         'this document is the second document',
         'and this is the third one',
         'is this the first document',
         ]
  

def fit(dataset):    
    unique_words = set() # at first we will initialize an empty set
    # check if its list type or not
    if isinstance(dataset, (list)):
        for document in dataset: # for each review in the dataset
            for word in document.split(" "): # for each word in the review.#split method converts a string into list of words
                if len(word) < 2:
                    continue
                unique_words.add(word)
        unique_words = sorted(list(unique_words))
        vocab = {j:i for i,j in enumerate(unique_words)}
        
        return vocab
    else:
        print("you need to pass list of sentance")

vocab=fit(corpus)
print(vocab)
output:{'and': 0, 'document': 1, 'first': 2, 'is': 3, 'one': 4, 'second': 5, 'the': 6, 'third': 7, 'this': 8}

def idf(unique_words):
    idf_dict={}
    N=len(corpus)
    for i in unique_words:
        count=0
        for row in corpus:
            if i in row.split():
                count+=1

        idf_dict[i]=float(1+math.log((N+1)/(count+1)))

    return idf_dict

def transform(dataset,vocab):
    rows = []
    columns = []
    values = []
    if isinstance(dataset, (list,)):
        for idx, row in enumerate(dataset): # for each document in the dataset
            # it will return a dict type object where key is the word and values is its frequency {word:frequency}
            word_freq = dict(Counter(row.split()))
            # for every unique word in the document
            for word, freq in word_freq.items():  # for each unique word in the review.                
                if len(word) < 2:
                    continue
                # we will check if its there in the vocabulary that we build in fit() function
                # dict.get() function will return the values, if the key doesn't exits it will return -1
                col_index = vocab.get(word, -1) # retrieving the dimension number of a word
                # if the word exists
                if col_index !=-1:
                    # we are storing the index of the document
                    rows.append(idx)
                    # we are storing the dimensions of the word
                    columns.append(col_index)
                    td = freq/float(len(rows)) # the number of times a word occured in a document
                    idf_ = 1+math.log((1+len(dataset))/float(1+idf(word)))
                    values.append((td) * (idf_))
                    
        return normalize(csr_matrix( ((values),(row,columns)), shape=(len(dataset),len(vocab))),norm='l2' )
    else:
        print("you need to pass list of strings")

print(transform(corpus,vocab))

Error:

 TypeError                                 Traceback (most recent call last)
     in ()
    ----> 1 print(transform(corpus,vocab))
    
    
         22                     td = freq/float(len(rows)) # the number of times a word occured in a document
         23                     a=idf(word)
    ---> 24                     idf_ = 1+math.log((1+len(dataset))/float(1+idf(word)))
         25                     values.append((td) * (idf_))
         26 
    
    TypeError: unsupported operand type(s) for +: 'int' and 'dict_values'
     

TF-IDF là một phương pháp cho chúng ta một trọng số số của các từ phản ánh mức độ quan trọng của từ cụ thể đối với một tài liệu trong một kho văn bản. Một kho văn bản là một tập hợp các tài liệu. TF là tần số thời hạn và IDF là tần số tài liệu nghịch đảo. Phương pháp này thường được sử dụng để truy xuất thông tin và khai thác văn bản.

TF (tần số thời hạn): tần số thuật ngữ có thể được coi là tần suất một từ ‘w, xảy ra trong một tài liệu‘ d. Tầm quan trọng hơn được đưa ra cho các từ thường xuyên xảy ra trong một tài liệu. Công thức của tần số thời hạn là:

Belamy

Đăng ký liều hàng tuần của bạn về những gì đang hoạt động trong công nghệ mới nổi.

IDF (tần số tài liệu nghịch đảo): Đôi khi, các từ như ’The The xảy ra rất nhiều và không cung cấp cho chúng tôi thông tin quan trọng về tài liệu. Để giảm thiểu trọng lượng của các thuật ngữ xảy ra rất thường xuyên bằng cách kết hợp trọng lượng của các từ hiếm khi xảy ra trong tài liệu. Nói cách khác, IDF được sử dụng để tính toán các từ hiếm Trọng lượng trên tất cả các tài liệu trong Corpus. Các từ hiếm khi xảy ra trong kho văn bản sẽ có giá trị IDF cao hơn

Kết hợp hai người này, chúng tôi đưa ra điểm TF-IDF.

Cũng đọc

Tại sao thực hiện TF-IDF từ đầu?

Chúng ta biết rằng Sklearn có mã trực tiếp và một dòng về việc triển khai sklearn.feature_extraction.text.tfidfvectorizer. Vậy thì tại sao cần phải thực hiện điều này từ đầu?

Đối với một số trường hợp, nó được thực hiện để hiểu TFIDF làm gì trong nội bộ và hiểu rõ hơn về nó. Biết chức năng là một điều và biết khi nào nên sử dụng là một điều khác.

Một lý do khác có thể là, trong thế giới thực, chúng ta có xu hướng chơi với GBS hoặc TBS của dữ liệu. Vì vậy, ở đây Scikit Học thực hiện có thể không hữu ích hoặc có thể không cho kết quả tốt. Vì vậy, trong các kịch bản như vậy, chúng ta có xu hướng viết tfidfvectorer từ đầu có thể xử lý dữ liệu khổng lồ như vậy.

Sử dụng Python để triển khai TF-IDF

Đầu tiên và quan trọng nhất là nhập tất cả các thư viện cần thiết cho việc này.

 from collections import Counter
 from tqdm import tqdm
 from scipy.sparse import csr_matrix
 import math
 import operator
 from sklearn.preprocessing import normalize
 import numpy as np 

Thư viện cơ bản được nhập. & NBSP;

Từ sklearn.preprocessing nhập khẩu bình thường hóa Ở đây Sklearn áp dụng L2-Normalization trên ma trận đầu ra của nó, tức là chiều dài Euclide.

 corpus = [
      'this is the first document',
      'this document is the second document',
      'and this is the third one',
      'is this the first document',
 ] 

Để đơn giản, chúng tôi đang lấy bốn đánh giá hoặc tài liệu làm kho dữ liệu của chúng tôi và lưu trữ chúng trong danh sách.

 def IDF(corpus, unique_words):
   idf_dict={}
   N=len(corpus)
   for i in unique_words:
     count=0
     for sen in corpus:
       if i in sen.split():
         count=count+1
       idf_dict[i]=(math.log((1+N)/(count+1)))+1
   return idf_dict 

Chúng tôi sẽ xác định một IDF chức năng có tham số sẽ là tử cung và các từ duy nhất.

Lý do tại sao chúng ta đang thêm ’1, vào tử số và mẫu số và cả vào toàn bộ phương trình của‘ idf_dict [i], là để duy trì sự ổn định số. Có thể có những tình huống không có giá trị, sẽ tạo ra lỗi (tránh phân chia số không). Vì vậy, để tránh lỗi đó, chúng tôi đang tạo ra sự ổn định số.

Đoạn mã này sẽ tạo ra các giá trị IDF của tất cả các từ duy nhất khi hàm ‘phù hợp được gọi.

 def fit(whole_data):
    unique_words = set()
    if isinstance(whole_data, (list,)):
      for x in whole_data:
        for y in x.split():
          if len(y)<2:
            continue
          unique_words.add(y)
      unique_words = sorted(list(unique_words))
      vocab = {j:i for i,j in enumerate(unique_words)}
      Idf_values_of_all_unique_words=IDF(whole_data,unique_words)
    return vocab, Idf_values_of_all_unique_words
 Vocabulary, idf_of_vocabulary=fit(corpus) 

Ở đây chúng tôi đã khởi tạo ‘độc đáo_words, như một bộ để có được tất cả các giá trị duy nhất. (Đặt có một thuộc tính mà nó không in ra các giá trị trùng lặp).

Kiểm tra xem ‘Whole_data có phải là danh sách hay không. Trong trường hợp của chúng tôi, Corpus là một danh sách. Chúng tôi đang chia danh sách và lặp lại danh sách để tìm các từ độc đáo và nối lại chúng trong tập hợp.

Tất cả các từ có độ dài nhỏ hơn hai được loại bỏ.

Chúng tôi đang gọi chức năng IDF bên trong hàm FIT sẽ cung cấp cho chúng tôi các giá trị IDF của tất cả các từ duy nhất được tạo và sẽ lưu trữ chúng trong ‘IDF_VALUES_OF_ALL_UNIQUE_WORDS, & NBSP;

Hàm phù hợp sẽ trả về các từ và giá trị IDF của chúng tương ứng.

Chúng tôi sẽ gán các giá trị cho ‘từ vựng và‘ IDF_OF_VOCABULary, & NBSP;

 print(list(Vocabulary.keys())) 
 ['and', 'document', 'first', 'is', 'one', 'second', 'the', 'third','this'] 

 print(list(idf_of_vocabulary.values()))
 [1.916290731874155, 1.2231435513142097, 1.5108256237659907, 1.0, 1.916290731874155, 1.916290731874155, 1.0, 1.916290731874155, 1.0] 

Đây là đầu ra chúng tôi sẽ nhận được khi thực hiện hàm FIT.

Chúng tôi đang mã hóa sự phù hợp và biến đổi chức năng của TfidFvectorizer.

Bây giờ nhảy về phía chức năng biến đổi.

 def transform(dataset,vocabulary,idf_values):
     sparse_matrix= csr_matrix( (len(dataset), len(vocabulary)), dtype=np.float64)
     for row  in range(0,len(dataset)):
       number_of_words_in_sentence=Counter(dataset[row].split())
       for word in dataset[row].split():
           if word in  list(vocabulary.keys()):
               tf_idf_value=(number_of_words_in_sentence[word]/len(dataset[row].split()))*(idf_values[word])
               sparse_matrix[row,vocabulary[word]]=tf_idf_value
     print("NORM FORM\n",normalize(sparse_matrix, norm='l2', axis=1, copy=True, return_norm=False))
     output =normalize(sparse_matrix, norm='l2', axis=1, copy=True, return_norm=False)
     return output
 final_output=transform(corpus,Vocabulary,idf_of_vocabulary)
 print(final_output.shape) 

Ở đây chúng tôi đang sử dụng chức năng biến đổi để có được đầu ra biểu diễn ma trận thưa thớt của kho văn bản.

Chúng tôi đã sử dụng công thức TF-IDF để tính toán các giá trị của tất cả các từ duy nhất trong tập hợp.

Như chúng ta đã nói trước đó về định mức L2, ở đây Sklearn thực hiện L2, vì vậy với sự trợ giúp của ‘Bình thường hóa & NBSP; Chúng tôi khởi tạo định mức L2 để có được đầu ra hoàn hảo. & NBSP;

Chúng tôi muốn biểu diễn ma trận thưa thớt nên được khởi tạo ‘Sparse_matrix, trong‘ Bình thường hóa & NBSP;

Ma trận thưa thớt là một loại ma trận có rất ít giá trị không 0 và nhiều giá trị bằng không. Chúng tôi chỉ sử dụng ma trận thưa thớt khi ma trận có một số giá trị bằng không.

Trong đầu ra cuối cùng, chúng tôi đã gọi xác chết ban đầu và đầu ra của hàm phù hợp.

Ở đây đầu ra chúng tôi sẽ nhận được sẽ ở đại diện thưa thớt.

Đây là đại diện thưa thớt của ma trận. & NBSP;

Chúng ta có thể chuyển đổi biểu diễn ma trận thưa thớt thành biểu diễn dày đặc hoặc ma trận dày đặc.

 print(final_output[0].toarray())
 [[0.         0.46979139 0.58028582 0.38408524 0.         0.
   0.38408524 0.         0.38408524]] 

Đây là cách người ta sẽ thực hiện TF-IDF trong Python từ đầu.

Để so sánh, chúng ta có thể sử dụng thư viện Sklearn và kiểm tra xem các giá trị có khớp hay không.

Sự kết luận

TF-IDF là một trong những phương pháp được sử dụng nhiều nhất để chuyển đổi văn bản thành dạng số. Ở đây, chúng tôi đã triển khai TF-IDF từ đầu trong Python, điều này rất hữu ích khi chúng tôi có hàng tấn dữ liệu và khi Sklearn có thể không cho kết quả tốt.

Làm thế nào để bạn thực hiện TF

Làm thế nào để tôi có được TF

TF như thế nào

Làm cách nào để tính toán TF theo cách thủ công