Load Data
In [1]:
import pandas as pd
import random
import matplotlib.pyplot as plt
import sklearn.metrics as metrics
import seaborn as sn
import statsmodels.api as sm
%matplotlib inline
path = '/Users/jjhy129/Desktop/study/Current Course/Text Analytics/Assignment 1'
# load data
ratings_training = pd.read_excel(path + '/OBGYN_new_train_80000.xlsx')
# load data
ratings_test = pd.read_excel(path + '/OBGYN_new_test_withoutAnswer_20000.xlsx')
# shuffle the data
ratings_training = ratings_training.sample(frac=1, random_state=1)
Process the review data
In [2]:
import re
import nltk
nltk.download('omw-1.4')
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
def preprocess_text(text):
# Lowercase
text = text.lower()
# Remove special characters and numbers
text = re.sub('[^a-z]+', ' ', text)
# Remove stopwords
stop_words = set(stopwords.words('english'))
text = ' '.join([word for word in text.split() if word not in stop_words])
# Remove task specific stopwords
text = ' '.join([word for word in text.split() if word not in ['doctor', 'dr']])
# Lemmatization
lemmatizer = WordNetLemmatizer()
text = ' '.join([lemmatizer.lemmatize(word) for word in text.split()])
return text
ratings_training['review'] = ratings_training['review'].apply(preprocess_text)
ratings_test['review'] = ratings_test['review'].apply(preprocess_text)
[nltk_data] Downloading package omw-1.4 to /Users/jjhy129/nltk_data... [nltk_data] Package omw-1.4 is already up-to-date!
Train Model
Sentiment analysis
In [3]:
from textblob import TextBlob
# Def Calculate sentiment polarity
def get_sentiment_polarity(text):
blob = TextBlob(text)
return blob.sentiment.polarity
Check ‘knowledge’ data
In [4]:
# add binary variable for knowledge rating
ratings_training['high_knowledge'] = (ratings_training['knowledge'] > 4).astype(int)
# check result
ratings_training.head(5)
Out[4]:
| reviewID | doctorID | doctorName | specialty | numReviews | city | state | doctorHomepage | averageRating | staff | punctuality | helpfulness | knowledge | postedTime | review | review_helpful_count | high_knowledge | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 7126 | 7127 | 102379 | Dr. Lynn B. Rapp | Gynecologist (OBGYN) | 8 | Staten Island | NY | /doctor-ratings/102379/Dr-Lynn%2BB.-Rapp-State… | 4.75 | 5 | 4 | 5 | 5 | 2008-09-12 20:23:00 | caring called home sick st stage heart gold ex… | 0 | 1 |
| 46624 | 46625 | 169383 | Dr. Martin L Immerman | Gynecologist (OBGYN) | 2 | Edina | MN | /doctor-ratings/169383/Dr-Martin%2BL-Immerman-… | 5.00 | 5 | 5 | 5 | 5 | 2008-05-15 14:33:00 | easy going always time listen | 0 | 1 |
| 67020 | 67021 | 30131 | Dr. Reynaldo O. Gomez | Gynecologist (OBGYN) | 23 | Palm Springs | CA | /doctor-ratings/30131/Dr-Reynaldo%2BO.-Gomez-P… | 1.00 | 1 | 1 | 1 | 1 | 2015-07-31 22:49:00 | first gomez perez horrible experience wife cou… | 0 | 0 |
| 67356 | 67357 | 18831 | Dr. John A. Porter | Gynecologist (OBGYN) | 9 | Montgomery | AL | /doctor-ratings/18831/Dr-John%2BA.-Porter-Mont… | 4.50 | 3 | 5 | 5 | 5 | 2010-12-21 06:43:00 | excellent caring patient several year always p… | 0 | 1 |
| 61688 | 61689 | 949046 | Dr. Jacueline D. Saitta | Gynecologist (OBGYN) | 13 | WEST ORANGE | NJ | /doctor-ratings/949046/Dr-Jacueline%2BD.-Saitt… | 5.00 | 5 | 5 | 5 | 5 | 2011-07-12 14:36:00 | saitta one nicest caring people ever met pheno… | 0 | 1 |
In [5]:
ratings_training['high_knowledge'].describe()
Out[5]:
count 80000.000000 mean 0.642288 std 0.479330 min 0.000000 25% 0.000000 50% 1.000000 75% 1.000000 max 1.000000 Name: high_knowledge, dtype: float64
In [6]:
# add binary for each state
temp = pd.get_dummies(ratings_training['state'])
ratings_training = pd.concat([ratings_training,temp],axis=1)
ratings_training.head()
Out[6]:
| reviewID | doctorID | doctorName | specialty | numReviews | city | state | doctorHomepage | averageRating | staff | … | TN | TX | UT | VA | VT | WA | WB | WI | WV | WY | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 7126 | 7127 | 102379 | Dr. Lynn B. Rapp | Gynecologist (OBGYN) | 8 | Staten Island | NY | /doctor-ratings/102379/Dr-Lynn%2BB.-Rapp-State… | 4.75 | 5 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 46624 | 46625 | 169383 | Dr. Martin L Immerman | Gynecologist (OBGYN) | 2 | Edina | MN | /doctor-ratings/169383/Dr-Martin%2BL-Immerman-… | 5.00 | 5 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 67020 | 67021 | 30131 | Dr. Reynaldo O. Gomez | Gynecologist (OBGYN) | 23 | Palm Springs | CA | /doctor-ratings/30131/Dr-Reynaldo%2BO.-Gomez-P… | 1.00 | 1 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 67356 | 67357 | 18831 | Dr. John A. Porter | Gynecologist (OBGYN) | 9 | Montgomery | AL | /doctor-ratings/18831/Dr-John%2BA.-Porter-Mont… | 4.50 | 3 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 61688 | 61689 | 949046 | Dr. Jacueline D. Saitta | Gynecologist (OBGYN) | 13 | WEST ORANGE | NJ | /doctor-ratings/949046/Dr-Jacueline%2BD.-Saitt… | 5.00 | 5 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
5 rows × 70 columns
In [7]:
# add binary for each state
ratings_training['postedTime'] = pd.to_datetime(ratings_training['postedTime'])
ratings_training['year'] = ratings_training['postedTime'].dt.year
ratings_training['hour'] = ratings_training['postedTime'].dt.hour
ratings_training.head()
Out[7]:
| reviewID | doctorID | doctorName | specialty | numReviews | city | state | doctorHomepage | averageRating | staff | … | UT | VA | VT | WA | WB | WI | WV | WY | year | hour | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 7126 | 7127 | 102379 | Dr. Lynn B. Rapp | Gynecologist (OBGYN) | 8 | Staten Island | NY | /doctor-ratings/102379/Dr-Lynn%2BB.-Rapp-State… | 4.75 | 5 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2008 | 20 |
| 46624 | 46625 | 169383 | Dr. Martin L Immerman | Gynecologist (OBGYN) | 2 | Edina | MN | /doctor-ratings/169383/Dr-Martin%2BL-Immerman-… | 5.00 | 5 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2008 | 14 |
| 67020 | 67021 | 30131 | Dr. Reynaldo O. Gomez | Gynecologist (OBGYN) | 23 | Palm Springs | CA | /doctor-ratings/30131/Dr-Reynaldo%2BO.-Gomez-P… | 1.00 | 1 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2015 | 22 |
| 67356 | 67357 | 18831 | Dr. John A. Porter | Gynecologist (OBGYN) | 9 | Montgomery | AL | /doctor-ratings/18831/Dr-John%2BA.-Porter-Mont… | 4.50 | 3 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2010 | 6 |
| 61688 | 61689 | 949046 | Dr. Jacueline D. Saitta | Gynecologist (OBGYN) | 13 | WEST ORANGE | NJ | /doctor-ratings/949046/Dr-Jacueline%2BD.-Saitt… | 5.00 | 5 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2011 | 14 |
5 rows × 72 columns
Split the data into training and test data
In [8]:
# split the data ramdomly by 85%
ratings_training_85 = ratings_training.sample(frac = 0.85, random_state = 1)
ratings_training_15 = ratings_training.drop(ratings_training_85.index)
print(ratings_training_85.shape)
print(ratings_training_15.shape)
(68000, 72) (12000, 72)
Find top keywords
In [9]:
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer
# TF-IDF method
def get_top_keywords(texts, n_keywords):
######### Tune here
# most accurate tune right now: 0.908. 3643 7253
# vectorizer = TfidfVectorizer(ngram_range=(1, 5), min_df= 4, max_df=0.9)
vectorizer = TfidfVectorizer(ngram_range=(1, 5), min_df= 4, max_df=0.9)
tfidf_matrix = vectorizer.fit_transform(texts)
feature_names = vectorizer.get_feature_names()
# Calculate the average TF-IDF scores for each term
avg_tfidf_scores = np.mean(tfidf_matrix, axis=0).tolist()[0]
# Sort the terms by their average TF-IDF scores
sorted_indices = np.argsort(avg_tfidf_scores)[::-1]
# Select the top N terms with the highest average TF-IDF scores
top_keywords = [feature_names[idx] for idx in sorted_indices[:n_keywords]]
return top_keywords
# add keywords to top_keywords
combined_reviews = pd.concat([ratings_training['review'], ratings_test['review']])
# most accurate tune right now: 1500
top_keywords = get_top_keywords(combined_reviews, 1500)
/Users/jjhy129/opt/anaconda3/lib/python3.9/site-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function get_feature_names is deprecated; get_feature_names is deprecated in 1.0 and will be removed in 1.2. Please use get_feature_names_out instead. warnings.warn(msg, category=FutureWarning)
Add sentiment polarity to feature set
In [10]:
# calculate sentiment polarity for training dataset
ratings_training_85['sentiment_polarity'] = ratings_training_85['review'].apply(get_sentiment_polarity)
Define search4keywords function
In [11]:
# define search4keywords function
def search4keywords(keywordlist):
for keyword in top_keywords:
if keyword not in keywordlist:
keywordlist.append(keyword)
keywordlist = list(set(keywordlist))
for keyword in keywordlist:
ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x))
ratings_training_85.head()
keywordsvarlist = ['kw_'+x for x in keywordlist]
# add keywords variable into the predictor variables
xcols = ['AK', 'AL', 'AR', 'AZ', 'CA',
'CO', 'CT', 'DC', 'DE', 'FL', 'GA', 'HI', 'IA', 'ID', 'IL', 'IN', 'KS',
'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN', 'MO', 'MS', 'NC', 'ND', 'NE',
'NJ', 'NM', 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'PR', 'RI', 'SC', 'SD',
'TN', 'TX', 'UT', 'VA', 'WA', 'WI', 'WV', 'WY', 'year', 'hour','numReviews'] + keywordsvarlist + ['sentiment_polarity']
# response variable
ycol = 'high_knowledge'
x = ratings_training_85[xcols]
print(x.shape)
x = sm.add_constant(x)
y = ratings_training_85[ycol]
print(x.shape,y.shape)
logit_model_keywords = sm.Logit(y, x)
logit_result = logit_model_keywords.fit()
print(logit_result.summary2())
#predict highPunctuality using the trained logit model
ratings_training_85['highKnowledge_predictLogitKeywords'] = (logit_result.predict(x) >= 0.5).astype(int)
ratings_training_85[['highKnowledge_predictLogitKeywords','high_knowledge']]
acc = metrics.accuracy_score(y_true = ratings_training_85['high_knowledge'],y_pred = ratings_training_85['highKnowledge_predictLogitKeywords'])
print(acc)
confusion = metrics.confusion_matrix(y_true = ratings_training_85['high_knowledge'],y_pred = ratings_training_85['highKnowledge_predictLogitKeywords'])
print(confusion)
sn.heatmap(confusion, annot = True, cmap = 'Reds', fmt = 'd')
plt.xlabel("highKnowledge_predictLogitKeywords")
plt.ylabel("highKnowledge")
return(acc)
Apply TF-IDF
Try different keywords according to tf-idf
In [12]:
###### beware: No special characters, no upperclass letter
# quality keywords: good, bad, best, worst, great, amazing, awesome, wonderful, correct, terrible, lack, awful, horrible, poor, poorly
# doctor keywords: professional, helpful, unhelpful, rude, rudely, not care, doesn't care, caring, thorough, friendly, not friendly, excellent, listening, listens, does not listen, knows, not know, she, he, He, She, compassionate, kind, arrogant
# behavior keywords: many years, highly recommend, love, away, delivered, deliver, delivers, saved, life, late, waited, took the time, takes the time, appreciate
# knowledge keywords: ask, not ask, answer, not answer, idea, no idea,
# knowledge, not knowledgeable, knowledgeable, question, questions, answer, answered,
# explain, explained, never explained, real, advise
# relationship keywords: child, children, girl, boy
# sentiment: wish, truly
keywordlist = ['great', 'real', 'good', 'bad','best', 'worst', 'helpful','unhelpful', 'ask', 'answer', 'idea', 'knowledge', 'knowledgeable','question','answer', 'explain', 'professional','amazing', 'awesome', 'rude', 'rudely', 'thorough', 'friendly', 'love', 'excellent', 'inform', 'caring', 'correct', 'away', 'worth', 'terrible', 'she', 'he', 'child', 'friend', 'life', 'compassionate', 'deliver', 'children', 'advise', 'wish', 'girl', 'boy', 'lack', 'awful', 'horrible', 'late', 'kind', 'arrogant', 'appreciate', 'poor', 'poorly', 'truly', 'highly recommend', 'take time', 'made feel', 'feel comfortable', 'make feel', 'recommend anyone', 'care', 'never']
acc = search4keywords(keywordlist)
/var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/513639826.py:13: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x))
(68000, 1558)
(68000, 1559) (68000,)
Warning: Maximum number of iterations has been exceeded.
Current function value: 0.222446
Iterations: 35
/Users/jjhy129/opt/anaconda3/lib/python3.9/site-packages/statsmodels/base/model.py:604: ConvergenceWarning: Maximum Likelihood optimization failed to converge. Check mle_retvals
warnings.warn("Maximum Likelihood optimization failed to "
Results: Logit
===============================================================================================================================
Model: Logit Pseudo R-squared: 0.659
Dependent Variable: high_knowledge AIC: 33370.5983
Date: 2023-04-04 21:11 BIC: 47600.0013
No. Observations: 68000 Log-Likelihood: -15126.
Df Model: 1558 LL-Null: -44366.
Df Residuals: 66441 LLR p-value: 0.0000
Converged: 0.0000 Scale: 1.0000
No. Iterations: 35.0000
-------------------------------------------------------------------------------------------------------------------------------
Coef. Std.Err. z P>|z| [0.025 0.975]
-------------------------------------------------------------------------------------------------------------------------------
const -25.8995 12.0961 -2.1411 0.0323 -49.6075 -2.1916
AK 0.6612 0.3746 1.7654 0.0775 -0.0729 1.3953
AL 0.1883 0.2686 0.7008 0.4834 -0.3383 0.7148
AR 0.2261 0.2062 1.0966 0.2728 -0.1780 0.6301
AZ -0.1952 0.2281 -0.8556 0.3922 -0.6422 0.2519
CA -0.3661 0.2447 -1.4961 0.1346 -0.8458 0.1135
CO -0.1584 0.2793 -0.5672 0.5706 -0.7059 0.3891
CT -0.1157 0.2759 -0.4196 0.6748 -0.6564 0.4250
DC 0.1419 0.3163 0.4487 0.6537 -0.4780 0.7618
DE -0.1219 0.3497 -0.3485 0.7275 -0.8074 0.5636
FL -0.1091 0.2751 -0.3966 0.6916 -0.6482 0.4300
GA -0.1677 0.2563 -0.6544 0.5128 -0.6700 0.3346
HI -0.2066 0.3446 -0.5995 0.5489 -0.8821 0.4689
IA -0.1108 0.3479 -0.3186 0.7500 -0.7926 0.5710
ID 0.0432 0.3392 0.1274 0.8987 -0.6215 0.7079
IL -0.0434 0.2531 -0.1716 0.8637 -0.5394 0.4526
IN -0.0837 0.2737 -0.3057 0.7598 -0.6200 0.4527
KS -0.0528 0.2034 -0.2594 0.7953 -0.4513 0.3458
KY -0.0094 0.2927 -0.0322 0.9743 -0.5831 0.5643
LA -0.0346 0.2732 -0.1266 0.8993 -0.5701 0.5009
MA 0.0476 0.2539 0.1876 0.8512 -0.4500 0.5453
MD -0.0783 0.2488 -0.3150 0.7528 -0.5659 0.4092
ME -0.2848 0.4482 -0.6355 0.5251 -1.1633 0.5937
MI -0.1950 0.2527 -0.7716 0.4404 -0.6902 0.3003
MN 0.0268 0.2895 0.0927 0.9262 -0.5405 0.5942
MO 0.0995 0.2621 0.3796 0.7043 -0.4142 0.6132
MS 0.2236 0.3375 0.6626 0.5076 -0.4379 0.8851
NC -0.0460 0.2631 -0.1747 0.8613 -0.5617 0.4698
ND -0.0769 0.4572 -0.1682 0.8664 -0.9730 0.8192
NE 0.3381 0.3386 0.9985 0.3180 -0.3255 1.0017
NJ -0.2417 0.2478 -0.9753 0.3294 -0.7273 0.2440
NM -0.2580 0.3469 -0.7437 0.4570 -0.9379 0.4219
NV -0.2245 0.2738 -0.8202 0.4121 -0.7611 0.3120
NY -0.2682 0.2444 -1.0971 0.2726 -0.7472 0.2109
OH -0.1229 0.2564 -0.4793 0.6317 -0.6253 0.3796
OK -0.0903 0.2650 -0.3409 0.7332 -0.6098 0.4291
OR -0.0428 0.2925 -0.1464 0.8836 -0.6161 0.5304
PA -0.2003 0.2552 -0.7849 0.4325 -0.7006 0.2999
PR 1.7504 0.4656 3.7596 0.0002 0.8379 2.6630
RI -0.4372 0.3540 -1.2352 0.2168 -1.1310 0.2566
SC -0.1367 0.2608 -0.5241 0.6002 -0.6479 0.3745
SD 0.1213 0.4085 0.2968 0.7666 -0.6794 0.9219
TN -0.0854 0.2617 -0.3265 0.7440 -0.5984 0.4275
TX -0.1499 0.2141 -0.7002 0.4838 -0.5695 0.2697
UT -0.2263 0.2696 -0.8393 0.4013 -0.7547 0.3021
VA -0.0985 0.2524 -0.3902 0.6964 -0.5933 0.3963
WA -0.2017 0.2719 -0.7416 0.4583 -0.7346 0.3313
WI 0.1273 0.2794 0.4557 0.6486 -0.4203 0.6750
WV 0.3459 0.3090 1.1194 0.2630 -0.2597 0.9515
WY -0.2388 0.5129 -0.4656 0.6415 -1.2442 0.7665
year 0.0127 0.0060 2.1243 0.0336 0.0010 0.0245
hour 0.0003 0.0042 0.0613 0.9511 -0.0079 0.0084
numReviews 0.0027 0.0014 2.0151 0.0439 0.0001 0.0054
kw_small 0.5004 0.1713 2.9204 0.0035 0.1646 0.8362
kw_discovered 0.4250 0.3258 1.3045 0.1921 -0.2135 1.0634
kw_one time 0.1617 0.2041 0.7922 0.4282 -0.2384 0.5618
kw_test -0.1364 0.0855 -1.5966 0.1104 -0.3039 0.0311
kw_often 0.0113 0.1541 0.0734 0.9415 -0.2908 0.3134
kw_happen -0.0871 0.1476 -0.5904 0.5549 -0.3764 0.2021
kw_pleasant -0.1375 0.1067 -1.2887 0.1975 -0.3465 0.0716
kw_discussed 0.2693 0.2780 0.9689 0.3326 -0.2755 0.8141
kw_encountered 0.2762 0.2639 1.0467 0.2952 -0.2410 0.7934
kw_beware -1.5464 0.3800 -4.0699 0.0000 -2.2911 -0.8017
kw_saved life 1.5522 0.3723 4.1691 0.0000 0.8225 2.2819
kw_obgyn 0.0521 0.1337 0.3898 0.6967 -0.2100 0.3142
kw_ultrasound 0.1235 0.2289 0.5396 0.5895 -0.3251 0.5720
kw_four -0.1948 0.1792 -1.0871 0.2770 -0.5461 0.1564
kw_attitude -0.4451 0.1316 -3.3826 0.0007 -0.7029 -0.1872
kw_via section 9.3973 623.7232 0.0151 0.9880 -1213.0777 1231.8723
kw_good experience -0.2891 0.1921 -1.5050 0.1323 -0.6655 0.0874
kw_absolutely love 0.9279 0.3486 2.6618 0.0078 0.2446 1.6111
kw_office staff -0.0537 0.0933 -0.5759 0.5647 -0.2365 0.1291
kw_acted -0.2673 0.1714 -1.5599 0.1188 -0.6032 0.0686
kw_open 0.2307 0.1359 1.6982 0.0895 -0.0356 0.4970
kw_blessed 0.3412 0.5373 0.6350 0.5254 -0.7119 1.3942
kw_say enough good thing -50.4938 65881211.5247 -0.0000 1.0000 -129124852.3401 129124751.3524
kw_hysterectomy 0.3174 0.1255 2.5287 0.0114 0.0714 0.5633
kw_money -0.9020 0.1292 -6.9814 0.0000 -1.1553 -0.6488
kw_situation -0.1738 0.1344 -1.2927 0.1961 -0.4373 0.0897
kw_office visit -0.1228 0.2113 -0.5812 0.5611 -0.5369 0.2913
kw_helpful 0.2572 0.0983 2.6180 0.0088 0.0647 0.4498
kw_son 0.1489 0.0760 1.9601 0.0500 0.0000 0.2977
kw_love love love -29.2886 1867905.4385 -0.0000 1.0000 -3661056.6746 3660998.0973
kw_joke -0.2661 0.2118 -1.2564 0.2090 -0.6813 0.1490
kw_addressed 0.1965 0.2852 0.6890 0.4908 -0.3625 0.7556
kw_nasty 0.2008 0.2517 0.7976 0.4251 -0.2926 0.6942
kw_emergency section -0.4025 2.9541 -0.1363 0.8916 -6.1925 5.3875
kw_hold 0.2200 0.1639 1.3427 0.1794 -0.1011 0.5412
kw_best care 0.4922 0.4191 1.1747 0.2401 -0.3291 1.3136
kw_period -0.2766 0.1602 -1.7271 0.0841 -0.5906 0.0373
kw_old -0.2487 0.1059 -2.3499 0.0188 -0.4562 -0.0413
kw_put -0.0734 0.0848 -0.8652 0.3869 -0.2396 0.0928
kw_sweet 0.3470 0.1260 2.7536 0.0059 0.1000 0.5941
kw_recovery 0.6848 0.2626 2.6079 0.0091 0.1701 1.1994
kw_extremely rude -0.6852 0.2769 -2.4745 0.0133 -1.2279 -0.1425
kw_fully -0.1161 0.1747 -0.6648 0.5062 -0.4586 0.2263
kw_last 0.0969 0.0841 1.1530 0.2489 -0.0678 0.2617
kw_feeling -0.2243 0.1289 -1.7391 0.0820 -0.4770 0.0285
kw_safe 0.2547 0.1715 1.4855 0.1374 -0.0814 0.5908
kw_spend time -0.3757 0.2875 -1.3071 0.1912 -0.9391 0.1877
kw_right 0.1420 0.0830 1.7109 0.0871 -0.0207 0.3048
kw_knew 0.3987 0.1349 2.9557 0.0031 0.1343 0.6631
kw_unnecessary -0.8024 0.2555 -3.1401 0.0017 -1.3032 -0.3016
kw_change 0.1327 0.1193 1.1125 0.2659 -0.1011 0.3665
kw_time listen 0.5961 0.2597 2.2953 0.0217 0.0871 1.1052
kw_seem -0.7594 0.1116 -6.8052 0.0000 -0.9781 -0.5407
kw_go another 0.6214 0.2834 2.1923 0.0284 0.0659 1.1769
kw_brown 0.0524 0.3002 0.1745 0.8614 -0.5359 0.6407
kw_delivered child 0.5085 0.2000 2.5424 0.0110 0.1165 0.9004
kw_set -0.0719 0.1489 -0.4829 0.6292 -0.3638 0.2200
kw_med 0.0402 0.0807 0.4984 0.6182 -0.1179 0.1983
kw_suggestion 0.0392 0.3122 0.1256 0.9001 -0.5727 0.6511
kw_understanding 0.2766 0.1531 1.8064 0.0709 -0.0235 0.5766
kw_month pregnant -0.1776 0.2617 -0.6784 0.4975 -0.6906 0.3354
kw_lot time 1.0267 0.2517 4.0796 0.0000 0.5334 1.5199
kw_front office 0.5459 0.2377 2.2966 0.0216 0.0800 1.0119
kw_thing say 0.4108 0.2327 1.7649 0.0776 -0.0454 0.8669
kw_difficult pregnancy 0.7009 0.3616 1.9382 0.0526 -0.0079 1.4096
kw_switched -0.5423 0.1979 -2.7401 0.0061 -0.9301 -0.1544
kw_current -0.1233 0.2012 -0.6127 0.5401 -0.5175 0.2710
kw_nice helpful 0.2117 0.2452 0.8632 0.3880 -0.2690 0.6924
kw_conversation -0.5291 0.2728 -1.9393 0.0525 -1.0638 0.0056
kw_pap -0.4939 0.1775 -2.7820 0.0054 -0.8418 -0.1459
kw_pick 0.1067 0.1904 0.5604 0.5752 -0.2665 0.4799
kw_ease 0.2903 0.1167 2.4869 0.0129 0.0615 0.5191
kw_bedside manner 0.0934 0.5512 0.1695 0.8654 -0.9868 1.1737
kw_worth wait 0.7307 0.2884 2.5335 0.0113 0.1654 1.2959
kw_delivered second -0.1601 0.3370 -0.4751 0.6347 -0.8207 0.5005
kw_warm 0.1244 0.1202 1.0348 0.3008 -0.1112 0.3599
kw_recommend anyone looking -0.1818 0.6408 -0.2837 0.7767 -1.4378 1.0742
kw_skilled 0.7029 0.3044 2.3089 0.0210 0.1062 1.2996
kw_smith -0.5637 0.2797 -2.0150 0.0439 -1.1119 -0.0154
kw_stayed 0.1957 0.2401 0.8151 0.4150 -0.2749 0.6664
kw_figure 0.0187 0.1866 0.1001 0.9203 -0.3471 0.3844
kw_appointment time 0.0440 0.1961 0.2242 0.8226 -0.3404 0.4284
kw_remembers 0.5848 0.3424 1.7078 0.0877 -0.0864 1.2560
kw_body -0.1414 0.1259 -1.1229 0.2615 -0.3882 0.1054
kw_feel rushed 0.0923 0.2178 0.4238 0.6717 -0.3345 0.5191
kw_ovary 0.0557 0.2128 0.2618 0.7935 -0.3613 0.4727
kw_best 1.0505 0.0761 13.7969 0.0000 0.9013 1.1998
kw_see another 0.4559 0.2758 1.6528 0.0984 -0.0847 0.9965
kw_md -0.1123 0.1596 -0.7039 0.4815 -0.4251 0.2005
kw_wonderful experience 0.1313 0.3198 0.4106 0.6814 -0.4956 0.7582
kw_looking 0.2805 0.1511 1.8567 0.0634 -0.0156 0.5765
kw_given 0.0727 0.1481 0.4911 0.6234 -0.2175 0.3630
kw_satisfied -0.4838 0.2279 -2.1231 0.0337 -0.9304 -0.0372
kw_wonderful bedside 0.0773 1.1111 0.0696 0.9445 -2.1005 2.2551
kw_removed -0.7827 0.3768 -2.0775 0.0378 -1.5212 -0.0443
kw_pm -0.1440 0.1732 -0.8314 0.4057 -0.4835 0.1955
kw_truly 0.6201 0.1546 4.0114 0.0001 0.3171 0.9231
kw_quite -0.3882 0.1312 -2.9583 0.0031 -0.6454 -0.1310
kw_gyn year 0.5185 0.2665 1.9459 0.0517 -0.0038 1.0407
kw_thru 0.3008 0.2538 1.1851 0.2360 -0.1967 0.7983
kw_receive 0.2989 0.2372 1.2600 0.2077 -0.1660 0.7639
kw_never felt 0.6418 0.2208 2.9069 0.0037 0.2091 1.0745
kw_thought -0.3132 0.1301 -2.4082 0.0160 -0.5682 -0.0583
kw_blood -0.2001 0.1564 -1.2794 0.2008 -0.5068 0.1065
kw_awesome 1.0782 0.1223 8.8130 0.0000 0.8384 1.3180
kw_wait time 0.1366 0.1241 1.1013 0.2708 -0.1065 0.3798
kw_appt -0.1370 0.1261 -1.0867 0.2772 -0.3842 0.1101
kw_answer question 0.2548 0.1308 1.9489 0.0513 -0.0014 0.5111
kw_sympathetic -0.8773 0.2494 -3.5175 0.0004 -1.3661 -0.3885
kw_practicing 0.0841 0.2384 0.3529 0.7241 -0.3831 0.5514
kw_may -0.0375 0.0869 -0.4312 0.6663 -0.2079 0.1329
kw_agree -0.2747 0.1074 -2.5580 0.0105 -0.4852 -0.0642
kw_took time answer 0.4598 0.7541 0.6097 0.5420 -1.0183 1.9379
kw_doctor practice -0.3792 0.2572 -1.4740 0.1405 -0.8833 0.1250
kw_rude -0.7535 0.0697 -10.8129 0.0000 -0.8901 -0.6169
kw_help 0.1749 0.0833 2.1011 0.0356 0.0117 0.3381
kw_explains everything 0.1686 0.4930 0.3419 0.7324 -0.7976 1.1347
kw_physical -0.0004 0.2038 -0.0019 0.9985 -0.3998 0.3990
kw_first time -0.0060 0.1271 -0.0471 0.9624 -0.2551 0.2432
kw_got 0.0009 0.0823 0.0104 0.9917 -0.1605 0.1622
kw_based -0.5948 0.1783 -3.3358 0.0009 -0.9442 -0.2453
kw_refuse -0.2785 0.2953 -0.9430 0.3457 -0.8573 0.3003
kw_best ever 2.2692 0.3748 6.0543 0.0000 1.5346 3.0038
kw_recommend family -0.2237 0.9426 -0.2373 0.8124 -2.0711 1.6238
kw_advice -0.1880 0.1466 -1.2830 0.1995 -0.4753 0.0992
kw_patient kind 0.9851 0.4779 2.0615 0.0393 0.0485 1.9217
kw_handle -0.3609 0.2198 -1.6417 0.1007 -0.7917 0.0700
kw_jones 0.0322 0.3340 0.0964 0.9232 -0.6225 0.6869
kw_outside -0.0876 0.2547 -0.3440 0.7308 -0.5869 0.4116
kw_straight forward 0.3397 0.3842 0.8842 0.3766 -0.4133 1.0927
kw_paying -0.4002 0.2512 -1.5932 0.1111 -0.8924 0.0921
kw_totally 0.0393 0.2479 0.1587 0.8739 -0.4465 0.5252
kw_waiting room 0.4546 0.1674 2.7153 0.0066 0.1264 0.7827
kw_could -0.0073 0.0624 -0.1175 0.9065 -0.1296 0.1150
kw_manager 0.5192 0.4551 1.1409 0.2539 -0.3728 1.4112
kw_calming 0.3851 0.4148 0.9284 0.3532 -0.4279 1.1982
kw_hard 0.4100 0.1134 3.6154 0.0003 0.1877 0.6323
kw_miss 0.1759 0.1419 1.2393 0.2152 -0.1023 0.4540
kw_sorry 0.2323 0.1742 1.3334 0.1824 -0.1091 0.5737
kw_via -0.0076 0.1602 -0.0477 0.9620 -0.3216 0.3063
kw_negative 0.3651 0.1298 2.8134 0.0049 0.1107 0.6194
kw_hate 0.0488 0.1681 0.2906 0.7714 -0.2806 0.3782
kw_notch 31.8272 7365808.1359 0.0000 1.0000 -14436686.8362 14436750.4907
kw_rough -0.4735 0.1579 -2.9981 0.0027 -0.7831 -0.1640
kw_overall -0.1633 0.1134 -1.4404 0.1497 -0.3855 0.0589
kw_returned 0.0357 0.3270 0.1092 0.9131 -0.6052 0.6766
kw_low -0.1448 0.1213 -1.1938 0.2326 -0.3824 0.0929
kw_payment 0.0329 0.2561 0.1286 0.8977 -0.4690 0.5348
kw_along 0.0411 0.1792 0.2293 0.8186 -0.3101 0.3923
kw_return phone 0.4202 1.2070 0.3481 0.7277 -1.9455 2.7860
kw_patient need -0.3812 0.2653 -1.4370 0.1507 -0.9010 0.1387
kw_emotional -0.1855 0.2305 -0.8048 0.4209 -0.6372 0.2662
kw_smear 0.3345 0.7087 0.4720 0.6369 -1.0546 1.7237
kw_appreciate 1.1565 0.1861 6.2134 0.0000 0.7917 1.5214
kw_show -0.0419 0.1267 -0.3307 0.7409 -0.2903 0.2065
kw_treated like -0.5143 0.2538 -2.0261 0.0428 -1.0118 -0.0168
kw_worst ever -1.2748 0.3898 -3.2701 0.0011 -2.0388 -0.5107
kw_due date -1.0937 0.2922 -3.7433 0.0002 -1.6663 -0.5210
kw_thank god -0.7636 0.2984 -2.5587 0.0105 -1.3485 -0.1787
kw_experience -0.2400 0.0693 -3.4615 0.0005 -0.3759 -0.1041
kw_would never go 0.4220 0.3909 1.0795 0.2803 -0.3442 1.1882
kw_would recommend everyone -0.4328 0.6843 -0.6324 0.5271 -1.7739 0.9084
kw_luck -1.0045 0.1804 -5.5686 0.0000 -1.3581 -0.6510
kw_guess -0.6819 0.1684 -4.0502 0.0001 -1.0119 -0.3519
kw_asks 0.5289 0.2472 2.1399 0.0324 0.0445 1.0133
kw_approach -0.0432 0.1907 -0.2262 0.8210 -0.4170 0.3307
kw_call back -0.0450 0.1516 -0.2970 0.7664 -0.3421 0.2521
kw_stop 0.0570 0.2073 0.2751 0.7832 -0.3493 0.4633
kw_deliver -0.4618 0.1850 -2.4963 0.0126 -0.8244 -0.0992
kw_well worth 0.9949 0.4683 2.1245 0.0336 0.0771 1.9128
kw_move -0.1262 0.2120 -0.5951 0.5517 -0.5417 0.2894
kw_offered 0.4454 0.2778 1.6030 0.1089 -0.0992 0.9900
kw_special 0.2544 0.1647 1.5441 0.1226 -0.0685 0.5772
kw_ups -0.1218 0.2240 -0.5440 0.5864 -0.5608 0.3171
kw_guy -0.0790 0.1599 -0.4942 0.6212 -0.3925 0.2344
kw_allow -0.0492 0.2210 -0.2228 0.8237 -0.4825 0.3840
kw_recommend anyone -0.1457 0.2035 -0.7159 0.4741 -0.5447 0.2532
kw_like patient 1.2048 0.3400 3.5431 0.0004 0.5383 1.8712
kw_best ob gyn 0.4654 0.6457 0.7208 0.4710 -0.8002 1.7310
kw_take time listen -0.0368 0.3480 -0.1056 0.9159 -0.7189 0.6454
kw_delivers 0.4918 0.2842 1.7308 0.0835 -0.0651 1.0488
kw_shot -0.1033 0.2790 -0.3702 0.7113 -0.6501 0.4436
kw_thoroughly -0.2204 0.2516 -0.8762 0.3809 -0.7134 0.2726
kw_got pregnant 0.2918 0.2350 1.2421 0.2142 -0.1687 0.7524
kw_comment -0.0964 0.1018 -0.9476 0.3434 -0.2959 0.1030
kw_seems like 0.1667 0.2420 0.6885 0.4911 -0.3077 0.6411
kw_partner -0.4231 0.1935 -2.1872 0.0287 -0.8023 -0.0440
kw_weekend 0.1458 0.2547 0.5725 0.5670 -0.3534 0.6451
kw_personal -0.1609 0.1294 -1.2435 0.2137 -0.4145 0.0927
kw_certainly -0.0751 0.3048 -0.2465 0.8053 -0.6726 0.5223
kw_poor bedside manner 1.2511 51.7109 0.0242 0.9807 -100.1004 102.6025
kw_year 0.4212 0.0619 6.8096 0.0000 0.3000 0.5425
kw_another ob 0.0653 0.1964 0.3322 0.7397 -0.3197 0.4502
kw_procedure -0.1391 0.0889 -1.5657 0.1174 -0.3133 0.0350
kw_town -0.1740 0.1700 -1.0239 0.3059 -0.5072 0.1591
kw_woman health 0.1858 0.3007 0.6180 0.5366 -0.4035 0.7751
kw_knowledgeable 0.7319 0.1269 5.7670 0.0000 0.4832 0.9807
kw_since -0.0161 0.0723 -0.2222 0.8242 -0.1577 0.1256
kw_keep 0.0281 0.1034 0.2719 0.7857 -0.1746 0.2308
kw_healthcare -0.1225 0.2528 -0.4847 0.6279 -0.6180 0.3730
kw_humor 0.4167 0.3346 1.2455 0.2130 -0.2391 1.0725
kw_bother -0.4145 0.1712 -2.4212 0.0155 -0.7501 -0.0790
kw_morning 0.4479 0.1720 2.6043 0.0092 0.1108 0.7851
kw_month later 0.0910 0.2615 0.3481 0.7278 -0.4215 0.6036
kw_return call -0.5690 0.2457 -2.3158 0.0206 -1.0505 -0.0874
kw_currently 0.2476 0.2761 0.8969 0.3698 -0.2935 0.7888
kw_numerous -0.1312 0.2417 -0.5431 0.5871 -0.6049 0.3424
kw_delivering -0.0207 0.1728 -0.1201 0.9044 -0.3594 0.3179
kw_concerned 0.0111 0.1266 0.0877 0.9301 -0.2370 0.2592
kw_question answered 0.7003 0.2909 2.4075 0.0161 0.1302 1.2703
kw_kid 0.0815 0.1384 0.5892 0.5557 -0.1897 0.3528
kw_always friendly 0.2163 0.3322 0.6512 0.5149 -0.4348 0.8674
kw_husband 0.0444 0.0916 0.4847 0.6279 -0.1352 0.2240
kw_wanted 0.0661 0.1072 0.6163 0.5377 -0.1441 0.2762
kw_reschedule -0.0658 0.1949 -0.3373 0.7359 -0.4478 0.3163
kw_explain thing 0.0729 0.2704 0.2698 0.7873 -0.4570 0.6028
kw_labor delivery 0.1967 0.2672 0.7363 0.4616 -0.3269 0.7203
kw_middle -0.1924 0.2413 -0.7973 0.4253 -0.6653 0.2805
kw_uncaring -2.2304 0.2490 -8.9584 0.0000 -2.7184 -1.7424
kw_rare 0.0596 0.1832 0.3250 0.7451 -0.2996 0.4187
kw_mile 0.4436 0.2868 1.5467 0.1219 -0.1185 1.0058
kw_tell -0.0882 0.0789 -1.1178 0.2636 -0.2429 0.0665
kw_medicine -0.1477 0.1587 -0.9305 0.3521 -0.4587 0.1634
kw_never see 0.1275 0.1937 0.6579 0.5106 -0.2523 0.5072
kw_fault 0.1266 0.2244 0.5641 0.5727 -0.3133 0.5664
kw_died -0.7509 0.2347 -3.1996 0.0014 -1.2108 -0.2909
kw_front desk 0.7820 0.3866 2.0225 0.0431 0.0242 1.5397
kw_found -0.1617 0.0664 -2.4336 0.0150 -0.2919 -0.0315
kw_comfortable -0.0203 0.2356 -0.0863 0.9312 -0.4820 0.4414
kw_star 0.2447 0.2326 1.0521 0.2928 -0.2112 0.7005
kw_delivered son 0.0929 0.1981 0.4690 0.6391 -0.2953 0.4811
kw_never met -0.1836 0.3705 -0.4956 0.6202 -0.9098 0.5426
kw_right away 0.5301 0.2435 2.1767 0.0295 0.0528 1.0074
kw_hurry -0.6702 0.1629 -4.1141 0.0000 -0.9895 -0.3509
kw_whatever -0.1647 0.2899 -0.5681 0.5700 -0.7330 0.4035
kw_yes 0.4571 0.1274 3.5872 0.0003 0.2074 0.7069
kw_make feel like -0.0199 0.2829 -0.0704 0.9439 -0.5745 0.5346
kw_matter 0.0669 0.1354 0.4943 0.6211 -0.1984 0.3323
kw_door -0.1971 0.1699 -1.1601 0.2460 -0.5302 0.1359
kw_kind knowledgeable -0.0192 0.4409 -0.0436 0.9653 -0.8834 0.8450
kw_worth 0.2309 0.1289 1.7914 0.0732 -0.0217 0.4835
kw_lee 0.1061 0.1703 0.6231 0.5332 -0.2277 0.4400
kw_educated -0.0689 0.2288 -0.3012 0.7632 -0.5173 0.3795
kw_lack -1.0617 0.1269 -8.3671 0.0000 -1.3104 -0.8130
kw_timely 0.5643 0.2398 2.3530 0.0186 0.0943 1.0344
kw_daughter 0.3664 0.0988 3.7098 0.0002 0.1728 0.5600
kw_used 0.0944 0.1281 0.7371 0.4611 -0.1566 0.3455
kw_bill -0.5049 0.1724 -2.9281 0.0034 -0.8428 -0.1669
kw_dedicated 1.3369 0.4290 3.1160 0.0018 0.4960 2.1779
kw_understood 0.8700 0.2714 3.2062 0.0013 0.3382 1.4019
kw_request 0.0047 0.2208 0.0211 0.9831 -0.4280 0.4374
kw_took care 0.5989 0.3198 1.8728 0.0611 -0.0279 1.2256
kw_worst -0.8256 0.1480 -5.5777 0.0000 -1.1157 -0.5355
kw_staff great -0.6899 0.1693 -4.0739 0.0000 -1.0218 -0.3580
kw_true 0.2211 0.1545 1.4307 0.1525 -0.0818 0.5239
kw_solution 0.1120 0.2555 0.4383 0.6612 -0.3888 0.6128
kw_facility 0.0079 0.2648 0.0298 0.9762 -0.5112 0.5270
kw_continue 0.4955 0.1554 3.1886 0.0014 0.1909 0.8001
kw_highly recommended -0.6296 0.2797 -2.2511 0.0244 -1.1777 -0.0814
kw_scheduled 0.0089 0.1503 0.0592 0.9528 -0.2857 0.3035
kw_punctual -0.0007 0.1663 -0.0042 0.9966 -0.3267 0.3253
kw_would recommend -0.2184 0.1158 -1.8863 0.0593 -0.4453 0.0085
kw_medical history -0.4257 0.3184 -1.3368 0.1813 -1.0498 0.1985
kw_follow 0.0322 0.1565 0.2057 0.8370 -0.2746 0.3390
kw_always take 0.3055 0.3930 0.7774 0.4369 -0.4648 1.0758
kw_vacation -0.0621 0.2011 -0.3087 0.7576 -0.4562 0.3321
kw_word -0.1258 0.1506 -0.8359 0.4032 -0.4209 0.1692
kw_didnt -0.3544 0.1537 -2.3061 0.0211 -0.6555 -0.0532
kw_go anywhere else -0.2365 1.3982 -0.1691 0.8657 -2.9769 2.5039
kw_spent 0.1979 0.1388 1.4260 0.1539 -0.0741 0.4699
kw_loved -0.3816 0.1462 -2.6101 0.0091 -0.6681 -0.0950
kw_never feel rushed -0.0132 0.7216 -0.0182 0.9855 -1.4274 1.4011
kw_co 0.0691 0.0423 1.6357 0.1019 -0.0137 0.1520
kw_surgery -0.0227 0.0709 -0.3208 0.7483 -0.1617 0.1162
kw_comforting 0.2805 0.2918 0.9612 0.3365 -0.2915 0.8525
kw_wait hour -0.1682 0.1915 -0.8784 0.3797 -0.5435 0.2071
kw_extremely helpful 1.1073 0.4528 2.4457 0.0145 0.2199 1.9947
kw_im -0.2219 0.0675 -3.2875 0.0010 -0.3542 -0.0896
kw_going back -0.5943 0.1865 -3.1867 0.0014 -0.9598 -0.2288
kw_promptly -0.3051 0.3559 -0.8572 0.3913 -1.0027 0.3925
kw_wish 0.1090 0.1111 0.9805 0.3268 -0.1089 0.3268
kw_pushed 0.2371 0.3067 0.7729 0.4396 -0.3641 0.8382
kw_mentioned 0.2625 0.3125 0.8400 0.4009 -0.3500 0.8750
kw_someone -0.1636 0.1083 -1.5100 0.1310 -0.3759 0.0487
kw_would -0.0273 0.0519 -0.5261 0.5988 -0.1291 0.0745
kw_later -0.1517 0.1535 -0.9883 0.3230 -0.4526 0.1492
kw_rudely 0.3733 0.4547 0.8210 0.4117 -0.5179 1.2645
kw_leave -0.0637 0.1122 -0.5682 0.5699 -0.2835 0.1561
kw_towards -0.7334 0.2371 -3.0935 0.0020 -1.1981 -0.2687
kw_severe -0.2752 0.1865 -1.4753 0.1401 -0.6408 0.0904
kw_saved 1.1401 0.3031 3.7619 0.0002 0.5461 1.7340
kw_pregnant first -0.1886 0.2400 -0.7858 0.4320 -0.6590 0.2818
kw_several 0.1731 0.1175 1.4734 0.1406 -0.0572 0.4033
kw_short -0.1566 0.1183 -1.3243 0.1854 -0.3885 0.0752
kw_endometriosis -0.2531 0.2058 -1.2295 0.2189 -0.6565 0.1504
kw_really nice 0.6602 0.2726 2.4214 0.0155 0.1258 1.1945
kw_available -0.1162 0.2002 -0.5802 0.5618 -0.5086 0.2763
kw_bed side manner 0.5998 0.6590 0.9102 0.3627 -0.6918 1.8914
kw_post 0.2254 0.1172 1.9236 0.0544 -0.0043 0.4551
kw_provider 0.1258 0.2849 0.4415 0.6588 -0.4326 0.6842
kw_said -0.4216 0.0752 -5.6043 0.0000 -0.5690 -0.2742
kw_pregnancy 0.0242 0.0742 0.3258 0.7446 -0.1213 0.1697
kw_real -0.1135 0.1178 -0.9637 0.3352 -0.3443 0.1173
kw_giving -0.3660 0.1482 -2.4701 0.0135 -0.6563 -0.0756
kw_turned -0.1214 0.2311 -0.5253 0.5994 -0.5742 0.3315
kw_people 0.2820 0.0988 2.8546 0.0043 0.0884 0.4756
kw_explain -0.2369 0.1363 -1.7383 0.0822 -0.5039 0.0302
kw_covered -0.1393 0.2669 -0.5218 0.6018 -0.6623 0.3838
kw_staff nice -0.3003 0.1933 -1.5534 0.1203 -0.6792 0.0786
kw_awful -0.3105 0.1680 -1.8480 0.0646 -0.6398 0.0188
kw_diagnosis -0.0822 0.1455 -0.5649 0.5722 -0.3674 0.2030
kw_horrible experience -0.2197 0.2829 -0.7764 0.4375 -0.7742 0.3349
kw_specialist -0.7586 0.2633 -2.8817 0.0040 -1.2746 -0.2426
kw_around -0.1117 0.1020 -1.0951 0.2735 -0.3117 0.0882
kw_decision -0.0131 0.1290 -0.1012 0.9194 -0.2658 0.2397
kw_infertility 0.0326 0.2853 0.1142 0.9091 -0.5266 0.5917
kw_anything -0.0728 0.1020 -0.7142 0.4751 -0.2727 0.1271
kw_symptom 0.1564 0.1622 0.9644 0.3349 -0.1615 0.4743
kw_patient would 0.0662 0.2755 0.2404 0.8100 -0.4738 0.6062
kw_doc -0.0384 0.0926 -0.4142 0.6787 -0.2200 0.1432
kw_older 0.5442 0.2381 2.2852 0.0223 0.0774 1.0109
kw_ago 0.4014 0.1559 2.5753 0.0100 0.0959 0.7069
kw_chance -0.4902 0.1669 -2.9367 0.0033 -0.8174 -0.1631
kw_fear 0.1628 0.2083 0.7814 0.4346 -0.2455 0.5710
kw_make sure 0.1802 0.1631 1.1045 0.2694 -0.1395 0.4999
kw_say -0.1528 0.0728 -2.0995 0.0358 -0.2954 -0.0102
kw_medical record 0.2657 0.3342 0.7950 0.4266 -0.3893 0.9207
kw_caring compassionate -0.1000 0.3358 -0.2977 0.7659 -0.7582 0.5582
kw_basically -0.4797 0.2228 -2.1526 0.0313 -0.9164 -0.0429
kw_etc -0.0802 0.1387 -0.5782 0.5631 -0.3520 0.1916
kw_get 0.0092 0.0562 0.1640 0.8698 -0.1009 0.1193
kw_read -0.0439 0.1185 -0.3701 0.7113 -0.2761 0.1884
kw_quickly 0.5779 0.1821 3.1736 0.0015 0.2210 0.9348
kw_including 0.2558 0.2089 1.2248 0.2207 -0.1536 0.6652
kw_ten 0.0835 0.0783 1.0663 0.2863 -0.0700 0.2371
kw_put ease 1.2503 0.3262 3.8330 0.0001 0.6110 1.8897
kw_night -0.0631 0.1531 -0.4122 0.6802 -0.3632 0.2370
kw_mean -0.2315 0.1215 -1.9053 0.0567 -0.4697 0.0066
kw_free 0.1791 0.1666 1.0752 0.2823 -0.1474 0.5056
kw_grateful 1.2879 0.2478 5.1972 0.0000 0.8022 1.7736
kw_time went -0.0574 0.2499 -0.2297 0.8183 -0.5472 0.4324
kw_insurance 0.2543 0.1228 2.0703 0.0384 0.0136 0.4950
kw_asking question -0.4014 0.2834 -1.4164 0.1567 -0.9568 0.1540
kw_needed 0.0519 0.0991 0.5237 0.6005 -0.1423 0.2460
kw_bothered -0.2637 0.3303 -0.7984 0.4246 -0.9111 0.3837
kw_prompt 0.8417 0.2562 3.2853 0.0010 0.3396 1.3438
kw_say enough good 51.1623 65871586.5267 0.0000 1.0000 -129105886.0347 129105988.3592
kw_leaf -0.2793 0.2532 -1.1032 0.2699 -0.7755 0.2169
kw_enjoy 0.2532 0.1673 1.5132 0.1302 -0.0748 0.5811
kw_first baby -0.3313 0.2095 -1.5811 0.1139 -0.7419 0.0794
kw_nervous 0.3491 0.1704 2.0487 0.0405 0.0151 0.6831
kw_learn -0.7131 0.1805 -3.9505 0.0001 -1.0669 -0.3593
kw_far best 0.3206 0.4413 0.7264 0.4676 -0.5443 1.1855
kw_really care patient 0.2250 0.3778 0.5956 0.5515 -0.5154 0.9654
kw_see -0.0684 0.0547 -1.2518 0.2107 -0.1756 0.0387
kw_definately 0.3230 0.2835 1.1393 0.2546 -0.2327 0.8787
kw_like -0.0773 0.0539 -1.4347 0.1514 -0.1830 0.0283
kw_delivered first baby 0.8404 0.4824 1.7421 0.0815 -0.1051 1.7860
kw_experience ever -0.0389 0.3632 -0.1070 0.9148 -0.7508 0.6731
kw_tube -0.7669 0.2389 -3.2095 0.0013 -1.2352 -0.2986
kw_discus -0.2338 0.1268 -1.8440 0.0652 -0.4823 0.0147
kw_sense humor -0.0280 0.4462 -0.0627 0.9500 -0.9024 0.8465
kw_genuinely 0.6569 0.3551 1.8498 0.0643 -0.0391 1.3529
kw_honestly -0.9007 0.2611 -3.4495 0.0006 -1.4125 -0.3889
kw_enough good 1.4017 1.7247 0.8127 0.4164 -1.9786 4.7821
kw_le -0.0301 0.0440 -0.6839 0.4941 -0.1164 0.0562
kw_properly 0.0644 0.2720 0.2368 0.8128 -0.4686 0.5975
kw_surgeon 0.5531 0.1563 3.5383 0.0004 0.2467 0.8595
kw_abnormal 0.0524 0.2501 0.2096 0.8340 -0.4378 0.5426
kw_lot 0.0697 0.0809 0.8617 0.3889 -0.0888 0.2282
kw_non -0.1551 0.1357 -1.1434 0.2529 -0.4210 0.1108
kw_terrible -0.2243 0.1249 -1.7952 0.0726 -0.4692 0.0206
kw_dismissive -1.4945 0.3368 -4.4372 0.0000 -2.1546 -0.8344
kw_detailed -0.1064 0.3053 -0.3485 0.7274 -0.7047 0.4919
kw_epidural -0.2446 0.2515 -0.9724 0.3309 -0.7375 0.2484
kw_williams 0.0271 0.3039 0.0892 0.9289 -0.5686 0.6228
kw_remember -0.2775 0.4381 -0.6334 0.5265 -1.1362 0.5812
kw_much better -0.3960 0.2434 -1.6268 0.1038 -0.8732 0.0811
kw_condescending -1.2604 0.2012 -6.2646 0.0000 -1.6547 -0.8661
kw_meet 0.1499 0.1778 0.8430 0.3992 -0.1986 0.4984
kw_anymore -0.3782 0.1890 -2.0015 0.0453 -0.7486 -0.0078
kw_answered 0.0968 0.2008 0.4819 0.6299 -0.2968 0.4904
kw_explains 1.3938 0.3335 4.1793 0.0000 0.7402 2.0475
kw_best obgyn 0.2860 0.6129 0.4667 0.6407 -0.9151 1.4872
kw_six -0.0497 0.2533 -0.1963 0.8443 -0.5461 0.4467
kw_room -0.2848 0.0915 -3.1124 0.0019 -0.4641 -0.1054
kw_respect 0.0999 0.1335 0.7486 0.4541 -0.1617 0.3615
kw_worked 0.1132 0.1712 0.6613 0.5084 -0.2223 0.4487
kw_competent 0.1291 0.1724 0.7490 0.4539 -0.2087 0.4669
kw_wait see 0.2828 0.2390 1.1829 0.2368 -0.1857 0.7513
kw_feel -0.0111 0.0789 -0.1412 0.8877 -0.1658 0.1435
kw_ask question -0.1574 0.1602 -0.9825 0.3259 -0.4713 0.1566
kw_lose -0.6680 0.2652 -2.5194 0.0118 -1.1877 -0.1483
kw_receptionist 0.2740 0.1408 1.9459 0.0517 -0.0020 0.5499
kw_level -0.1898 0.1549 -1.2255 0.2204 -0.4933 0.1137
kw_medical -0.1791 0.1016 -1.7626 0.0780 -0.3782 0.0201
kw_pregnancy delivery 0.1828 0.2899 0.6306 0.5283 -0.3854 0.7511
kw_place -0.1394 0.1112 -1.2534 0.2100 -0.3574 0.0786
kw_experienced 0.1152 0.1492 0.7726 0.4398 -0.1771 0.4076
kw_complication -0.1133 0.1178 -0.9616 0.3362 -0.3443 0.1176
kw_worst experience -1.1800 0.5028 -2.3469 0.0189 -2.1654 -0.1945
kw_wish could 0.5310 0.2800 1.8962 0.0579 -0.0178 1.0799
kw_love love 29.4868 1867906.7082 0.0000 1.0000 -3661000.3877 3661059.3614
kw_staff wonderful 0.6484 0.3012 2.1524 0.0314 0.0580 1.2388
kw_made sure 0.7210 0.2574 2.8014 0.0051 0.2166 1.2254
kw_high risk pregnancy 2.0726 0.7679 2.6990 0.0070 0.5675 3.5776
kw_gyn ever 0.3840 0.5920 0.6486 0.5166 -0.7763 1.5443
kw_personable 0.2291 0.1397 1.6403 0.1009 -0.0447 0.5029
kw_vaginal -0.2319 0.1822 -1.2730 0.2030 -0.5889 0.1251
kw_chose -0.1262 0.1660 -0.7599 0.4473 -0.4515 0.1992
kw_drug -0.7738 0.2305 -3.3569 0.0008 -1.2256 -0.3220
kw_absolutely -0.5666 0.3231 -1.7540 0.0794 -1.1998 0.0665
kw_treated -0.0157 0.1569 -0.1001 0.9202 -0.3233 0.2919
kw_time appointment -0.0251 0.2432 -0.1033 0.9177 -0.5017 0.4515
kw_though 0.0446 0.0991 0.4501 0.6526 -0.1496 0.2387
kw_knowledge 0.1531 0.1109 1.3806 0.1674 -0.0643 0.3705
kw_time see -0.2519 0.1668 -1.5097 0.1311 -0.5788 0.0751
kw_touch 0.0520 0.2083 0.2496 0.8029 -0.3564 0.4604
kw_would highly recommend anyone 1.5134 0.7634 1.9825 0.0474 0.0172 3.0095
kw_unhappy -0.5895 0.2850 -2.0686 0.0386 -1.1481 -0.0310
kw_law -0.5552 0.1979 -2.8061 0.0050 -0.9430 -0.1674
kw_medication -0.3906 0.1567 -2.4921 0.0127 -0.6978 -0.0834
kw_kind caring 0.5012 0.3309 1.5144 0.1299 -0.1475 1.1498
kw_prescribed -0.6078 0.2890 -2.1030 0.0355 -1.1743 -0.0413
kw_stay away -2.6819 0.4941 -5.4282 0.0000 -3.6503 -1.7135
kw_earlier -0.0354 0.2363 -0.1499 0.8809 -0.4985 0.4276
kw_scary 0.4977 0.2900 1.7161 0.0861 -0.0707 1.0661
kw_liked 0.1613 0.1421 1.1346 0.2565 -0.1173 0.4399
kw_go anyone -0.2417 1.0379 -0.2329 0.8158 -2.2759 1.7925
kw_weight -0.1320 0.1553 -0.8497 0.3955 -0.4364 0.1724
kw_never -0.3876 0.0702 -5.5210 0.0000 -0.5252 -0.2500
kw_especially -0.4391 0.2049 -2.1425 0.0322 -0.8408 -0.0374
kw_big -0.0563 0.1306 -0.4311 0.6664 -0.3122 0.1997
kw_outstanding 1.6622 0.2920 5.6924 0.0000 1.0899 2.2345
kw_looked 0.0249 0.1950 0.1275 0.8985 -0.3573 0.4070
kw_oh -0.2938 0.1503 -1.9552 0.0506 -0.5883 0.0007
kw_uncomfortable -0.8055 0.1800 -4.4746 0.0000 -1.1583 -0.4527
kw_changed -0.4003 0.1751 -2.2863 0.0222 -0.7436 -0.0571
kw_waste time -0.2144 0.3555 -0.6031 0.5464 -0.9111 0.4823
kw_nicest 1.3675 0.3917 3.4915 0.0005 0.5999 2.1352
kw_contraction 0.4633 0.3235 1.4323 0.1521 -0.1707 1.0974
kw_two year -0.1868 0.2691 -0.6943 0.4875 -0.7142 0.3405
kw_making -0.0391 0.1306 -0.2997 0.7644 -0.2951 0.2168
kw_showed -0.2015 0.2091 -0.9640 0.3351 -0.6113 0.2082
kw_compassion -0.1836 0.1547 -1.1869 0.2353 -0.4867 0.1196
kw_gyns 0.2481 0.2132 1.1639 0.2445 -0.1697 0.6659
kw_care patient 0.0899 0.1398 0.6429 0.5203 -0.1842 0.3640
kw_mistake -0.5102 0.1969 -2.5903 0.0096 -0.8962 -0.1241
kw_waste -0.4087 0.2605 -1.5686 0.1167 -0.9193 0.1020
kw_able 0.1602 0.0641 2.4984 0.0125 0.0345 0.2859
kw_part -0.0911 0.0998 -0.9123 0.3616 -0.2867 0.1046
kw_bedside -0.9133 0.4046 -2.2574 0.0240 -1.7063 -0.1203
kw_op -0.2015 0.0656 -3.0735 0.0021 -0.3300 -0.0730
kw_three child 1.5586 0.5396 2.8883 0.0039 0.5009 2.6163
kw_informed 0.4223 0.2453 1.7214 0.0852 -0.0585 0.9032
kw_midwife -0.1107 0.2201 -0.5028 0.6151 -0.5420 0.3207
kw_choose -0.2570 0.1778 -1.4455 0.1483 -0.6054 0.0915
kw_calling -0.1070 0.1731 -0.6181 0.5365 -0.4463 0.2323
kw_patient 0.0154 0.0599 0.2563 0.7977 -0.1021 0.1328
kw_clean 0.0360 0.1676 0.2149 0.8298 -0.2925 0.3646
kw_became -0.0011 0.1846 -0.0060 0.9952 -0.3630 0.3608
kw_time answer question 0.1928 0.4935 0.3907 0.6960 -0.7744 1.1599
kw_health care 0.0955 0.2842 0.3360 0.7368 -0.4615 0.6526
kw_baby would 0.1009 0.2831 0.3565 0.7215 -0.4539 0.6557
kw_offer -0.4245 0.1953 -2.1732 0.0298 -0.8073 -0.0417
kw_hurt -0.3685 0.2015 -1.8292 0.0674 -0.7634 0.0264
kw_definitely 0.2716 0.1295 2.0978 0.0359 0.0178 0.5253
kw_office 0.0105 0.0493 0.2136 0.8309 -0.0860 0.1071
kw_full 0.0696 0.1209 0.5759 0.5647 -0.1674 0.3067
kw_biopsy -0.0410 0.2321 -0.1767 0.8597 -0.4959 0.4139
kw_line -0.0117 0.1285 -0.0910 0.9275 -0.2635 0.2401
kw_staff always 0.0639 0.2144 0.2978 0.7658 -0.3564 0.4841
kw_cyst -0.0725 0.1950 -0.3717 0.7101 -0.4548 0.3098
kw_refer 0.0492 0.1257 0.3912 0.6957 -0.1972 0.2956
kw_time talk 0.1048 0.2459 0.4262 0.6700 -0.3771 0.5867
kw_however -0.2862 0.0853 -3.3568 0.0008 -0.4533 -0.1191
kw_child would 0.5740 0.3612 1.5892 0.1120 -0.1339 1.2820
kw_visit -0.3751 0.1068 -3.5110 0.0004 -0.5844 -0.1657
kw_sometimes 0.2133 0.1532 1.3925 0.1638 -0.0869 0.5135
kw_sonogram -0.0464 0.2714 -0.1709 0.8643 -0.5783 0.4855
kw_ahead 0.2426 0.2937 0.8258 0.4089 -0.3331 0.8183
kw_ovarian 0.0504 0.2463 0.2045 0.8380 -0.4324 0.5332
kw_simple -0.4615 0.2231 -2.0680 0.0386 -0.8988 -0.0241
kw_everyone know 0.0979 0.3790 0.2583 0.7961 -0.6449 0.8407
kw_large 0.2598 0.1787 1.4532 0.1462 -0.0906 0.6101
kw_approachable 0.2183 0.3403 0.6415 0.5212 -0.4487 0.8853
kw_feel ease 0.1728 0.5051 0.3420 0.7323 -0.8172 1.1627
kw_doctor like 0.5186 0.3584 1.4469 0.1479 -0.1839 1.2211
kw_cause 0.2720 0.1916 1.4193 0.1558 -0.1036 0.6476
kw_called 0.1018 0.0949 1.0721 0.2837 -0.0843 0.2878
kw_first 0.0024 0.0686 0.0355 0.9717 -0.1321 0.1370
kw_honest 0.7075 0.1692 4.1813 0.0000 0.3759 1.0392
kw_always make feel 0.6120 0.5852 1.0458 0.2957 -0.5350 1.7589
kw_seemed -0.1097 0.1493 -0.7347 0.4625 -0.4023 0.1829
kw_find another -0.8719 0.2252 -3.8724 0.0001 -1.3133 -0.4306
kw_although -0.2190 0.1485 -1.4740 0.1405 -0.5101 0.0722
kw_passed -0.0710 0.2217 -0.3204 0.7487 -0.5056 0.3636
kw_cervix -0.1845 0.2658 -0.6940 0.4877 -0.7055 0.3365
kw_wonderful staff 1.8877 0.5405 3.4927 0.0005 0.8284 2.9469
kw_business -0.3278 0.1576 -2.0797 0.0376 -0.6368 -0.0189
kw_issue -0.1098 0.0710 -1.5477 0.1217 -0.2489 0.0293
kw_take time answer 0.0123 0.6568 0.0187 0.9851 -1.2751 1.2996
kw_birth -0.0582 0.0914 -0.6366 0.5244 -0.2372 0.1209
kw_anybody 0.7840 0.2736 2.8661 0.0042 0.2479 1.3202
kw_good thing -0.1909 0.2474 -0.7716 0.4403 -0.6759 0.2940
kw_truly care 0.5104 0.3582 1.4248 0.1542 -0.1917 1.2124
kw_born -0.2474 0.1187 -2.0849 0.0371 -0.4801 -0.0148
kw_breast -0.2854 0.1940 -1.4709 0.1413 -0.6657 0.0949
kw_requested -0.2024 0.3360 -0.6023 0.5470 -0.8610 0.4562
kw_patient take -0.4742 0.3201 -1.4816 0.1385 -1.1015 0.1531
kw_relationship -0.8012 0.2516 -3.1850 0.0014 -1.2943 -0.3082
kw_yet -0.0162 0.1367 -0.1187 0.9055 -0.2841 0.2516
kw_poor bedside -2.5395 41.6106 -0.0610 0.9513 -84.0948 79.0159
kw_ridiculous -0.4698 0.2405 -1.9539 0.0507 -0.9411 0.0015
kw_another patient -0.1113 0.2741 -0.4060 0.6848 -0.6484 0.4259
kw_address 0.0805 0.1738 0.4632 0.6432 -0.2601 0.4211
kw_need -0.0496 0.0633 -0.7829 0.4337 -0.1737 0.0745
kw_recommend everyone 1.4314 0.4808 2.9774 0.0029 0.4891 2.3737
kw_second 0.1812 0.1043 1.7370 0.0824 -0.0233 0.3857
kw_advise -0.3156 0.2007 -1.5725 0.1158 -0.7089 0.0777
kw_responsive 0.5307 0.2611 2.0327 0.0421 0.0190 1.0424
kw_well 0.1749 0.0610 2.8686 0.0041 0.0554 0.2944
kw_sense 0.0836 0.1821 0.4589 0.6463 -0.2734 0.4406
kw_easy talk 0.2417 0.2401 1.0065 0.3142 -0.2290 0.7124
kw_polite 0.3442 0.1476 2.3312 0.0197 0.0548 0.6335
kw_gentle 0.5077 0.1311 3.8724 0.0001 0.2508 0.7647
kw_dealing -0.0657 0.2179 -0.3014 0.7631 -0.4928 0.3614
kw_glad found 0.4043 0.3714 1.0888 0.2763 -0.3235 1.1322
kw_reassuring 0.8113 0.2505 3.2388 0.0012 0.3203 1.3022
kw_love 1.2000 0.0734 16.3472 0.0000 1.0561 1.3439
kw_female -0.0588 0.2486 -0.2363 0.8132 -0.5460 0.4285
kw_idea -0.2398 0.1857 -1.2915 0.1965 -0.6038 0.1241
kw_three 0.1266 0.1509 0.8393 0.4013 -0.1691 0.4224
kw_rate 0.0328 0.0945 0.3473 0.7283 -0.1523 0.2179
kw_top 0.1278 0.1434 0.8913 0.3727 -0.1532 0.4088
kw_would highly -0.0394 0.5085 -0.0775 0.9383 -1.0360 0.9572
kw_new patient -0.0774 0.1882 -0.4113 0.6808 -0.4462 0.2914
kw_done -0.0780 0.0848 -0.9195 0.3578 -0.2443 0.0883
kw_pelvic -0.3440 0.2023 -1.7006 0.0890 -0.7405 0.0525
kw_site -0.0174 0.1669 -0.1043 0.9169 -0.3445 0.3097
kw_fine -0.3413 0.1137 -3.0028 0.0027 -0.5641 -0.1185
kw_visited -0.1180 0.2589 -0.4557 0.6486 -0.6255 0.3895
kw_high risk 0.4411 0.2653 1.6630 0.0963 -0.0788 0.9611
kw_long time 0.1834 0.1734 1.0576 0.2902 -0.1564 0.5232
kw_never problem 0.8224 0.2621 3.1378 0.0017 0.3087 1.3362
kw_looking new -0.2954 0.2734 -1.0807 0.2798 -0.8313 0.2404
kw_caring 0.9671 0.0722 13.3914 0.0000 0.8256 1.1087
kw_delivered first -0.5259 0.3082 -1.7064 0.0879 -1.1299 0.0781
kw_deal -0.2105 0.1264 -1.6649 0.0959 -0.4583 0.0373
kw_nice -0.2440 0.0606 -4.0258 0.0001 -0.3628 -0.1252
kw_problem -0.0356 0.0645 -0.5518 0.5811 -0.1619 0.0908
kw_successful 0.3861 0.2122 1.8195 0.0688 -0.0298 0.8021
kw_number 0.1669 0.1255 1.3298 0.1836 -0.0791 0.4129
kw_complicated 0.4263 0.2218 1.9220 0.0546 -0.0084 0.8610
kw_made feel ease 0.8927 0.6255 1.4272 0.1535 -0.3333 2.1186
kw_last visit -0.6372 0.2700 -2.3601 0.0183 -1.1663 -0.1080
kw_let 0.0090 0.0935 0.0957 0.9237 -0.1743 0.1922
kw_get back 0.2040 0.2583 0.7897 0.4297 -0.3022 0.7101
kw_uterus -0.1781 0.1991 -0.8945 0.3710 -0.5684 0.2122
kw_confident 0.3424 0.1701 2.0131 0.0441 0.0090 0.6758
kw_poor -0.2668 0.1457 -1.8318 0.0670 -0.5523 0.0187
kw_vbac -0.3141 0.2325 -1.3506 0.1768 -0.7698 0.1417
kw_term 0.1652 0.1374 1.2026 0.2291 -0.1041 0.4346
kw_also 0.0656 0.0567 1.1584 0.2467 -0.0454 0.1767
kw_easy 0.4192 0.1405 2.9832 0.0029 0.1438 0.6945
kw_hour see -0.0276 0.2026 -0.1364 0.8915 -0.4248 0.3695
kw_wasnt 0.2706 0.2572 1.0519 0.2928 -0.2335 0.7747
kw_several year -0.3113 0.2244 -1.3876 0.1652 -0.7511 0.1284
kw_aware 0.0797 0.2148 0.3711 0.7106 -0.3413 0.5008
kw_history 0.1066 0.2848 0.3742 0.7082 -0.4517 0.6649
kw_huge -0.3474 0.2089 -1.6635 0.0962 -0.7568 0.0619
kw_many doctor 1.0938 0.2937 3.7243 0.0002 0.5182 1.6694
kw_she -0.1170 0.1474 -0.7934 0.4275 -0.4059 0.1720
kw_paperwork -0.6926 0.3536 -1.9587 0.0501 -1.3856 0.0004
kw_personally 0.5501 0.1833 3.0009 0.0027 0.1908 0.9094
kw_hormone -0.0194 0.1929 -0.1007 0.9198 -0.3975 0.3587
kw_glad 0.5043 0.1317 3.8290 0.0001 0.2462 0.7624
kw_important -0.0547 0.1214 -0.4505 0.6523 -0.2926 0.1832
kw_question concern 0.0556 0.1731 0.3209 0.7483 -0.2838 0.3949
kw_heart -0.0544 0.1827 -0.2976 0.7660 -0.4124 0.3037
kw_asking -0.0846 0.1856 -0.4561 0.6483 -0.4483 0.2791
kw_prescription 0.1035 0.1775 0.5834 0.5596 -0.2443 0.4514
kw_caring knowledgeable -0.3462 0.3338 -1.0371 0.2997 -1.0005 0.3081
kw_missed -0.7470 0.2274 -3.2852 0.0010 -1.1926 -0.3013
kw_strongly 0.4177 0.2568 1.6268 0.1038 -0.0855 0.9209
kw_really like 0.5073 0.1667 3.0429 0.0023 0.1805 0.8340
kw_careful 0.2883 0.2072 1.3912 0.1642 -0.1179 0.6945
kw_moment 0.2278 0.2844 0.8009 0.4232 -0.3296 0.7851
kw_always 0.4481 0.0867 5.1670 0.0000 0.2782 0.6181
kw_lb 0.1710 0.1500 1.1401 0.2542 -0.1229 0.4649
kw_make 0.0676 0.0739 0.9153 0.3600 -0.0772 0.2123
kw_already 0.0698 0.2207 0.3164 0.7517 -0.3628 0.5025
kw_exam room 0.3761 0.1893 1.9875 0.0469 0.0052 0.7471
kw_unfriendly -1.0164 0.2440 -4.1660 0.0000 -1.4946 -0.5382
kw_pushing -0.0676 0.2702 -0.2502 0.8025 -0.5972 0.4620
kw_year later -0.7046 0.2403 -2.9319 0.0034 -1.1756 -0.2336
kw_called office -0.4005 0.2339 -1.7125 0.0868 -0.8589 0.0579
kw_previous 0.6799 0.1186 5.7313 0.0000 0.4474 0.9124
kw_hand 0.2786 0.1100 2.5329 0.0113 0.0630 0.4942
kw_forget 0.0777 0.1904 0.4081 0.6832 -0.2955 0.4510
kw_use -0.2528 0.0891 -2.8366 0.0046 -0.4274 -0.0781
kw_always time 0.6751 0.2810 2.4023 0.0163 0.1243 1.2258
kw_god 0.1176 0.1749 0.6724 0.5013 -0.2253 0.4605
kw_others 0.1020 0.1235 0.8261 0.4087 -0.1400 0.3441
kw_always make -0.2831 0.4127 -0.6862 0.4926 -1.0920 0.5257
kw_incompetent -0.7286 0.2915 -2.4996 0.0124 -1.2999 -0.1573
kw_ran 0.0216 0.0783 0.2754 0.7830 -0.1319 0.1750
kw_within 0.5000 0.1509 3.3147 0.0009 0.2044 0.7957
kw_compassionate caring 0.0170 0.4287 0.0397 0.9683 -0.8232 0.8573
kw_everyone 0.0295 0.1428 0.2067 0.8362 -0.2503 0.3093
kw_met 0.2205 0.1042 2.1167 0.0343 0.0163 0.4246
kw_regular -0.0608 0.1365 -0.4457 0.6558 -0.3283 0.2067
kw_cannot 0.0784 0.1583 0.4955 0.6202 -0.2318 0.3886
kw_enough good thing -0.4348 2.3250 -0.1870 0.8517 -4.9916 4.1221
kw_every question -0.1371 0.3574 -0.3837 0.7012 -0.8376 0.5633
kw_upset -0.3137 0.3148 -0.9967 0.3189 -0.9306 0.3032
kw_concern -0.1954 0.0777 -2.5141 0.0119 -0.3477 -0.0431
kw_always felt -0.3552 0.2674 -1.3285 0.1840 -0.8792 0.1688
kw_went -0.0884 0.0622 -1.4209 0.1553 -0.2103 0.0335
kw_center -0.0897 0.2075 -0.4323 0.6655 -0.4965 0.3171
kw_become -0.5376 0.2170 -2.4776 0.0132 -0.9629 -0.1123
kw_baby girl 0.0679 0.2966 0.2290 0.8188 -0.5135 0.6494
kw_pre -0.0925 0.0599 -1.5443 0.1225 -0.2098 0.0249
kw_bleeding 0.0109 0.2256 0.0483 0.9614 -0.4313 0.4532
kw_bed side -0.9472 0.5258 -1.8015 0.0716 -1.9777 0.0833
kw_never make 0.9883 0.3932 2.5135 0.0120 0.2177 1.7589
kw_delivered three -0.0930 0.4797 -0.1939 0.8463 -1.0332 0.8472
kw_thoughtful 0.9370 0.3178 2.9483 0.0032 0.3141 1.5598
kw_drive 0.3735 0.1907 1.9582 0.0502 -0.0003 0.7474
kw_wonderful caring -0.5141 0.3746 -1.3724 0.1699 -1.2484 0.2201
kw_performed 0.3408 0.2216 1.5377 0.1241 -0.0936 0.7751
kw_incredibly 0.3112 0.2199 1.4155 0.1569 -0.1197 0.7422
kw_form -0.0729 0.1512 -0.4820 0.6298 -0.3692 0.2235
kw_share -0.0746 0.2270 -0.3285 0.7425 -0.5195 0.3704
kw_prior 0.1769 0.1463 1.2087 0.2268 -0.1099 0.4637
kw_bad 0.1384 0.0837 1.6534 0.0982 -0.0257 0.3024
kw_question never 0.3745 0.2857 1.3107 0.1900 -0.1855 0.9344
kw_many friend 0.9810 0.4951 1.9815 0.0475 0.0107 1.9513
kw_called back 0.0317 0.2144 0.1476 0.8827 -0.3887 0.4520
kw_great great 0.1143 0.3978 0.2873 0.7739 -0.6654 0.8940
kw_beyond 0.5615 0.2012 2.7906 0.0053 0.1671 0.9558
kw_needle say 0.5255 0.5515 0.9529 0.3406 -0.5554 1.6064
kw_family 0.0777 0.1106 0.7027 0.4823 -0.1390 0.2944
kw_using 0.1234 0.1349 0.9148 0.3603 -0.1410 0.3879
kw_pill -0.2450 0.1954 -1.2538 0.2099 -0.6280 0.1380
kw_following -0.1367 0.2148 -0.6364 0.5245 -0.5576 0.2843
kw_professional caring -0.0122 0.4381 -0.0279 0.9778 -0.8709 0.8465
kw_health issue -0.1048 0.2799 -0.3745 0.7080 -0.6534 0.4438
kw_switch -0.1365 0.1632 -0.8361 0.4031 -0.4565 0.1835
kw_never feel 1.5494 0.5679 2.7281 0.0064 0.4363 2.6625
kw_every visit -0.5241 0.2682 -1.9541 0.0507 -1.0498 0.0016
kw_option 0.7375 0.1363 5.4115 0.0000 0.4704 1.0046
kw_best doctor 0.4896 1.1254 0.4350 0.6635 -1.7162 2.6954
kw_month -0.1964 0.0814 -2.4120 0.0159 -0.3560 -0.0368
kw_sick -0.1424 0.2079 -0.6848 0.4935 -0.5498 0.2651
kw_empathetic 0.4303 0.2770 1.5538 0.1202 -0.1125 0.9732
kw_switching -0.5613 0.2467 -2.2753 0.0229 -1.0447 -0.0778
kw_talked 0.0131 0.1641 0.0797 0.9365 -0.3086 0.3347
kw_enough -0.1279 0.1055 -1.2124 0.2253 -0.3347 0.0789
kw_pain -0.1450 0.0919 -1.5773 0.1147 -0.3251 0.0352
kw_comfort 0.4386 0.2077 2.1118 0.0347 0.0315 0.8457
kw_bring -0.0356 0.1781 -0.1997 0.8417 -0.3846 0.3135
kw_must 0.2072 0.1522 1.3619 0.1732 -0.0910 0.5054
kw_shocked 0.0309 0.2223 0.1390 0.8895 -0.4048 0.4665
kw_poorly -0.3855 0.3434 -1.1228 0.2615 -1.0585 0.2874
kw_anyway -0.1020 0.2200 -0.4636 0.6429 -0.5332 0.3292
kw_like family 1.8520 0.5524 3.3529 0.0008 0.7694 2.9346
kw_hope 0.2689 0.1193 2.2541 0.0242 0.0351 0.5026
kw_horrible -0.3002 0.1070 -2.8057 0.0050 -0.5099 -0.0905
kw_take time patient -0.0301 0.3854 -0.0780 0.9378 -0.7855 0.7254
kw_crazy -0.0164 0.2339 -0.0700 0.9442 -0.4747 0.4420
kw_gave 0.1992 0.0875 2.2758 0.0229 0.0276 0.3708
kw_best ob gyn ever 0.3719 1.0816 0.3439 0.7309 -1.7479 2.4917
kw_individual 0.1529 0.2261 0.6764 0.4988 -0.2902 0.5961
kw_letter -0.7238 0.2745 -2.6371 0.0084 -1.2618 -0.1859
kw_better -0.0891 0.0828 -1.0763 0.2818 -0.2514 0.0732
kw_worse -0.7690 0.1833 -4.1954 0.0000 -1.1283 -0.4098
kw_kind patient 0.6281 0.3940 1.5941 0.1109 -0.1441 1.4003
kw_avoid -1.1074 0.1663 -6.6576 0.0000 -1.4334 -0.7814
kw_good bedside manner -0.7872 0.9231 -0.8528 0.3938 -2.5964 1.0220
kw_ordered -0.3532 0.2753 -1.2830 0.1995 -0.8926 0.1863
kw_else -0.1436 0.1319 -1.0884 0.2764 -0.4021 0.1150
kw_delivered baby -0.0126 0.1816 -0.0694 0.9447 -0.3684 0.3432
kw_thanks -0.3047 0.1934 -1.5755 0.1151 -0.6838 0.0743
kw_sincere 0.5705 0.2655 2.1490 0.0316 0.0502 1.0909
kw_make appointment -0.0516 0.1891 -0.2727 0.7851 -0.4221 0.3190
kw_anyone 0.1614 0.1024 1.5756 0.1151 -0.0394 0.3621
kw_year old 0.2345 0.1885 1.2437 0.2136 -0.1351 0.6040
kw_broke 0.1144 0.2479 0.4614 0.6445 -0.3714 0.6002
kw_date 0.3284 0.1349 2.4346 0.0149 0.0640 0.5927
kw_section -0.1429 0.0807 -1.7704 0.0767 -0.3012 0.0153
kw_wonderful bedside manner 0.0967 1.1652 0.0830 0.9338 -2.1870 2.3805
kw_far 0.1385 0.0961 1.4411 0.1496 -0.0499 0.3270
kw_caused -1.2337 0.3042 -4.0560 0.0000 -1.8298 -0.6375
kw_general -0.0707 0.1569 -0.4507 0.6522 -0.3782 0.2368
kw_took time answer question -0.9594 0.8606 -1.1148 0.2649 -2.6462 0.7273
kw_baby boy -0.1116 0.3490 -0.3197 0.7492 -0.7956 0.5725
kw_heard -0.2690 0.1863 -1.4438 0.1488 -0.6342 0.0962
kw_feel like -0.2177 0.1418 -1.5354 0.1247 -0.4955 0.0602
kw_referred 0.2200 0.1687 1.3041 0.1922 -0.1107 0.5507
kw_listen concern -0.2075 0.2457 -0.8443 0.3985 -0.6890 0.2741
kw_go anywhere 0.8925 1.2300 0.7256 0.4681 -1.5182 3.3032
kw_checked -0.0535 0.1911 -0.2797 0.7797 -0.4280 0.3211
kw_single -0.0131 0.2268 -0.0577 0.9540 -0.4575 0.4314
kw_diagnose -0.1412 0.2318 -0.6092 0.5424 -0.5956 0.3131
kw_required -0.1866 0.2396 -0.7790 0.4360 -0.6563 0.2830
kw_paid 0.0446 0.1759 0.2535 0.7999 -0.3002 0.3894
kw_half -0.3349 0.1457 -2.2979 0.0216 -0.6205 -0.0493
kw_insurance company -0.3323 0.4413 -0.7531 0.4514 -1.1972 0.5325
kw_extra 0.4691 0.1592 2.9473 0.0032 0.1571 0.7810
kw_little 0.2117 0.0833 2.5428 0.0110 0.0485 0.3749
kw_face -0.3451 0.1659 -2.0805 0.0375 -0.6702 -0.0200
kw_recommend friend 0.9179 0.2936 3.1268 0.0018 0.3425 1.4933
kw_always take time 0.0459 0.5337 0.0861 0.9314 -1.0001 1.0919
kw_friend 0.2165 0.1019 2.1235 0.0337 0.0167 0.4163
kw_profession 0.0211 0.2666 0.0792 0.9369 -0.5014 0.5436
kw_boy 0.1652 0.1869 0.8836 0.3769 -0.2012 0.5315
kw_np -0.4793 0.1457 -3.2903 0.0010 -0.7649 -0.1938
kw_he -0.0394 0.0483 -0.8156 0.4147 -0.1340 0.0552
kw_story -0.0454 0.2220 -0.2046 0.8379 -0.4805 0.3897
kw_great sense humor -16.2742 6316.8346 -0.0026 0.9979 -12397.0425 12364.4940
kw_tried -0.3532 0.1318 -2.6805 0.0074 -0.6115 -0.0949
kw_take time talk -0.3459 0.4172 -0.8290 0.4071 -1.1637 0.4719
kw_area 0.0658 0.1053 0.6250 0.5320 -0.1406 0.2723
kw_company 0.0549 0.3779 0.1454 0.8844 -0.6858 0.7957
kw_woman -0.1977 0.0902 -2.1912 0.0284 -0.3746 -0.0209
kw_front -0.0340 0.1488 -0.2285 0.8192 -0.3256 0.2576
kw_always helpful 0.2586 0.2951 0.8763 0.3809 -0.3197 0.8369
kw_recommended friend 0.3727 0.3398 1.0966 0.2728 -0.2934 1.0388
kw_retired 0.3545 0.2379 1.4902 0.1362 -0.1117 0.8207
kw_risk -0.5237 0.1902 -2.7536 0.0059 -0.8965 -0.1509
kw_really care 0.6733 0.2070 3.2520 0.0011 0.2675 1.0791
kw_recently 0.0690 0.1376 0.5012 0.6162 -0.2008 0.3388
kw_dismissed 0.0115 0.3159 0.0365 0.9709 -0.6076 0.6306
kw_delivery 0.0507 0.1039 0.4878 0.6257 -0.1529 0.2543
kw_beginning -0.2158 0.2250 -0.9592 0.3374 -0.6568 0.2252
kw_er -0.1224 0.0490 -2.4961 0.0126 -0.2185 -0.0263
kw_ready 0.1766 0.2083 0.8477 0.3966 -0.2317 0.5848
kw_obgyn ever -1.5488 0.8413 -1.8409 0.0656 -3.1978 0.1001
kw_type -0.0899 0.1510 -0.5950 0.5518 -0.3858 0.2061
kw_scar -0.1125 0.1320 -0.8520 0.3942 -0.3712 0.1463
kw_birth control -0.1365 0.2853 -0.4786 0.6322 -0.6957 0.4226
kw_person 0.1230 0.1046 1.1752 0.2399 -0.0821 0.3280
kw_trust 0.5395 0.1017 5.3041 0.0000 0.3401 0.7388
kw_believe -0.2878 0.1098 -2.6206 0.0088 -0.5030 -0.0725
kw_plus -0.0859 0.1901 -0.4518 0.6514 -0.4585 0.2867
kw_certain -0.2941 0.2051 -1.4340 0.1516 -0.6961 0.1079
kw_take -0.1114 0.0745 -1.4965 0.1345 -0.2574 0.0345
kw_throughout 0.9334 0.2597 3.5942 0.0003 0.4244 1.4424
kw_recomend 0.1321 0.2321 0.5693 0.5692 -0.3228 0.5871
kw_answered question 0.7047 0.2233 3.1552 0.0016 0.2669 1.1424
kw_two 0.1021 0.0855 1.1938 0.2326 -0.0655 0.2698
kw_earth 0.9504 0.2206 4.3091 0.0000 0.5181 1.3827
kw_felt like -0.2324 0.1536 -1.5134 0.1302 -0.5334 0.0686
kw_ever 0.0382 0.0619 0.6160 0.5379 -0.0833 0.1596
kw_really listens 0.2053 0.4959 0.4139 0.6789 -0.7667 1.1772
kw_go anyone else 1.7667 1.2888 1.3708 0.1704 -0.7593 4.2927
kw_bless 0.9775 0.4170 2.3442 0.0191 0.1602 1.7948
kw_assistant -0.1587 0.1639 -0.9683 0.3329 -0.4799 0.1625
kw_scared 0.0113 0.2671 0.0422 0.9663 -0.5122 0.5347
kw_needle -0.9966 0.4830 -2.0633 0.0391 -1.9433 -0.0499
kw_skill 0.4281 0.1534 2.7903 0.0053 0.1274 0.7287
kw_know 0.1966 0.0574 3.4250 0.0006 0.0841 0.3091
kw_usually 0.1939 0.1360 1.4255 0.1540 -0.0727 0.4605
kw_gynecologist 0.2366 0.1651 1.4333 0.1518 -0.0869 0.5601
kw_early -0.0037 0.1271 -0.0292 0.9767 -0.2528 0.2454
kw_dont -0.4228 0.1425 -2.9679 0.0030 -0.7020 -0.1436
kw_completely -0.2467 0.1913 -1.2895 0.1972 -0.6217 0.1283
kw_positive 0.1977 0.1521 1.2998 0.1937 -0.1004 0.4959
kw_referral -0.4204 0.2726 -1.5421 0.1231 -0.9547 0.1139
kw_saw -0.1777 0.0767 -2.3155 0.0206 -0.3280 -0.0273
kw_want -0.1765 0.0670 -2.6358 0.0084 -0.3077 -0.0452
kw_find 0.0052 0.0783 0.0665 0.9470 -0.1483 0.1587
kw_first visit 0.0727 0.1529 0.4757 0.6343 -0.2269 0.3724
kw_waited hour -0.2526 0.2441 -1.0348 0.3008 -0.7309 0.2258
kw_lost -0.3097 0.1392 -2.2259 0.0260 -0.5825 -0.0370
kw_patient year 0.2730 0.2328 1.1725 0.2410 -0.1833 0.7292
kw_pa -0.0156 0.0552 -0.2817 0.7782 -0.1238 0.0927
kw_provides 0.9962 0.3900 2.5542 0.0106 0.2317 1.7606
kw_recommend friend family -0.2080 0.6541 -0.3180 0.7505 -1.4901 1.0740
kw_one -0.0176 0.0491 -0.3598 0.7190 -0.1138 0.0785
kw_annual 0.1030 0.1681 0.6127 0.5401 -0.2264 0.4323
kw_great experience 0.6397 0.2546 2.5128 0.0120 0.1407 1.1386
kw_appointment -0.0929 0.1164 -0.7980 0.4249 -0.3212 0.1353
kw_interest -0.4651 0.2394 -1.9432 0.0520 -0.9343 0.0040
kw_time explain 0.5970 0.2771 2.1546 0.0312 0.0539 1.1400
kw_amount 0.3160 0.1855 1.7037 0.0884 -0.0475 0.6796
kw_meeting -0.3657 0.2933 -1.2466 0.2125 -0.9406 0.2093
kw_close 0.7926 0.2974 2.6650 0.0077 0.2097 1.3754
kw_state 0.0560 0.1531 0.3657 0.7146 -0.2441 0.3560
kw_much time 0.2872 0.2191 1.3104 0.1901 -0.1423 0.7167
kw_anyone else 0.9226 0.2579 3.5767 0.0003 0.4170 1.4281
kw_cell -0.1762 nan nan nan nan nan
kw_great sense 16.3211 6316.8345 0.0026 0.9979 -12364.4471 12397.0893
kw_plan 0.1943 0.1046 1.8583 0.0631 -0.0106 0.3993
kw_bit 0.2028 0.1088 1.8643 0.0623 -0.0104 0.4159
kw_waited -0.5541 0.1343 -4.1271 0.0000 -0.8172 -0.2909
kw_answering question -0.1471 0.3326 -0.4424 0.6582 -0.7990 0.5047
kw_time needed -0.4399 0.4120 -1.0675 0.2857 -1.2474 0.3677
kw_direct 0.1264 0.1610 0.7852 0.4323 -0.1891 0.4420
kw_calm 0.6154 0.1586 3.8800 0.0001 0.3045 0.9263
kw_worry 0.2120 0.1716 1.2356 0.2166 -0.1243 0.5483
kw_across -0.1270 0.2220 -0.5718 0.5674 -0.5621 0.3082
kw_communication -0.6822 0.2241 -3.0444 0.0023 -1.1214 -0.2430
kw_inside -0.5997 0.3252 -1.8443 0.0651 -1.2370 0.0376
kw_explained everything 0.9586 0.3407 2.8134 0.0049 0.2908 1.6264
kw_pressure -0.2602 0.2675 -0.9728 0.3307 -0.7846 0.2641
kw_making feel 1.1861 0.4093 2.8980 0.0038 0.3839 1.9882
kw_customer 0.2663 0.2447 1.0885 0.2764 -0.2132 0.7459
kw_performed surgery 0.1548 0.2935 0.5273 0.5980 -0.4204 0.7299
kw_went back -0.6366 0.2378 -2.6774 0.0074 -1.1027 -0.1706
kw_speaks 0.6331 0.3093 2.0466 0.0407 0.0268 1.2394
kw_research -0.4102 0.1604 -2.5568 0.0106 -0.7246 -0.0958
kw_tumor 0.2498 0.2716 0.9198 0.3577 -0.2825 0.7821
kw_best obgyn ever 1.2870 0.9773 1.3169 0.1879 -0.6285 3.2025
kw_reason -0.2589 0.1184 -2.1860 0.0288 -0.4911 -0.0268
kw_would go 0.2192 0.1713 1.2793 0.2008 -0.1166 0.5549
kw_go back -0.4326 0.1500 -2.8832 0.0039 -0.7267 -0.1385
kw_considerate -0.0479 0.2538 -0.1889 0.8502 -0.5453 0.4494
kw_refused -0.0625 0.3514 -0.1777 0.8589 -0.7513 0.6264
kw_rather 0.0312 0.1313 0.2373 0.8124 -0.2262 0.2885
kw_annual exam 0.1742 0.2956 0.5894 0.5556 -0.4052 0.7537
kw_ask -0.3054 0.0972 -3.1409 0.0017 -0.4960 -0.1148
kw_even -0.0878 0.0546 -1.6087 0.1077 -0.1947 0.0192
kw_ob gyn ever -0.3515 0.9504 -0.3698 0.7115 -2.2143 1.5114
kw_time patient -0.2043 0.1833 -1.1149 0.2649 -0.5636 0.1549
kw_going 0.1257 0.0662 1.8973 0.0578 -0.0041 0.2555
kw_never felt rushed 2.5536 0.4924 5.1863 0.0000 1.5886 3.5187
kw_great would 1.4509 0.5006 2.8981 0.0038 0.4697 2.4321
kw_message 0.4687 0.1818 2.5784 0.0099 0.1124 0.8250
kw_information -0.2081 0.2283 -0.9116 0.3620 -0.6555 0.2393
kw_correct -0.5272 0.1371 -3.8467 0.0001 -0.7959 -0.2586
kw_hr -0.0705 0.0891 -0.7919 0.4284 -0.2451 0.1041
kw_unprofessional -1.4181 0.2014 -7.0408 0.0000 -1.8129 -1.0234
kw_nurse practitioner -0.5340 0.3945 -1.3538 0.1758 -1.3072 0.2391
kw_recommend family friend 1.2678 1.0861 1.1673 0.2431 -0.8609 3.3965
kw_suffered 0.2176 0.2687 0.8100 0.4179 -0.3089 0.7442
kw_knowledgable 0.6690 0.1210 5.5295 0.0000 0.4319 0.9061
kw_get know 0.0694 0.2772 0.2503 0.8024 -0.4740 0.6128
kw_mother -0.1635 0.1296 -1.2616 0.2071 -0.4175 0.0905
kw_many -0.2284 0.1021 -2.2381 0.0252 -0.4285 -0.0284
kw_misdiagnosed -1.6088 0.3361 -4.7868 0.0000 -2.2675 -0.9501
kw_truly care patient 1.1241 0.6016 1.8685 0.0617 -0.0550 2.3033
kw_pcos 0.0476 0.2724 0.1748 0.8612 -0.4863 0.5815
kw_time never 0.1999 0.2511 0.7962 0.4259 -0.2922 0.6920
kw_explaining 0.5785 0.2179 2.6547 0.0079 0.1514 1.0057
kw_expertise -0.2838 0.3786 -0.7498 0.4534 -1.0258 0.4581
kw_drs 0.2498 0.1828 1.3662 0.1719 -0.1086 0.6082
kw_rushed -0.1632 0.2025 -0.8063 0.4201 -0.5601 0.2336
kw_decided -0.1864 0.1348 -1.3828 0.1667 -0.4505 0.0778
kw_instead -0.5635 0.1208 -4.6659 0.0000 -0.8003 -0.3268
kw_professionalism -0.5777 0.2135 -2.7058 0.0068 -0.9962 -0.1592
kw_today 0.4137 0.1548 2.6726 0.0075 0.1103 0.7171
kw_favorite 0.4830 0.2668 1.8102 0.0703 -0.0400 1.0059
kw_time make -0.1400 0.2951 -0.4742 0.6354 -0.7184 0.4385
kw_start -0.1543 0.2836 -0.5440 0.5864 -0.7101 0.4015
kw_always willing 1.2554 0.3989 3.1472 0.0016 0.4736 2.0372
kw_either -0.3797 0.1345 -2.8231 0.0048 -0.6433 -0.1161
kw_amazing 1.7101 0.1111 15.3949 0.0000 1.4924 1.9278
kw_sat 0.5522 0.1535 3.5977 0.0003 0.2514 0.8530
kw_informative 1.3398 0.2647 5.0625 0.0000 0.8211 1.8586
kw_wait 0.1003 0.0748 1.3412 0.1799 -0.0463 0.2469
kw_soon 0.1737 0.1418 1.2246 0.2207 -0.1043 0.4517
kw_left -0.4098 0.0851 -4.8127 0.0000 -0.5766 -0.2429
kw_delivering baby 0.2802 0.2520 1.1122 0.2661 -0.2136 0.7741
kw_response -0.5458 0.1965 -2.7776 0.0055 -0.9309 -0.1607
kw_told would 0.0842 0.2199 0.3828 0.7019 -0.3468 0.5151
kw_routine -0.2010 0.1663 -1.2091 0.2266 -0.5269 0.1249
kw_kept 0.2738 0.1404 1.9506 0.0511 -0.0013 0.5489
kw_insensitive -1.7324 0.3324 -5.2117 0.0000 -2.3839 -1.0809
kw_wouldnt -0.2904 0.3030 -0.9586 0.3378 -0.8843 0.3034
kw_doctor ever 0.2336 0.3288 0.7103 0.4775 -0.4109 0.8781
kw_desk -0.4150 0.3356 -1.2364 0.2163 -1.0728 0.2429
kw_explain everything 0.9720 0.4329 2.2452 0.0248 0.1235 1.8206
kw_expect -0.1552 0.1241 -1.2507 0.2110 -0.3984 0.0880
kw_team 0.6030 0.2632 2.2911 0.0220 0.0871 1.1188
kw_impatient -0.3784 0.2756 -1.3729 0.1698 -0.9186 0.1618
kw_file -0.1398 0.2150 -0.6505 0.5154 -0.5611 0.2815
kw_spends 0.0804 0.2625 0.3062 0.7594 -0.4340 0.5948
kw_expert 0.9295 0.2963 3.1368 0.0017 0.3487 1.5103
kw_child -0.0892 0.0776 -1.1494 0.2504 -0.2412 0.0629
kw_st -0.0444 0.0451 -0.9849 0.3247 -0.1329 0.0440
kw_day later 0.0580 0.2740 0.2117 0.8323 -0.4789 0.5949
kw_would highly recommend -0.2770 0.5551 -0.4990 0.6178 -1.3650 0.8110
kw_related 0.1159 0.2326 0.4982 0.6183 -0.3400 0.5717
kw_could ask 1.0455 0.3377 3.0964 0.0020 0.3837 1.7074
kw_death -0.2509 0.2546 -0.9852 0.3245 -0.7500 0.2482
kw_exactly 0.6166 0.2126 2.9001 0.0037 0.1999 1.0332
kw_made feel like 0.0634 0.2861 0.2215 0.8247 -0.4974 0.6241
kw_smart 0.9164 0.1612 5.6832 0.0000 0.6004 1.2324
kw_young -0.2116 0.1288 -1.6430 0.1004 -0.4640 0.0408
kw_unable -0.5906 0.2595 -2.2759 0.0228 -1.0991 -0.0820
kw_thankful -0.8883 0.2233 -3.9775 0.0001 -1.3260 -0.4506
kw_always made feel -1.7234 0.5931 -2.9056 0.0037 -2.8859 -0.5609
kw_never wait 0.9598 0.2300 4.1730 0.0000 0.5090 1.4105
kw_recommend -0.1405 0.0970 -1.4489 0.1474 -0.3307 0.0496
kw_question 0.0524 0.0708 0.7398 0.4594 -0.0864 0.1911
kw_ok -0.2434 0.0904 -2.6913 0.0071 -0.4207 -0.0661
kw_phone call -0.5072 0.2033 -2.4942 0.0126 -0.9057 -0.1086
kw_time would -0.2530 0.2436 -1.0384 0.2991 -0.7305 0.2245
kw_come 0.0854 0.0775 1.1010 0.2709 -0.0666 0.2374
kw_saying -0.1710 0.1645 -1.0397 0.2985 -0.4934 0.1514
kw_rating -0.0834 0.1347 -0.6194 0.5357 -0.3474 0.1806
kw_sent -0.1479 0.0962 -1.5371 0.1243 -0.3364 0.0407
kw_pregnancy always 0.2417 0.3628 0.6661 0.5054 -0.4694 0.9528
kw_loss -0.3303 0.2121 -1.5574 0.1194 -0.7460 0.0854
kw_entire 0.1538 0.1381 1.1134 0.2655 -0.1169 0.4244
kw_forever -0.3450 0.2002 -1.7231 0.0849 -0.7375 0.0474
kw_side 0.0261 0.1136 0.2301 0.8180 -0.1965 0.2488
kw_seen 0.0709 0.0837 0.8466 0.3972 -0.0932 0.2350
kw_examination 0.6120 0.2376 2.5757 0.0100 0.1463 1.0776
kw_please -0.8540 0.1806 -4.7278 0.0000 -1.2081 -0.5000
kw_natural 0.1971 0.1627 1.2113 0.2258 -0.1218 0.5160
kw_felt -0.2608 0.0883 -2.9540 0.0031 -0.4339 -0.0878
kw_allowed 0.3585 0.2831 1.2662 0.2054 -0.1964 0.9133
kw_call 0.0340 0.0660 0.5152 0.6064 -0.0953 0.1633
kw_cannot say -0.5301 0.5546 -0.9559 0.3391 -1.6171 0.5569
kw_year ago -0.5938 0.1886 -3.1482 0.0016 -0.9634 -0.2241
kw_thank 1.0487 0.1383 7.5847 0.0000 0.7777 1.3197
kw_point -0.0744 0.1046 -0.7107 0.4772 -0.2794 0.1307
kw_cover -0.1898 0.1647 -1.1525 0.2491 -0.5125 0.1330
kw_talking -0.0527 0.1401 -0.3764 0.7066 -0.3273 0.2219
kw_began -0.2660 0.2377 -1.1190 0.2631 -0.7319 0.1999
kw_act -0.1924 0.0829 -2.3199 0.0203 -0.3549 -0.0299
kw_get see 0.1666 0.2315 0.7197 0.4717 -0.2871 0.6203
kw_someone else -0.1472 0.2538 -0.5800 0.5619 -0.6446 0.3502
kw_excited -0.0487 0.2411 -0.2018 0.8401 -0.5213 0.4239
kw_super 0.5123 0.1579 3.2435 0.0012 0.2027 0.8218
kw_job 0.0624 0.1183 0.5275 0.5979 -0.1695 0.2943
kw_took 0.5434 0.1120 4.8536 0.0000 0.3239 0.7628
kw_manner -0.1282 0.1607 -0.7977 0.4250 -0.4433 0.1868
kw_note -0.2648 0.2164 -1.2240 0.2210 -0.6889 0.1592
kw_probably -0.3830 0.1466 -2.6130 0.0090 -0.6703 -0.0957
kw_always made 0.9215 0.5030 1.8319 0.0670 -0.0644 1.9075
kw_rd -0.0517 0.0679 -0.7610 0.4467 -0.1848 0.0815
kw_patient care 0.1124 0.2771 0.4058 0.6849 -0.4306 0.6555
kw_sign -0.1051 0.1539 -0.6833 0.4944 -0.4067 0.1964
kw_question would -0.3751 0.2863 -1.3105 0.1900 -0.9362 0.1859
kw_another -0.1716 0.0748 -2.2943 0.0218 -0.3182 -0.0250
kw_supportive 0.0749 0.2318 0.3230 0.7467 -0.3795 0.5292
kw_perform -0.2886 0.2190 -1.3176 0.1876 -0.7178 0.1407
kw_get appointment 0.4220 0.1997 2.1126 0.0346 0.0305 0.8134
kw_considering -0.0121 0.2460 -0.0493 0.9607 -0.4943 0.4700
kw_great bedside 1.2928 0.7810 1.6552 0.0979 -0.2381 2.8236
kw_walked -0.1930 0.2402 -0.8034 0.4218 -0.6638 0.2778
kw_entire pregnancy -0.0393 0.3097 -0.1270 0.8990 -0.6463 0.5677
kw_prenatal -0.1957 0.2168 -0.9024 0.3668 -0.6206 0.2293
kw_seems 0.1243 0.1302 0.9549 0.3396 -0.1308 0.3794
kw_took time 0.8948 0.1742 5.1376 0.0000 0.5534 1.2361
kw_pleased 1.2749 0.1941 6.5687 0.0000 0.8945 1.6553
kw_otherwise -0.0419 0.2425 -0.1726 0.8630 -0.5171 0.4334
kw_human 0.1448 0.1805 0.8024 0.4223 -0.2089 0.4985
kw_good bedside 1.0995 0.8988 1.2233 0.2212 -0.6621 2.8611
kw_answering 0.1592 0.2729 0.5836 0.5595 -0.3756 0.6940
kw_longer -0.0085 0.1404 -0.0607 0.9516 -0.2837 0.2667
kw_finally -0.1264 0.1138 -1.1103 0.2669 -0.3494 0.0967
kw_nightmare -0.4500 0.3316 -1.3573 0.1747 -1.0999 0.1998
kw_efficient 0.4522 0.1797 2.5163 0.0119 0.1000 0.8044
kw_never rush 2.2782 0.3504 6.5012 0.0000 1.5913 2.9650
kw_handled 0.3054 0.3101 0.9849 0.3247 -0.3023 0.9131
kw_fact 0.0061 0.1208 0.0501 0.9601 -0.2308 0.2429
kw_last year -0.1591 0.2092 -0.7604 0.4470 -0.5692 0.2510
kw_gynecological 0.1133 0.2634 0.4303 0.6670 -0.4029 0.6296
kw_miller 0.3443 0.3411 1.0094 0.3128 -0.3243 1.0129
kw_gone 0.3776 0.1315 2.8720 0.0041 0.1199 0.6353
kw_hospital 0.0188 0.0751 0.2507 0.8020 -0.1284 0.1660
kw_twin 0.3867 0.1886 2.0506 0.0403 0.0171 0.7563
kw_asked question -0.2767 0.2225 -1.2434 0.2137 -0.7129 0.1595
kw_gyno 0.0355 0.1820 0.1953 0.8452 -0.3211 0.3922
kw_travel 0.9341 0.2983 3.1312 0.0017 0.3494 1.5187
kw_make feel ease -0.3922 0.6211 -0.6314 0.5278 -1.6095 0.8252
kw_necessary 0.2213 0.1638 1.3511 0.1767 -0.0997 0.5424
kw_manor 0.1426 0.3865 0.3689 0.7122 -0.6149 0.9000
kw_labor -0.1658 0.1724 -0.9616 0.3363 -0.5037 0.1721
kw_bad experience 0.1748 0.2040 0.8569 0.3915 -0.2250 0.5745
kw_clear -0.1882 0.1674 -1.1244 0.2608 -0.5163 0.1399
kw_working 0.3728 0.1740 2.1423 0.0322 0.0317 0.7138
kw_induced -0.1914 0.2098 -0.9121 0.3617 -0.6026 0.2199
kw_addition -0.1248 0.1738 -0.7180 0.4727 -0.4656 0.2159
kw_arrived -0.1409 0.2137 -0.6595 0.5096 -0.5598 0.2779
kw_rushing -0.0174 0.2456 -0.0710 0.9434 -0.4988 0.4639
kw_seriously 0.1668 0.2321 0.7185 0.4724 -0.2881 0.6216
kw_upon -0.1712 0.2203 -0.7770 0.4372 -0.6030 0.2606
kw_attentive 0.3257 0.1514 2.1509 0.0315 0.0289 0.6224
kw_year always 0.3538 0.2502 1.4141 0.1573 -0.1366 0.8442
kw_nursing -0.4492 0.2617 -1.7167 0.0860 -0.9621 0.0636
kw_every step 0.5825 0.4270 1.3643 0.1725 -0.2543 1.4193
kw_testing -0.1775 0.1962 -0.9049 0.3655 -0.5620 0.2070
kw_sit 0.2214 0.0936 2.3647 0.0180 0.0379 0.4049
kw_fit -0.1720 0.1775 -0.9689 0.3326 -0.5199 0.1759
kw_whole 0.0080 0.1132 0.0707 0.9436 -0.2138 0.2298
kw_school -0.2214 0.2198 -1.0072 0.3138 -0.6522 0.2094
kw_staff amazing -0.9245 0.3807 -2.4285 0.0152 -1.6707 -0.1784
kw_thing -0.1804 0.0697 -2.5892 0.0096 -0.3170 -0.0438
kw_except 0.0193 0.1996 0.0965 0.9231 -0.3719 0.4104
kw_trying get 0.2899 0.2638 1.0990 0.2718 -0.2271 0.8070
kw_fertility -0.0468 0.2035 -0.2300 0.8181 -0.4457 0.3520
kw_arrogant -1.4107 0.2179 -6.4750 0.0000 -1.8378 -0.9837
kw_name -0.1441 0.1490 -0.9671 0.3335 -0.4362 0.1480
kw_unless 0.1360 0.1610 0.8446 0.3983 -0.1795 0.4514
kw_imagine 0.6528 0.2301 2.8368 0.0046 0.2018 1.1038
kw_time get -0.2272 0.2183 -1.0410 0.2979 -0.6550 0.2006
kw_excellent 1.4464 0.1892 7.6431 0.0000 1.0755 1.8173
kw_never recommend -1.9813 0.6436 -3.0786 0.0021 -3.2427 -0.7199
kw_beautiful 0.2588 0.1918 1.3490 0.1773 -0.1172 0.6348
kw_year would 0.5276 0.3441 1.5334 0.1252 -0.1468 1.2020
kw_excellent bedside manner -59.5651 33656753713608532.0000 -0.0000 1.0000 -65966025115207496.0000 65966025115207384.0000
kw_excellent bedside 59.8489 33656753713608528.0000 0.0000 1.0000 -65966025115207376.0000 65966025115207488.0000
kw_run -0.0752 0.1171 -0.6418 0.5210 -0.3048 0.1544
kw_long wait -0.0833 0.1661 -0.5017 0.6159 -0.4089 0.2422
kw_known -0.0677 0.1805 -0.3752 0.7075 -0.4216 0.2861
kw_ever seen 0.0817 0.2149 0.3802 0.7038 -0.3395 0.5029
kw_knowing -0.1969 0.2063 -0.9546 0.3398 -0.6012 0.2074
kw_great ob -0.0936 0.2677 -0.3498 0.7265 -0.6183 0.4311
kw_major -0.4342 0.1990 -2.1817 0.0291 -0.8243 -0.0441
kw_spend -0.1900 0.1780 -1.0674 0.2858 -0.5388 0.1588
kw_almost year -0.2645 0.2546 -1.0389 0.2989 -0.7634 0.2345
kw_actually 0.2075 0.1106 1.8764 0.0606 -0.0092 0.4243
kw_caring patient -0.6608 0.3256 -2.0297 0.0424 -1.2989 -0.0227
kw_perfect 0.1409 0.1782 0.7908 0.4291 -0.2083 0.4901
kw_would definitely 0.3255 0.3912 0.8322 0.4053 -0.4412 1.0923
kw_obviously -0.1001 0.2337 -0.4286 0.6682 -0.5581 0.3578
kw_sound -0.3008 0.2027 -1.4840 0.1378 -0.6982 0.0965
kw_good hand 1.4641 0.4847 3.0206 0.0025 0.5141 2.4141
kw_time always -0.2223 0.2751 -0.8083 0.4189 -0.7614 0.3168
kw_family member -0.1525 0.4908 -0.3107 0.7560 -1.1145 0.8095
kw_telling -0.2562 0.1687 -1.5192 0.1287 -0.5868 0.0743
kw_high 0.0614 0.1255 0.4892 0.6247 -0.1846 0.3075
kw_miscarriage 0.1909 0.1840 1.0379 0.2993 -0.1696 0.5515
kw_due 0.1811 0.0913 1.9833 0.0473 0.0021 0.3601
kw_risk pregnancy -1.8745 0.7358 -2.5475 0.0109 -3.3167 -0.4323
kw_happy 0.2979 0.0878 3.3909 0.0007 0.1257 0.4701
kw_blood test 0.0553 0.2983 0.1854 0.8529 -0.5293 0.6399
kw_alot 0.3403 0.2113 1.6101 0.1074 -0.0739 0.7545
kw_went see -0.4000 0.2092 -1.9117 0.0559 -0.8100 0.0101
kw_next day -0.1126 0.2184 -0.5154 0.6062 -0.5406 0.3155
kw_chart -0.2728 0.1831 -1.4901 0.1362 -0.6316 0.0860
kw_went labor 0.0150 0.2444 0.0613 0.9511 -0.4641 0.4940
kw_stuck -0.0896 0.2478 -0.3617 0.7176 -0.5752 0.3960
kw_would recommend anyone 0.5235 0.2312 2.2646 0.0235 0.0704 0.9766
kw_practice -0.0830 0.0948 -0.8755 0.3813 -0.2687 0.1028
kw_staff friendly 0.0221 0.1610 0.1371 0.8910 -0.2935 0.3377
kw_girl 0.0132 0.1393 0.0950 0.9243 -0.2598 0.2863
kw_laid -0.7805 0.7471 -1.0447 0.2961 -2.2447 0.6837
kw_fast 0.2094 0.1492 1.4031 0.1606 -0.0831 0.5019
kw_would never -0.0740 0.1826 -0.4053 0.6853 -0.4319 0.2839
kw_pregnancy would 0.1804 0.3047 0.5921 0.5538 -0.4168 0.7776
kw_absolute 0.6595 0.2973 2.2180 0.0266 0.0767 1.2422
kw_bladder -0.2203 0.2506 -0.8793 0.3793 -0.7114 0.2708
kw_professional 0.7491 0.2765 2.7090 0.0067 0.2071 1.2911
kw_review 0.0686 0.1022 0.6707 0.5024 -0.1318 0.2689
kw_look forward 2.0148 0.4473 4.5041 0.0000 1.1380 2.8915
kw_taking 0.0148 0.1334 0.1112 0.9115 -0.2467 0.2763
kw_recommend highly 1.9657 0.6553 2.9998 0.0027 0.6814 3.2501
kw_great job -0.0639 0.2731 -0.2341 0.8149 -0.5992 0.4713
kw_spoken 0.4512 0.2970 1.5191 0.1287 -0.1309 1.0332
kw_tear -0.0747 0.1981 -0.3772 0.7060 -0.4630 0.3136
kw_patient feel -0.1303 0.2841 -0.4584 0.6467 -0.6871 0.4266
kw_return -0.0386 0.2349 -0.1641 0.8696 -0.4990 0.4219
kw_highly recommend anyone -0.5893 0.5224 -1.1282 0.2592 -1.6131 0.4345
kw_consider -0.0607 0.1739 -0.3491 0.7270 -0.4014 0.2801
kw_brought 0.4659 0.2619 1.7791 0.0752 -0.0473 0.9791
kw_week later 0.0670 0.2534 0.2643 0.7916 -0.4297 0.5637
kw_nd 0.0346 0.0488 0.7095 0.4780 -0.0610 0.1302
kw_walk -0.0254 0.1611 -0.1577 0.8747 -0.3411 0.2903
kw_funny 0.7930 0.2685 2.9534 0.0031 0.2667 1.3193
kw_throughout pregnancy -0.3152 0.3006 -1.0485 0.2944 -0.9044 0.2740
kw_cancer 0.0258 0.1414 0.1822 0.8554 -0.2513 0.3029
kw_paper 0.6386 0.2871 2.2242 0.0261 0.0759 1.2013
kw_get pregnant -0.0829 0.2176 -0.3811 0.7032 -0.5094 0.3435
kw_stress -0.1099 0.1461 -0.7522 0.4519 -0.3962 0.1764
kw_least -0.2086 0.1126 -1.8535 0.0638 -0.4293 0.0120
kw_interested -0.1969 0.2400 -0.8206 0.4118 -0.6673 0.2734
kw_provided 0.3645 0.2748 1.3264 0.1847 -0.1741 0.9031
kw_pregnant -0.1635 0.0903 -1.8115 0.0701 -0.3404 0.0134
kw_moved 0.7836 0.2444 3.2063 0.0013 0.3046 1.2626
kw_write -0.1728 0.2215 -0.7801 0.4353 -0.6069 0.2613
kw_listener 0.4332 0.2629 1.6479 0.0994 -0.0820 0.9484
kw_gyn 0.0852 0.0971 0.8773 0.3803 -0.1051 0.2754
kw_hour -0.2718 0.0737 -3.6868 0.0002 -0.4162 -0.1273
kw_future 0.5405 0.1854 2.9154 0.0036 0.1771 0.9039
kw_check -0.1479 0.0945 -1.5654 0.1175 -0.3332 0.0373
kw_thats 0.1291 0.2654 0.4863 0.6267 -0.3911 0.6492
kw_leaving -0.0698 0.1830 -0.3816 0.7028 -0.4285 0.2889
kw_delivered two 0.1542 0.3520 0.4380 0.6614 -0.5357 0.8440
kw_time go -0.0719 0.1739 -0.4133 0.6794 -0.4126 0.2689
kw_patient always 0.3176 0.3454 0.9195 0.3578 -0.3594 0.9946
kw_spoke -0.1666 0.2094 -0.7955 0.4263 -0.5770 0.2439
kw_consultation 0.4929 0.2560 1.9257 0.0541 -0.0088 0.9946
kw_dealt 0.6961 0.3064 2.2715 0.0231 0.0955 1.2967
kw_bc 0.2345 0.2159 1.0861 0.2774 -0.1887 0.6576
kw_schedule 0.1031 0.1171 0.8805 0.3786 -0.1264 0.3327
kw_knowledgeable helpful -0.1964 0.3190 -0.6156 0.5382 -0.8217 0.4289
kw_literally -0.3336 0.2259 -1.4766 0.1398 -0.7763 0.1092
kw_pleasure 0.7043 0.3666 1.9211 0.0547 -0.0142 1.4228
kw_question always -0.0604 0.2891 -0.2088 0.8346 -0.6269 0.5062
kw_normal -0.0495 0.1247 -0.3973 0.6911 -0.2940 0.1949
kw_highly 0.6271 0.2117 2.9622 0.0031 0.2122 1.0421
kw_gotten 0.2223 0.2151 1.0332 0.3015 -0.1994 0.6439
kw_simply 0.1429 0.1917 0.7454 0.4561 -0.2329 0.5187
kw_felt comfortable 0.6148 0.2538 2.4225 0.0154 0.1174 1.1122
kw_doctor 0.2575 0.1082 2.3805 0.0173 0.0455 0.4695
kw_best ob 0.3540 0.4268 0.8295 0.4068 -0.4825 1.1904
kw_pregnant woman 0.2432 0.2488 0.9775 0.3283 -0.2444 0.7309
kw_anxiety 0.0893 0.2656 0.3363 0.7366 -0.4312 0.6098
kw_cant -0.4212 0.2034 -2.0709 0.0384 -0.8199 -0.0226
kw_unhelpful -0.8444 0.2143 -3.9401 0.0001 -1.2644 -0.4243
kw_step -0.2706 0.2016 -1.3421 0.1796 -0.6657 0.1246
kw_maybe -0.4805 0.1654 -2.9058 0.0037 -0.8046 -0.1564
kw_asked -0.0187 0.1200 -0.1559 0.8761 -0.2538 0.2164
kw_two week 0.2618 0.2479 1.0562 0.2909 -0.2240 0.7476
kw_scheduling 0.1505 0.1888 0.7970 0.4255 -0.2196 0.5205
kw_patience 0.3055 0.2144 1.4246 0.1543 -0.1148 0.7257
kw_personality -0.3715 0.1704 -2.1796 0.0293 -0.7055 -0.0374
kw_life 0.1633 0.0846 1.9306 0.0535 -0.0025 0.3291
kw_nothing -0.0715 0.1080 -0.6618 0.5081 -0.2832 0.1402
kw_delivery room 0.0411 0.2761 0.1487 0.8818 -0.5001 0.5822
kw_twice -0.3238 0.1477 -2.1924 0.0283 -0.6132 -0.0343
kw_course 0.0172 0.1701 0.1011 0.9195 -0.3163 0.3507
kw_friendly -0.1571 0.1155 -1.3601 0.1738 -0.3834 0.0693
kw_genuine 0.2786 0.2362 1.1795 0.2382 -0.1844 0.7417
kw_expecting -0.0208 0.2478 -0.0841 0.9330 -0.5064 0.4648
kw_standard -0.1931 0.2510 -0.7694 0.4417 -0.6851 0.2988
kw_every 0.4967 0.0933 5.3252 0.0000 0.3139 0.6795
kw_anywhere -0.5437 0.3500 -1.5534 0.1203 -1.2297 0.1423
kw_together -0.0717 0.2484 -0.2888 0.7728 -0.5586 0.4152
kw_delivered daughter -0.2121 0.2271 -0.9340 0.3503 -0.6571 0.2330
kw_side manner 0.1888 0.4516 0.4180 0.6759 -0.6964 1.0740
kw_difficult 0.2547 0.1222 2.0838 0.0372 0.0151 0.4942
kw_smile -0.1099 0.3385 -0.3247 0.7454 -0.7734 0.5536
kw_regard -0.1390 0.1888 -0.7366 0.4614 -0.5090 0.2309
kw_spent time 0.4648 0.3154 1.4737 0.1406 -0.1534 1.0830
kw_friendly knowledgeable 0.1197 0.4024 0.2974 0.7661 -0.6689 0.9083
kw_rush -0.4262 0.1070 -3.9818 0.0001 -0.6360 -0.2164
kw_shes 0.3011 0.3109 0.9687 0.3327 -0.3081 0.9104
kw_followed 0.6210 0.2326 2.6704 0.0076 0.1652 1.0768
kw_five 0.1457 0.2129 0.6844 0.4938 -0.2715 0.5629
kw_none 0.2721 0.2571 1.0583 0.2899 -0.2318 0.7761
kw_coming -0.0737 0.1544 -0.4772 0.6332 -0.3762 0.2289
kw_treat patient 0.1427 0.2791 0.5112 0.6092 -0.4044 0.6898
kw_pay 0.0170 0.1221 0.1391 0.8894 -0.2223 0.2562
kw_report -0.7383 0.2209 -3.3421 0.0008 -1.1712 -0.3053
kw_ever met 0.3256 0.2608 1.2484 0.2119 -0.1856 0.8368
kw_detail 0.2064 0.1634 1.2630 0.2066 -0.1139 0.5267
kw_send -0.0794 0.1449 -0.5479 0.5838 -0.3634 0.2046
kw_supposed -0.1102 0.2004 -0.5498 0.5824 -0.5031 0.2827
kw_return phone call -0.4796 1.2424 -0.3860 0.6995 -2.9146 1.9554
kw_everything 0.0398 0.1230 0.3237 0.7462 -0.2013 0.2810
kw_barely -0.4331 0.2366 -1.8309 0.0671 -0.8968 0.0305
kw_anytime 0.8434 0.3364 2.5067 0.0122 0.1839 1.5028
kw_good 0.0192 0.0634 0.3030 0.7619 -0.1050 0.1434
kw_charged 0.2571 0.2800 0.9180 0.3586 -0.2918 0.8059
kw_without 0.0675 0.0878 0.7686 0.4421 -0.1045 0.2395
kw_control -0.2427 0.2142 -1.1333 0.2571 -0.6625 0.1770
kw_staff rude 0.2659 0.1545 1.7209 0.0853 -0.0369 0.5688
kw_fun -0.1340 0.1969 -0.6805 0.4962 -0.5199 0.2519
kw_pretty -0.3272 0.1440 -2.2723 0.0231 -0.6095 -0.0450
kw_despite -0.0344 0.2136 -0.1612 0.8719 -0.4530 0.3841
kw_order 0.0361 0.1589 0.2269 0.8205 -0.2755 0.3476
kw_wonderful 0.9081 0.0783 11.5948 0.0000 0.7546 1.0616
kw_doesnt -0.1179 0.2070 -0.5694 0.5691 -0.5237 0.2879
kw_multiple -0.0032 0.1812 -0.0174 0.9861 -0.3582 0.3519
kw_okay -0.0461 0.2010 -0.2292 0.8187 -0.4400 0.3478
kw_kind compassionate -0.1627 0.3720 -0.4374 0.6618 -0.8919 0.5664
kw_love staff 0.0709 0.3776 0.1878 0.8510 -0.6692 0.8111
kw_genuinely care -0.1172 0.4402 -0.2663 0.7900 -0.9800 0.7456
kw_health 0.1795 0.1017 1.7658 0.0774 -0.0197 0.3788
kw_taken care 0.7738 0.2926 2.6447 0.0082 0.2003 1.3472
kw_confidence 0.6408 0.2489 2.5742 0.0100 0.1529 1.1287
kw_behind -0.0097 0.1644 -0.0588 0.9531 -0.3318 0.3125
kw_pap smear -0.0656 0.7256 -0.0903 0.9280 -1.4876 1.3565
kw_natural birth -0.4364 0.2852 -1.5303 0.1260 -0.9954 0.1225
kw_listens patient -0.3640 0.3987 -0.9130 0.3613 -1.1454 0.4174
kw_spends time 1.0027 0.3875 2.5873 0.0097 0.2431 1.7623
kw_friendly helpful 0.0833 0.2119 0.3933 0.6941 -0.3320 0.4986
kw_happened -0.2050 0.2244 -0.9132 0.3611 -0.6448 0.2349
kw_excellent physician 0.9937 0.6897 1.4407 0.1497 -0.3581 2.3455
kw_explains thing -0.3610 0.4586 -0.7872 0.4312 -1.2599 0.5379
kw_doubt 0.0956 0.2204 0.4339 0.6644 -0.3363 0.5276
kw_ability -0.1914 0.1731 -1.1059 0.2688 -0.5306 0.1478
kw_ignored -0.8644 0.2600 -3.3250 0.0009 -1.3739 -0.3549
kw_make feel comfortable 0.0142 0.2620 0.0542 0.9568 -0.4994 0.5278
kw_would definitely recommend -0.8485 0.5833 -1.4547 0.1457 -1.9917 0.2947
kw_stuff 0.3617 0.2258 1.6021 0.1091 -0.0808 0.8041
kw_baby -0.0848 0.0653 -1.2979 0.1943 -0.2128 0.0432
kw_checkup 0.1893 0.2393 0.7908 0.4291 -0.2798 0.6583
kw_sad 0.5766 0.1423 4.0523 0.0001 0.2977 0.8554
kw_office manager -0.7541 0.5091 -1.4814 0.1385 -1.7519 0.2436
kw_trouble -0.3856 0.2266 -1.7018 0.0888 -0.8297 0.0585
kw_different -0.2083 0.0927 -2.2473 0.0246 -0.3900 -0.0266
kw_outcome -0.3096 0.2784 -1.1121 0.2661 -0.8552 0.2360
kw_mind 0.1228 0.1269 0.9676 0.3333 -0.1260 0.3716
kw_painful 0.1736 0.1920 0.9040 0.3660 -0.2028 0.5499
kw_said would 0.0908 0.2597 0.3496 0.7267 -0.4182 0.5997
kw_field -0.0955 0.1433 -0.6666 0.5050 -0.3764 0.1853
kw_great care 0.0101 0.2908 0.0347 0.9723 -0.5599 0.5801
kw_surprised 0.1106 0.1946 0.5685 0.5697 -0.2707 0.4920
kw_infection -0.6109 0.1829 -3.3393 0.0008 -0.9694 -0.2523
kw_reading -0.0272 0.2113 -0.1287 0.8976 -0.4414 0.3870
kw_fibroid 0.0908 0.1984 0.4578 0.6471 -0.2981 0.4798
kw_doctor office -0.2719 0.2419 -1.1243 0.2609 -0.7460 0.2021
kw_menopause -0.1560 0.2554 -0.6108 0.5413 -0.6566 0.3446
kw_primary 0.1384 0.1931 0.7168 0.4735 -0.2401 0.5169
kw_book 0.2933 0.1416 2.0711 0.0384 0.0157 0.5709
kw_total -0.0437 0.1940 -0.2251 0.8219 -0.4240 0.3366
kw_left office -0.3027 0.2667 -1.1351 0.2564 -0.8254 0.2200
kw_top notch -30.4640 7365808.1359 -0.0000 1.0000 -14436749.1274 14436688.1995
kw_yr 0.4167 0.1278 3.2611 0.0011 0.1663 0.6672
kw_never go back -0.7064 0.3638 -1.9418 0.0522 -1.4194 0.0066
kw_fix -0.1873 0.1933 -0.9691 0.3325 -0.5662 0.1916
kw_complaint 0.5039 0.1225 4.1133 0.0000 0.2638 0.7440
kw_group 0.2569 0.1620 1.5853 0.1129 -0.0607 0.5744
kw_go -0.1352 0.0523 -2.5878 0.0097 -0.2377 -0.0328
kw_caring take 0.3195 0.5079 0.6290 0.5294 -0.6760 1.3149
kw_recommend office -0.3445 0.3065 -1.1239 0.2610 -0.9451 0.2562
kw_ob gyn 0.1253 0.1306 0.9596 0.3372 -0.1306 0.3812
kw_record -0.6740 0.1869 -3.6052 0.0003 -1.0404 -0.3076
kw_wish would -0.5351 0.2620 -2.0423 0.0411 -1.0486 -0.0216
kw_respectful -0.2596 0.2025 -1.2818 0.1999 -0.6566 0.1374
kw_thorough 1.2565 0.1858 6.7608 0.0000 0.8922 1.6207
kw_fantastic 1.5201 0.1823 8.3391 0.0000 1.1629 1.8774
kw_time office 0.1047 0.2464 0.4248 0.6710 -0.3783 0.5877
kw_anyone looking 0.6842 0.4878 1.4026 0.1607 -0.2719 1.6404
kw_male 0.2183 0.2193 0.9956 0.3195 -0.2115 0.6481
kw_diagnosed 0.0464 0.2667 0.1741 0.8618 -0.4763 0.5692
kw_stated -0.2211 0.2516 -0.8786 0.3796 -0.7143 0.2721
kw_greatest 0.0723 0.3221 0.2246 0.8223 -0.5590 0.7037
kw_know stuff 0.1771 0.3125 0.5666 0.5710 -0.4355 0.7896
kw_third 0.3727 0.1826 2.0413 0.0412 0.0148 0.7306
kw_th -0.0108 0.0468 -0.2317 0.8168 -0.1026 0.0809
kw_whenever 0.7616 0.2749 2.7705 0.0056 0.2228 1.3004
kw_pt -0.2804 0.0781 -3.5887 0.0003 -0.4335 -0.1273
kw_result -0.3408 0.0979 -3.4803 0.0005 -0.5328 -0.1489
kw_bed 0.0459 0.1856 0.2473 0.8047 -0.3178 0.4096
kw_service -0.2594 0.1094 -2.3711 0.0177 -0.4739 -0.0450
kw_serious -0.0748 0.1626 -0.4599 0.6456 -0.3936 0.2440
kw_professional knowledgeable 0.1959 0.4255 0.4603 0.6453 -0.6381 1.0299
kw_end 0.0022 0.0708 0.0304 0.9757 -0.1366 0.1409
kw_ob 0.0770 0.0633 1.2177 0.2233 -0.0470 0.2010
kw_waiting -0.0617 0.1138 -0.5424 0.5875 -0.2848 0.1613
kw_nearly -0.4974 0.2550 -1.9503 0.0511 -0.9972 0.0025
kw_family friend 0.4303 0.3463 1.2423 0.2141 -0.2485 1.1091
kw_seeing year 0.9708 0.3454 2.8104 0.0049 0.2938 1.6479
kw_long -0.0381 0.0880 -0.4330 0.6650 -0.2106 0.1344
kw_seeing 0.1418 0.0869 1.6318 0.1027 -0.0285 0.3121
kw_hear 0.0833 0.1363 0.6110 0.5412 -0.1838 0.3503
kw_cry -0.2286 0.2061 -1.1092 0.2674 -0.6325 0.1753
kw_ask better 1.0155 0.4245 2.3925 0.0167 0.1836 1.8474
kw_tech 0.0851 0.1671 0.5090 0.6107 -0.2425 0.4127
kw_compassionate 0.7591 0.1840 4.1258 0.0000 0.3985 1.1197
kw_treating 0.0124 0.2660 0.0467 0.9627 -0.5089 0.5338
kw_kindness 0.7137 0.3352 2.1296 0.0332 0.0568 1.3706
kw_elsewhere -0.7629 0.2515 -3.0339 0.0024 -1.2557 -0.2701
kw_relaxed 0.9759 0.3236 3.0161 0.0026 0.3417 1.6101
kw_lab 0.0110 0.1400 0.0784 0.9375 -0.2634 0.2853
kw_test result 0.0193 0.1833 0.1051 0.9163 -0.3400 0.3786
kw_mom -0.0994 0.1503 -0.6613 0.5084 -0.3940 0.1952
kw_provide -0.0714 0.2079 -0.3433 0.7314 -0.4788 0.3361
kw_suggest -0.1324 0.2008 -0.6592 0.5098 -0.5259 0.2612
kw_make feel 0.4796 0.1809 2.6512 0.0080 0.1250 0.8342
kw_laid back 1.0625 0.8060 1.3183 0.1874 -0.5172 2.6423
kw_busy -0.1282 0.1010 -1.2693 0.2043 -0.3261 0.0698
kw_respected 0.8143 0.3036 2.6819 0.0073 0.2192 1.4094
kw_blessing 0.4153 0.5830 0.7124 0.4762 -0.7273 1.5579
kw_insisted -0.4921 0.2650 -1.8570 0.0633 -1.0115 0.0273
kw_new -0.0445 0.0810 -0.5493 0.5828 -0.2033 0.1143
kw_still -0.0561 0.0758 -0.7402 0.4592 -0.2047 0.0925
kw_say enough 2.9224 0.5363 5.4491 0.0000 1.8712 3.9736
kw_listen -0.7818 0.2045 -3.8237 0.0001 -1.1826 -0.3811
kw_turn -0.0871 0.1686 -0.5166 0.6054 -0.4177 0.2434
kw_suggested 0.3324 0.2775 1.1977 0.2310 -0.2116 0.8764
kw_time 0.0721 0.0757 0.9519 0.3411 -0.0763 0.2205
kw_ended -0.2857 0.1069 -2.6733 0.0075 -0.4951 -0.0762
kw_finding -0.1228 0.1804 -0.6808 0.4960 -0.4765 0.2308
kw_recommend woman 0.9907 0.4193 2.3627 0.0181 0.1689 1.8125
kw_abrupt -0.0754 0.2377 -0.3172 0.7511 -0.5413 0.3905
kw_case -0.1662 0.1331 -1.2487 0.2118 -0.4270 0.0947
kw_head -0.2667 0.1603 -1.6633 0.0962 -0.5809 0.0476
kw_helpful knowledgeable 0.2977 0.3462 0.8600 0.3898 -0.3808 0.9763
kw_give 0.0690 0.0863 0.7996 0.4239 -0.1002 0.2382
kw_forward 0.3752 0.2122 1.7683 0.0770 -0.0407 0.7912
kw_fabulous 1.3602 0.2705 5.0278 0.0000 0.8299 1.8904
kw_wrong 0.1457 0.1040 1.4007 0.1613 -0.0582 0.3497
kw_location 0.3150 0.2415 1.3043 0.1921 -0.1584 0.7884
kw_man 0.1237 0.0684 1.8084 0.0705 -0.0104 0.2577
kw_appreciated -0.2174 0.3052 -0.7122 0.4763 -0.8156 0.3808
kw_ive -0.1226 0.0621 -1.9751 0.0483 -0.2443 -0.0009
kw_caring professional -0.2635 0.4239 -0.6216 0.5342 -1.0942 0.5673
kw_minute -0.1072 0.0998 -1.0746 0.2826 -0.3027 0.0883
kw_listened 1.1653 0.1764 6.6068 0.0000 0.8196 1.5110
kw_attention -0.1861 0.1567 -1.1879 0.2349 -0.4932 0.1210
kw_emergency 0.2531 0.1073 2.3583 0.0184 0.0427 0.4634
kw_came 0.1662 0.0873 1.9038 0.0569 -0.0049 0.3372
kw_blood pressure 0.4809 0.3718 1.2936 0.1958 -0.2477 1.2096
kw_cared 0.4501 0.1622 2.7753 0.0055 0.1322 0.7680
kw_great 0.7804 0.0531 14.6904 0.0000 0.6763 0.8845
kw_iud -0.0974 0.2654 -0.3670 0.7137 -0.6175 0.4227
kw_trying -0.2495 0.1566 -1.5934 0.1111 -0.5564 0.0574
kw_treatment 0.0598 0.1532 0.3906 0.6961 -0.2404 0.3601
kw_thinking 0.1557 0.2200 0.7078 0.4790 -0.2755 0.5870
kw_inform 0.0903 0.3299 0.2737 0.7843 -0.5563 0.7369
kw_told -0.4156 0.1159 -3.5871 0.0003 -0.6427 -0.1885
kw_opinion -0.2360 0.1330 -1.7741 0.0761 -0.4966 0.0247
kw_speak -0.2990 0.1370 -2.1821 0.0291 -0.5675 -0.0304
kw_list 0.3882 0.1641 2.3659 0.0180 0.0666 0.7098
kw_nurse -0.0532 0.0622 -0.8547 0.3927 -0.1750 0.0687
kw_demeanor -0.1543 0.2574 -0.5996 0.5488 -0.6588 0.3501
kw_couple -0.0442 0.1415 -0.3122 0.7549 -0.3215 0.2331
kw_appts 0.1785 0.2276 0.7843 0.4329 -0.2676 0.6246
kw_getting -0.1988 0.1076 -1.8478 0.0646 -0.4096 0.0121
kw_changing -0.3373 0.2026 -1.6644 0.0960 -0.7345 0.0599
kw_sister 0.5439 0.1854 2.9335 0.0034 0.1805 0.9073
kw_listens 1.4303 0.1781 8.0288 0.0000 1.0811 1.7795
kw_staff helpful 0.1820 0.2120 0.8585 0.3906 -0.2335 0.5975
kw_happier 0.5725 0.2645 2.1646 0.0304 0.0541 1.0909
kw_unfortunately 0.2547 0.1380 1.8459 0.0649 -0.0157 0.5250
kw_work -0.0421 0.0737 -0.5711 0.5679 -0.1864 0.1023
kw_started -0.2297 0.1973 -1.1640 0.2444 -0.6164 0.1570
kw_really 0.1573 0.1307 1.2039 0.2286 -0.0988 0.4134
kw_back 0.0643 0.0813 0.7914 0.4287 -0.0950 0.2236
kw_sure -0.0106 0.0818 -0.1291 0.8972 -0.1709 0.1497
kw_mention -0.5208 0.2185 -2.3831 0.0172 -0.9492 -0.0925
kw_many year -0.1621 0.1890 -0.8575 0.3911 -0.5326 0.2084
kw_deliver baby -0.0461 0.1555 -0.2964 0.7669 -0.3509 0.2588
kw_mine -0.0495 0.1405 -0.3524 0.7245 -0.3248 0.2258
kw_intelligent 1.2179 0.2510 4.8523 0.0000 0.7259 1.7098
kw_never go -0.3945 0.1931 -2.0433 0.0410 -0.7728 -0.0161
kw_worried -0.2330 0.2175 -1.0714 0.2840 -0.6593 0.1933
kw_age -0.0956 0.0778 -1.2287 0.2192 -0.2480 0.0569
kw_find new -0.1778 0.2751 -0.6464 0.5180 -0.7169 0.3613
kw_lucky 1.4887 0.2689 5.5366 0.0000 0.9617 2.0158
kw_one best doctor 0.3763 1.2348 0.3047 0.7606 -2.0439 2.7965
kw_look -0.3131 0.1328 -2.3569 0.0184 -0.5734 -0.0527
kw_lady 0.1631 0.1309 1.2462 0.2127 -0.0934 0.4196
kw_regarding 0.3341 0.2415 1.3832 0.1666 -0.1393 0.8074
kw_cut -0.1503 0.1567 -0.9592 0.3374 -0.4573 0.1568
kw_made feel comfortable 0.8877 0.2759 3.2175 0.0013 0.3469 1.4285
kw_quality 0.0863 0.1790 0.4822 0.6296 -0.2645 0.4371
kw_away 0.0102 0.1381 0.0740 0.9410 -0.2604 0.2809
kw_heartbeat -0.2582 0.2632 -0.9811 0.3265 -0.7740 0.2576
kw_action -0.3025 0.1616 -1.8722 0.0612 -0.6193 0.0142
kw_explanation -0.5357 0.2383 -2.2476 0.0246 -1.0027 -0.0686
kw_go beyond 1.5744 0.5593 2.8152 0.0049 0.4783 2.6706
kw_think -0.1470 0.0700 -2.1009 0.0356 -0.2841 -0.0099
kw_anywhere else 1.3836 0.6684 2.0699 0.0385 0.0735 2.6937
kw_save 0.1748 0.2163 0.8081 0.4190 -0.2491 0.5987
kw_past 0.1472 0.1321 1.1144 0.2651 -0.1117 0.4060
kw_absolutely wonderful 0.1426 0.4155 0.3432 0.7314 -0.6717 0.9569
kw_feel comfortable -0.5302 0.1957 -2.7093 0.0067 -0.9138 -0.1467
kw_try 0.0908 0.1037 0.8760 0.3810 -0.1124 0.2940
kw_billing 0.5863 0.2361 2.4830 0.0130 0.1235 1.0492
kw_week pregnant -0.0031 0.2221 -0.0138 0.9890 -0.4384 0.4323
kw_failed -0.5762 0.2254 -2.5562 0.0106 -1.0179 -0.1344
kw_condition -0.2551 0.1275 -2.0008 0.0454 -0.5051 -0.0052
kw_physician 0.1326 0.0928 1.4293 0.1529 -0.0492 0.3145
kw_helping 0.1571 0.2167 0.7247 0.4686 -0.2677 0.5819
kw_trusted -0.3242 0.2437 -1.3302 0.1834 -0.8020 0.1535
kw_let know -0.1525 0.2167 -0.7040 0.4814 -0.5772 0.2721
kw_continue see 0.0864 0.3069 0.2816 0.7783 -0.5150 0.6878
kw_helped 1.1109 0.1376 8.0711 0.0000 0.8411 1.3806
kw_sensitive 0.4257 0.2011 2.1167 0.0343 0.0315 0.8199
kw_whether -0.1011 0.2613 -0.3870 0.6988 -0.6133 0.4110
kw_expected 0.2979 0.2134 1.3958 0.1628 -0.1204 0.7162
kw_recommendation 0.4576 0.2170 2.1086 0.0350 0.0323 0.8830
kw_recommended 0.4852 0.1647 2.9464 0.0032 0.1624 0.8079
kw_live 0.5590 0.1635 3.4202 0.0006 0.2387 0.8794
kw_delivered kid 1.0326 0.4161 2.4818 0.0131 0.2171 1.8481
kw_extremely 0.3469 0.0925 3.7507 0.0002 0.1657 0.5282
kw_waiting time -0.3759 0.2536 -1.4822 0.1383 -0.8729 0.1212
kw_second pregnancy 0.2027 0.2472 0.8201 0.4122 -0.2817 0.6871
kw_stay 0.0011 0.1388 0.0077 0.9939 -0.2709 0.2730
kw_yearly -0.1783 0.2223 -0.8021 0.4225 -0.6141 0.2574
kw_knowledgeable caring 0.1309 0.4219 0.3102 0.7564 -0.6961 0.9578
kw_take time explain -0.5320 0.3717 -1.4314 0.1523 -1.2606 0.1965
kw_willing 0.0495 0.1160 0.4262 0.6700 -0.1780 0.2769
kw_great bedside manner -0.7938 0.8328 -0.9531 0.3405 -2.4261 0.8385
kw_take care 0.7447 0.2175 3.4236 0.0006 0.3184 1.1710
kw_great staff 0.4404 0.2328 1.8916 0.0585 -0.0159 0.8967
kw_next 0.3084 0.0971 3.1771 0.0015 0.1181 0.4986
kw_received 0.0207 0.2655 0.0780 0.9378 -0.4996 0.5411
kw_friend family 0.5998 0.3190 1.8800 0.0601 -0.0255 1.2251
kw_wait long 0.2285 0.1812 1.2608 0.2074 -0.1267 0.5838
kw_cold -0.5806 0.1580 -3.6756 0.0002 -0.8902 -0.2710
kw_two child 0.2767 0.3353 0.8255 0.4091 -0.3803 0.9338
kw_almost -0.1071 0.1069 -1.0022 0.3163 -0.3167 0.1024
kw_never made 0.7895 0.2975 2.6542 0.0079 0.2065 1.3726
kw_straight 0.2982 0.1748 1.7060 0.0880 -0.0444 0.6407
kw_occasion 0.0214 0.1991 0.1073 0.9145 -0.3689 0.4116
kw_would like -0.1184 0.2063 -0.5741 0.5659 -0.5228 0.2859
kw_water -0.0733 0.2406 -0.3046 0.7607 -0.5448 0.3983
kw_take time 1.0647 0.1493 7.1302 0.0000 0.7720 1.3573
kw_highly recommend 1.0064 0.2322 4.3347 0.0000 0.5514 1.4615
kw_annoyed -0.3565 0.3022 -1.1795 0.2382 -0.9488 0.2358
kw_reccomend -0.0293 0.2381 -0.1231 0.9020 -0.4959 0.4373
kw_possible 0.0112 0.1238 0.0901 0.9282 -0.2315 0.2539
kw_running 0.0477 0.2025 0.2354 0.8139 -0.3492 0.4445
kw_first appointment 0.2601 0.2216 1.1737 0.2405 -0.1742 0.6945
kw_came back -0.4402 0.2306 -1.9084 0.0563 -0.8922 0.0119
kw_way -0.1015 0.0733 -1.3839 0.1664 -0.2452 0.0422
kw_excellent care -0.1125 0.3629 -0.3098 0.7567 -0.8238 0.5989
kw_listening 0.0858 0.2073 0.4140 0.6789 -0.3205 0.4922
kw_clinic 0.0511 0.1365 0.3741 0.7083 -0.2165 0.3187
kw_delivered 0.5152 0.1231 4.1864 0.0000 0.2740 0.7563
kw_answer -0.0076 0.1005 -0.0755 0.9398 -0.2045 0.1893
kw_second opinion -0.8930 0.2509 -3.5596 0.0004 -1.3847 -0.4013
kw_moving 0.1424 0.2089 0.6817 0.4954 -0.2671 0.5519
kw_incredible 1.0207 0.3423 2.9823 0.0029 0.3499 1.6916
kw_listens concern 0.3523 0.4408 0.7991 0.4242 -0.5117 1.2163
kw_news 0.0902 0.2746 0.3284 0.7426 -0.4480 0.6283
kw_wife -0.0355 0.1267 -0.2801 0.7794 -0.2839 0.2129
kw_first child 0.0529 0.1727 0.3061 0.7595 -0.2857 0.3914
kw_every time -0.6216 0.1707 -3.6421 0.0003 -0.9561 -0.2871
kw_going year 0.5620 0.2807 2.0023 0.0452 0.0119 1.1121
kw_late -0.0027 0.0846 -0.0321 0.9744 -0.1686 0.1632
kw_surgical 0.1673 0.2133 0.7845 0.4328 -0.2507 0.5853
kw_talk 0.0291 0.0908 0.3206 0.7485 -0.1489 0.2071
kw_made 0.0239 0.0745 0.3206 0.7485 -0.1221 0.1699
kw_felt rushed -0.8345 0.3212 -2.5982 0.0094 -1.4640 -0.2050
kw_understand 0.4073 0.0993 4.1006 0.0000 0.2126 0.6020
kw_explained 0.8045 0.1827 4.4032 0.0000 0.4464 1.1626
kw_phone 0.1058 0.1094 0.9671 0.3335 -0.1086 0.3203
kw_rest 0.1605 0.1436 1.1173 0.2639 -0.1210 0.4420
kw_complete 0.1392 0.1796 0.7753 0.4382 -0.2128 0.4913
kw_extremely knowledgeable 1.6645 0.4831 3.4453 0.0006 0.7176 2.6114
kw_staff 0.1198 0.0510 2.3479 0.0189 0.0198 0.2199
kw_come back -0.3701 0.2084 -1.7762 0.0757 -0.7786 0.0383
kw_feel uncomfortable -0.1862 0.3022 -0.6162 0.5378 -0.7786 0.4062
kw_choice -0.0445 0.1515 -0.2934 0.7692 -0.3415 0.2526
kw_prenatal care 0.3175 0.3292 0.9645 0.3348 -0.3277 0.9628
kw_contact 0.0529 0.1835 0.2881 0.7733 -0.3068 0.4125
kw_remove 0.2194 0.3114 0.7046 0.4810 -0.3909 0.8297
kw_time answer 0.1200 0.3971 0.3021 0.7626 -0.6583 0.8982
kw_definitely recommend 1.1579 0.3834 3.0203 0.0025 0.4065 1.9092
kw_immediately 0.6263 0.1549 4.0444 0.0001 0.3228 0.9298
kw_first pregnancy -0.2956 0.1442 -2.0496 0.0404 -0.5783 -0.0129
kw_one best -0.1981 0.2330 -0.8505 0.3951 -0.6547 0.2585
kw_second child -0.0253 0.2219 -0.1138 0.9094 -0.4601 0.4096
kw_exam -0.2526 0.0850 -2.9722 0.0030 -0.4192 -0.0860
kw_eye -0.4015 0.1764 -2.2758 0.0229 -0.7474 -0.0557
kw_induction -0.2405 0.2511 -0.9575 0.3383 -0.7327 0.2518
kw_johnson 0.1976 0.3429 0.5762 0.5645 -0.4745 0.8696
kw_many patient -0.6832 0.2253 -3.0322 0.0024 -1.1247 -0.2416
kw_even though 0.1337 0.1529 0.8746 0.3818 -0.1659 0.4333
kw_conceive 0.5877 0.2549 2.3057 0.0211 0.0881 1.0873
kw_treat -0.0044 0.1301 -0.0341 0.9728 -0.2594 0.2505
kw_children 0.4301 0.8891 0.4838 0.6286 -1.3125 2.1727
kw_courteous -0.0589 0.2042 -0.2885 0.7730 -0.4590 0.3412
kw_everytime -0.5792 0.2634 -2.1985 0.0279 -1.0955 -0.0628
kw_clearly 0.1198 0.2863 0.4185 0.6756 -0.4413 0.6809
kw_staff member -0.1090 0.4708 -0.2315 0.8170 -1.0317 0.8138
kw_impressed 0.1578 0.1581 0.9981 0.3183 -0.1520 0.4676
kw_world 0.4427 0.1794 2.4678 0.0136 0.0911 0.7943
kw_home 0.2215 0.1128 1.9643 0.0495 0.0005 0.4425
kw_effect -0.6194 0.2161 -2.8666 0.0041 -1.0429 -0.1959
kw_good care 0.5734 0.2679 2.1406 0.0323 0.0484 1.0983
kw_treat like 0.0953 0.2590 0.3677 0.7131 -0.4125 0.6030
kw_support 0.0806 0.1706 0.4724 0.6367 -0.2538 0.4150
kw_terrific 1.9849 0.3801 5.2218 0.0000 1.2399 2.7299
kw_quick -0.2108 0.1167 -1.8069 0.0708 -0.4394 0.0178
kw_year never 0.6197 0.2704 2.2915 0.0219 0.0897 1.1497
kw_care -0.0536 0.0550 -0.9749 0.3296 -0.1614 0.0542
kw_day -0.0429 0.0632 -0.6789 0.4972 -0.1667 0.0809
kw_stopped -0.0897 0.2556 -0.3508 0.7257 -0.5906 0.4113
kw_staff office 0.0063 0.2754 0.0227 0.9819 -0.5335 0.5461
kw_much 0.0413 0.0725 0.5697 0.5689 -0.1009 0.1835
kw_continued -0.6985 0.2709 -2.5783 0.0099 -1.2295 -0.1675
kw_prepared 0.6975 0.2171 3.2120 0.0013 0.2719 1.1230
kw_returning -0.6122 0.2735 -2.2387 0.0252 -1.1482 -0.0762
kw_listened concern 0.0383 0.3470 0.1104 0.9121 -0.6417 0.7183
kw_time need 0.9283 0.2888 3.2143 0.0013 0.3622 1.4943
kw_regret -0.5209 0.2390 -2.1796 0.0293 -0.9894 -0.0525
kw_min -0.1087 0.0747 -1.4543 0.1459 -0.2551 0.0378
kw_practitioner 0.0070 0.3489 0.0200 0.9840 -0.6769 0.6909
kw_might 0.0742 0.1282 0.5787 0.5628 -0.1770 0.3253
kw_info -0.2601 0.2113 -1.2310 0.2183 -0.6743 0.1540
kw_taken 0.1078 0.1556 0.6926 0.4886 -0.1972 0.4128
kw_past year -0.3078 0.2815 -1.0934 0.2742 -0.8596 0.2440
kw_take time answer question -0.0357 0.7418 -0.0482 0.9616 -1.4896 1.4182
kw_go see 0.2029 0.2001 1.0143 0.3105 -0.1892 0.5951
kw_stupid 0.0942 0.2075 0.4539 0.6499 -0.3125 0.5008
kw_blood work 0.1863 0.2931 0.6356 0.5251 -0.3881 0.7606
kw_self -0.4214 0.2154 -1.9566 0.0504 -0.8435 0.0007
kw_afraid 0.6450 0.2661 2.4236 0.0154 0.1234 1.1666
kw_kind 0.2099 0.0732 2.8679 0.0041 0.0664 0.3533
kw_week -0.2248 0.0760 -2.9572 0.0031 -0.3737 -0.0758
kw_best gyn 0.0789 0.4110 0.1920 0.8478 -0.7266 0.8844
kw_member 0.3872 0.4121 0.9395 0.3475 -0.4205 1.1948
kw_listen patient -0.8225 0.3158 -2.6045 0.0092 -1.4415 -0.2035
kw_staff also 0.1069 0.2448 0.4369 0.6622 -0.3728 0.5867
kw_charge -0.4504 0.1867 -2.4122 0.0159 -0.8164 -0.0844
kw_average -0.3543 0.2611 -1.3569 0.1748 -0.8661 0.1575
kw_something -0.0955 0.1456 -0.6560 0.5118 -0.3809 0.1899
kw_kind helpful -0.1551 0.3373 -0.4599 0.6456 -0.8163 0.5060
kw_push -0.6377 0.1646 -3.8740 0.0001 -0.9604 -0.3151
kw_delivered first child 0.4574 0.4074 1.1227 0.2616 -0.3411 1.2559
kw_several time -0.3456 0.2163 -1.5977 0.1101 -0.7696 0.0784
kw_disappointed -0.5582 0.1741 -3.2062 0.0013 -0.8994 -0.2170
kw_would never recommend -0.0476 0.8063 -0.0590 0.9530 -1.6278 1.5327
kw_cost -0.2480 0.1853 -1.3384 0.1808 -0.6111 0.1152
kw_healthy baby 0.1216 0.2721 0.4471 0.6548 -0.4116 0.6549
kw_exceptional 1.2238 0.3375 3.6263 0.0003 0.5624 1.8853
kw_year delivered 0.1507 0.2855 0.5278 0.5976 -0.4089 0.7103
kw_process 0.0347 0.1697 0.2046 0.8379 -0.2979 0.3674
kw_healthy -0.0842 0.1660 -0.5071 0.6121 -0.4096 0.2412
kw_made feel 0.0064 0.1691 0.0376 0.9700 -0.3251 0.3378
sentiment_polarity 2.4267 0.0884 27.4425 0.0000 2.2533 2.6000
===============================================================================================================================
0.9205735294117647
[[21325 3040]
[ 2361 41274]]
Store the best model
In [13]:
# store the model
for keyword in keywordlist:
ratings_training_85['kw_'+keyword] = ratings_training_85['review'].apply(lambda x: int(keyword in x))
ratings_training_85.head()
keywordsvarlist = ['kw_'+x for x in keywordlist]
# add keywords variable into the predictor variables
xcols = ['AK', 'AL', 'AR', 'AZ', 'CA',
'CO', 'CT', 'DC', 'DE', 'FL', 'GA', 'HI', 'IA', 'ID', 'IL', 'IN', 'KS',
'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN', 'MO', 'MS', 'NC', 'ND', 'NE',
'NJ', 'NM', 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'PR', 'RI', 'SC', 'SD',
'TN', 'TX', 'UT', 'VA', 'WA', 'WI', 'WV', 'WY', 'year', 'hour','numReviews'] + keywordsvarlist + ['sentiment_polarity']
# response variable
ycol = 'high_knowledge'
x = ratings_training_85[xcols]
print(x.shape)
x = sm.add_constant(x)
y = ratings_training_85[ycol]
print(x.shape,y.shape)
logit_model_keywords = sm.Logit(y, x)
logit_result = logit_model_keywords.fit()
(68000, 1559)
(68000, 1560) (68000,)
Warning: Maximum number of iterations has been exceeded.
Current function value: 0.222446
Iterations: 35
/Users/jjhy129/opt/anaconda3/lib/python3.9/site-packages/statsmodels/base/model.py:604: ConvergenceWarning: Maximum Likelihood optimization failed to converge. Check mle_retvals
warnings.warn("Maximum Likelihood optimization failed to "
Validate the model using 15% training data
In [14]:
ratings_training_15['sentiment_polarity'] = ratings_training_15['review'].apply(get_sentiment_polarity)
In [15]:
for keyword in keywordlist:
ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x))
keywordsvarlist = ['kw_'+x for x in keywordlist]
xcols = ['AK', 'AL', 'AR', 'AZ', 'CA',
'CO', 'CT', 'DC', 'DE', 'FL', 'GA', 'HI', 'IA', 'ID', 'IL', 'IN', 'KS',
'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN', 'MO', 'MS', 'NC', 'ND', 'NE',
'NJ', 'NM', 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'PR', 'RI', 'SC', 'SD',
'TN', 'TX', 'UT', 'VA', 'WA', 'WI', 'WV', 'WY', 'year', 'hour','numReviews'] + keywordsvarlist + ['sentiment_polarity']
x_training_15 = ratings_training_15[xcols]
# add constant
x_training_15 = sm.add_constant(x_training_15)
predicted_probabilities = logit_result.predict(x_training_15)
high_knowledge_predictions = (predicted_probabilities >= 0.5).astype(int)
ratings_training_15['high_knowledge_predicted'] = high_knowledge_predictions
accuracy = sum(ratings_training_15['high_knowledge_predicted'] == ratings_training_15['high_knowledge'])/ len(ratings_training_15)
/var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/1914452954.py:2: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_training_15['kw_' + keyword] = ratings_training_15['review'].apply(lambda x: int(keyword in x))
In [16]:
# check confusion matrix
confusion = metrics.confusion_matrix(y_true = ratings_training_15['high_knowledge'],y_pred = ratings_training_15['high_knowledge_predicted'])
print(confusion)
sn.heatmap(confusion, annot = True, cmap = 'Reds', fmt = 'd')
plt.xlabel("high_knowledge_predicted")
plt.ylabel("highKnowledge")
print('accuracy:'+ str(accuracy))
[[3643 609] [ 495 7253]] accuracy:0.908
Test the model using 20000 data
In [17]:
ratings_test['sentiment_polarity'] = ratings_test['review'].apply(get_sentiment_polarity)
In [18]:
# transform the test data
temp = pd.get_dummies(ratings_test['state'])
ratings_test = pd.concat([ratings_test, temp], axis=1)
ratings_test['postedTime'] = pd.to_datetime(ratings_test['postedTime'])
ratings_test['year'] = ratings_test['postedTime'].dt.year
ratings_test['hour'] = ratings_test['postedTime'].dt.hour
for keyword in keywordlist:
ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x))
keywordsvarlist = ['kw_'+x for x in keywordlist]
xcols = ['AK', 'AL', 'AR', 'AZ', 'CA',
'CO', 'CT', 'DC', 'DE', 'FL', 'GA', 'HI', 'IA', 'ID', 'IL', 'IN', 'KS',
'KY', 'LA', 'MA', 'MD', 'ME', 'MI', 'MN', 'MO', 'MS', 'NC', 'ND', 'NE',
'NJ', 'NM', 'NV', 'NY', 'OH', 'OK', 'OR', 'PA', 'PR', 'RI', 'SC', 'SD',
'TN', 'TX', 'UT', 'VA', 'WA', 'WI', 'WV', 'WY', 'year', 'hour','numReviews'] + keywordsvarlist + ['sentiment_polarity']
/var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x)) /var/folders/q4/d6cjd_r56hd476m9zf60fqtr0000gn/T/ipykernel_38663/76433455.py:12: PerformanceWarning: DataFrame is highly fragmented. This is usually the result of calling `frame.insert` many times, which has poor performance. Consider joining all columns at once using pd.concat(axis=1) instead. To get a de-fragmented frame, use `newframe = frame.copy()` ratings_test['kw_' + keyword] = ratings_test['review'].apply(lambda x: int(keyword in x))
In [19]:
x_test = ratings_test[xcols]
# add constant
x_test = sm.add_constant(x_test)
predicted_probabilities = logit_result.predict(x_test)
high_knowledge_predictions = (predicted_probabilities >= 0.5).astype(int)
ratings_test['high_knowledge_predicted'] = high_knowledge_predictions
In [20]:
ratings_test.describe()
Out[20]:
| reviewID | doctorID | numReviews | review_helpful_count | sentiment_polarity | AK | AL | AR | AZ | CA | … | kw_never made | kw_pt | kw_friendly knowledgeable | kw_law | kw_get back | kw_conceive | kw_lose | kw_making feel | kw_always made feel | high_knowledge_predicted | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| count | 20000.000000 | 2.000000e+04 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.00000 | … | 20000.000000 | 20000.000000 | 20000.000000 | 20000.00000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 | 20000.000000 |
| mean | 90000.500000 | 5.731178e+05 | 14.299100 | 0.180450 | 0.237151 | 0.002000 | 0.018900 | 0.008700 | 0.024150 | 0.09035 | … | 0.003250 | 0.155250 | 0.002500 | 0.00730 | 0.003800 | 0.004500 | 0.020900 | 0.004450 | 0.004000 | 0.651700 |
| std | 5773.647028 | 9.757751e+05 | 12.712632 | 0.921537 | 0.311246 | 0.044678 | 0.136175 | 0.092869 | 0.153519 | 0.28669 | … | 0.056917 | 0.362152 | 0.049939 | 0.08513 | 0.061528 | 0.066933 | 0.143053 | 0.066561 | 0.063121 | 0.476444 |
| min | 80001.000000 | 6.800000e+01 | 1.000000 | 0.000000 | -1.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.00000 | … | 0.000000 | 0.000000 | 0.000000 | 0.00000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 25% | 85000.750000 | 3.908900e+04 | 6.000000 | 0.000000 | 0.033333 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.00000 | … | 0.000000 | 0.000000 | 0.000000 | 0.00000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 |
| 50% | 90000.500000 | 1.392095e+05 | 11.000000 | 0.000000 | 0.245869 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.00000 | … | 0.000000 | 0.000000 | 0.000000 | 0.00000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 1.000000 |
| 75% | 95000.250000 | 4.743942e+05 | 20.000000 | 0.000000 | 0.433333 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.00000 | … | 0.000000 | 0.000000 | 0.000000 | 0.00000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 0.000000 | 1.000000 |
| max | 100000.000000 | 4.029545e+06 | 172.000000 | 43.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.00000 | … | 1.000000 | 1.000000 | 1.000000 | 1.00000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 | 1.000000 |
8 rows × 1565 columns
In [21]:
ratings_test.head(30)
Out[21]:
| reviewID | doctorID | doctorName | specialty | numReviews | city | state | postedTime | review | review_helpful_count | … | kw_never made | kw_pt | kw_friendly knowledgeable | kw_law | kw_get back | kw_conceive | kw_lose | kw_making feel | kw_always made feel | high_knowledge_predicted | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 80001 | 108058 | Dr. Jackelinne P. Villalobos | Gynecologist (OBGYN) | 11 | Cypress | TX | 2010-04-14 20:11:00 | one complaint v wait time expect wait least ho… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 |
| 1 | 80002 | 248984 | Dr. Michael Spruiell | Gynecologist (OBGYN) | 7 | Virginia Beach | VA | 2013-12-12 09:18:00 | visit year caring considerate skillful highly … | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 2 | 80003 | 92320 | Dr. Sheba Gabrail | Gynecologist (OBGYN) | 18 | Irvine | CA | 2011-02-26 22:17:00 | gabrail amazing nonsense knowledgeable sugar c… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 3 | 80004 | 31937 | Dr. Courtney A. Hunt | Gynecologist (OBGYN) | 32 | SCOTTSDALE | AZ | 2009-05-21 20:35:00 | office fantastic hunt smart earth cool knowled… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 4 | 80005 | 153081 | Dr. Jeanne Knotek | Gynecologist (OBGYN) | 7 | Garfield Heights | OH | 2008-11-19 11:16:00 | must take really good note remembers question … | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 5 | 80006 | 2673861 | Dr. Pamorn Kulsakdinun | Gynecologist (OBGYN) | 9 | Elgin | IL | 2014-10-11 15:57:00 | kulsak proffesional kind make feel comfortable… | 1 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 |
| 6 | 80007 | 3126037 | Dr. Sarah G. Obican | Gynecologist (OBGYN) | 5 | Washington | DC | 2012-04-15 19:21:00 | loved obican nice helpful made feel comfortabl… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 7 | 80008 | 329691 | Dr. Thomas J. Helm | Gynecologist (OBGYN) | 1 | Wallingford | CT | 2010-03-22 08:26:00 | found thing brother charles care look thorough… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 8 | 80009 | 144418 | Dr. Rosemary Fadool | Gynecologist (OBGYN) | 18 | Surprise | AZ | 2013-08-19 13:25:00 | absolutely best thorough care could hoped beca… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 9 | 80010 | 291878 | Dr. Benjamin R. Dispenziere | Gynecologist (OBGYN) | 6 | Oakland | NJ | 2010-10-05 14:08:00 | dispenziere ob gyn year delivered child fabulo… | 1 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 10 | 80011 | 91919 | Dr. Joseph Montanaro | Gynecologist (OBGYN) | 10 | OLIVIA | MN | 2007-04-01 19:20:00 | want wonderful experience concerned helpful wa… | 2 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 11 | 80012 | 90497 | Dr. Elihu M. Kraemer | Gynecologist (OBGYN) | 8 | Coral Springs | FL | 2009-08-31 19:30:00 | kraemer obgyn ten year always positive experie… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 12 | 80013 | 33939 | Dr. Tauhni T. Hunt | Gynecologist (OBGYN) | 8 | Sioux City | IA | 2012-02-27 10:59:00 | hunt far best ever seen fair share drs husband… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 13 | 80014 | 2366521 | Dr. Marianne Wizda | Gynecologist (OBGYN) | 6 | McMurray | PA | 2015-08-26 17:29:00 | much seeing stupid diagnosis treatment much ha… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 14 | 80015 | 104019 | Dr. Elaine M. Biester | Gynecologist (OBGYN) | 4 | Forest Park | IL | 2008-06-02 19:11:00 | first visit last month physician nervous reall… | 0 | … | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 15 | 80016 | 43802 | Dr. Matthew S. Casavant | Gynecologist (OBGYN) | 14 | Clermont | FL | 2008-03-19 09:02:00 | love casavant wife competent sincere physician… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 16 | 80017 | 1075 | Dr. Thomas W. Scott | Gynecologist (OBGYN) | 4 | Woodstock | GA | 2010-06-02 16:10:00 | scott best gynecologist ever seen extremely pe… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 17 | 80018 | 103422 | Dr. Ravi K. Trivedi | Gynecologist (OBGYN) | 16 | Hoffman Estates | IL | 2008-03-13 20:20:00 | helpful friendly easy get appointment flexible… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 18 | 80019 | 5687 | Dr. Paul D. Neblett | Gynecologist (OBGYN) | 19 | Memphis | TN | 2012-01-26 13:41:00 | neblett truly added huge amount perspective li… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 19 | 80020 | 886625 | Dr. Diane E. BROWN-YOUNG | Gynecologist (OBGYN) | 4 | CLEVELAND | OH | 2009-03-09 01:48:00 | examined several time severe bleeding said men… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 20 | 80021 | 354979 | Dr. Stephen R. Wells | Gynecologist (OBGYN) | 8 | Walnut Creek | CA | 2011-02-02 13:47:00 | tried discredit doctor unprofessional | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 21 | 80022 | 67666 | Dr. Mearl A. Naponic | Gynecologist (OBGYN) | 14 | La Mesa | CA | 2010-03-09 16:15:00 | naponic phenomenal delivered boy may punctual … | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 22 | 80023 | 15384 | Dr. Vijay Arora | Gynecologist (OBGYN) | 38 | Apple Valley | CA | 2015-07-14 18:03:00 | recommend arora others stated wait time alone … | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 23 | 80024 | 952735 | Dr. Wade A. Neiman | Gynecologist (OBGYN) | 1 | Lynchburg | VA | 2011-07-12 10:38:00 | neinman great however staff another story nurs… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 24 | 80025 | 3087935 | Dr. Walter K. Lippard | Gynecologist (OBGYN) | 2 | Phoenix | AZ | 2011-09-20 21:33:00 | love lippard best bed side mannerand trully ca… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 25 | 80026 | 327181 | Dr. Paul A. Pyka | Gynecologist (OBGYN) | 10 | La Mesa | CA | 2012-03-14 16:01:00 | pyka worst ever papsmear first papsmear check … | 0 | … | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 26 | 80027 | 106045 | Dr. Bruce A. Lessey | Gynecologist (OBGYN) | 7 | GREENVILLE | SC | 2011-09-03 15:11:00 | lessey absolutely wonderful trying concieve ba… | 1 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 27 | 80028 | 19596 | Dr. Richard L. Alexander | Gynecologist (OBGYN) | 16 | Monterey | CA | 2013-09-24 15:48:00 | month pregnant currently seeing alexanader tru… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 28 | 80029 | 398622 | Dr. Renee J. Wellenstein | Gynecologist (OBGYN) | 1 | WILTON | CT | 2008-12-11 14:05:00 | lovely person knowledgeable gentle friend like… | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| 29 | 80030 | 424788 | Dr. Anthony R. Piccolo | Gynecologist (OBGYN) | 5 | York | PA | 2011-10-22 20:17:00 | poor bedside mannor suffered miscarriage told … | 0 | … | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
30 rows × 1571 columns
Export Result
In [38]:
result = ratings_test[['reviewID', 'high_knowledge_predicted']]
result = result.rename(columns = {'high_knowledge_predicted': 'prediction'})
In [39]:
result.to_csv('/Users/jjhy129/Desktop/study/Current Course/Text Analytics/Assignment 1/32400199_boba129.csv', index=False)
In [ ]: