GPT-3 vs Bert vs GloVe vs Word2vec 文本嵌入技术的性能对比测试

来源：DeepHub IMBA本文约3000字，建议阅读6分钟随着NLP(自然语言处理)的最新进展，OpenAI的GPT-3已经成为市场上最强大的语言模型之一。

 # Libraries from sentence_transformers import SentenceTransformer from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import classification_report from sklearn.tree import DecisionTreeClassifier from sklearn.preprocessing import RobustScaler from sklearn.pipeline import Pipeline import gensim.downloader as api from sklearn.svm import SVC import pandas as pd import numpy as np import openai import re
 # import data df1 = pd.read_csv('https://raw.githubusercontent.com/openai/openai-cookbook/main/examples/data/fine_food_reviews_with_embeddings_1k.csv',                   index_col=0)
 # view first three rows df1.head(3)

 # clean openai embeddings def clean_emb(text):
 # remove line break     text = re.sub(r'\n', '', text)
 # remove square brackets     text = re.sub(r'\[|\]', "", text)
 # remove leading and trailing white spaces     text = text.strip()
 # convert string into array     text = np.fromstring(text, dtype=float, sep=',')
     return text

 # Rename column to gpt_3 df1.rename(columns={'embedding': 'gpt_3'}, inplace=True)
 # Apply clean_emb function df1['gpt_3'] = df1['gpt_3'].apply(lambda x: clean_emb(x))

 api_key = 'api key'
 # set api key as default api key for openai openai.api_key = api_key
 def get_embedding(text, model="text-embedding-ada-002"):
 # replace new lines with spaces    text = text.replace("\n", " ")
 # openai.Embedding.create to convert text into embedding array    return openai.Embedding.create(input = [text], model=model)['data'][0]['embedding']

 import spacy # load pipeline nlp = spacy.load("en_core_web_lg")

 df1.combined[0]

 def replace_multiple_fullstops(text):
 # replace 2 or more consecutive fullstops with 1      text = re.sub(r'\.{2,}', '.', text)
 # strip white spaces from ends of sentence      text= text.strip()
      return text
 # Apply function df1['clean_text'] = df1['combined'].apply(lambda x: replace_multiple_fullstops(x))

 df1['glove'] = df1['clean_text'].apply(lambda text: nlp(text).vector)

 import gensim.downloader as api
 # Load word2vec-google-news-300 model wv = api.load("word2vec-google-news-300")

 def wv_preprocess_and_vectorize(text):     # Process the input text using a natural language processing library     doc = nlp(text)
     # Initialize a list to store the filtered tokens     filtered_tokens = []
     # Loop through each token in the doc     for token in doc:         # If the token is a stop word or punctuation, skip it         if token.is_stop or token.is_punct:             continue         # Otherwise, add the lemma of the token to the filtered_tokens list         filtered_tokens.append(token.lemma_)
     # If there are no filtered tokens, return np.nan     if not filtered_tokens:         return np.nan     else:         # Otherwise, return the mean vector representation of the filtered tokens         return wv.get_mean_vector(filtered_tokens)
 # Apply function df1['word2vec'] = df1['clean_text'].apply(lambda text: wv_preprocess_and_vectorize(text))

 model_sent = SentenceTransformer('all-mpnet-base-v2') df1['mpnet'] = df1['clean_text'].apply(lambda text: model_sent.encode(text))

 # assign data of lists.   data = {'Name': ['gpt_3', 'mpnet', 'word2vec', 'glove'],          'Dimension': [len(df1.gpt_3[0]), len(df1.mpnet[0]),                         len(df1.word2vec[0]), len(df1.glove[0])]}  
 # Create DataFrame   df_emb_len = pd.DataFrame(data)  
 # Set background style df_emb_len.style.background_gradient()

 # Define a list of embedding methods to evaluate embedding_var= ['gpt_3', 'mpnet', 'word2vec', 'glove']
 # Define a list of classifier models to use classifiers = [('rf', RandomForestClassifier(random_state=76)),                ('svm', SVC(random_state=76)),                ('lr', LogisticRegression(random_state=76, max_iter=400)),                ('dt', DecisionTreeClassifier(random_state=76))]
 # Define a dictionary to store accuracy results for each classifier accuracy_lists = {     'rf': [],     'svm': [],     'lr': [],     'dt': [] }
 # Loop through each embedding method for emb in embedding_var:
     # Split the data into training and testing sets using the 'train_test_split' function     X_train, X_test, y_train, y_test = train_test_split(         df1[emb].values,         df1.Score,         test_size=0.25,         random_state=76    )
     # Stack the training and testing sets into 3D arrays     X_train_stacked = np.stack(X_train)     X_test_stacked = np.stack(X_test)
     # Loop through each classifier model     for classifier_name, classifier in classifiers:
         # Create a pipeline that scales the data and fits the classifier         pipe = Pipeline([('scaler', RobustScaler()), (classifier_name, classifier)])         pipe.fit(X_train_stacked, y_train)
         # Use the pipeline to make predictions on the test data         y_pred = pipe.predict(X_test_stacked)
         # Evaluate the accuracy of the predictions         report = classification_report(y_test, y_pred ,output_dict=True)         acc = report['accuracy']
         # Store the accuracy results for each classifier         accuracy_lists[classifier_name].append(acc)

 # Add a new key 'embeddings' to the dictionary 'accuracy_lists' and assign the list 'embedding_var' to it accuracy_lists['embeddings'] = embedding_var  # Create a list of tuples using the values from the dictionaries df_zip = list(zip(accuracy_lists['embeddings'], accuracy_lists['lr'], accuracy_lists['svm'], accuracy_lists['rf'], accuracy_lists['dt']))  # Create a DataFrame 'df_accuracy' from the list 'df_zip' and specify the column names df_accuracy = pd.DataFrame(df_zip, columns = ['Embedding','Logistic_Regression','Support_Vector_Machine', 'Random_Forest','Decision_Tree'])  # Add a background gradient to the DataFrame for visual representation df_accuracy.style.background_gradient()