<jupyter_start><jupyter_text>Curate the dataset from Reddit comments and train the model to match anti-depressants with symptomsIn this notebook, I demonstrate how I trained the model to give recommendation given the symptoms. The idea here is to train a model in such a way that it maps an anti-depressant to symptoms that were alleviated by it. To acheive this, I've applied sentiment analysis to the text metioning the drugs and then used the score to weight the features. These features were then used to train the model (here I explored Bag-of-words, TF-IDF and Word2Vec) to classify top 5/10 mentioned drugs.1. Load Reddit data and explore the data structure2. Extract list of drugs3. Create a corpus of drugs:comments about the drugs4. Sentiment analysis5. Train the model with CV and sentiment analysis score   1. Load Reddit data and explore the data structure<jupyter_code>import keras
import nltk
from nltk.stem import WordNetLemmatizer, SnowballStemmer
from nltk.stem.porter import *
import gensim
from gensim.utils import simple_preprocess
from gensim.parsing.preprocessing import STOPWORDS
import pandas as pd
import numpy as np
np.random.seed(2018)
import re
import json
import os 
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score, classification_report,confusion_matrix
from sklearn.svm import LinearSVC
from sklearn.calibration import CalibratedClassifierCV

import itertools
from pathlib import Path
module_path = os.path.abspath(os.path.join('..'))
if module_path not in sys.path:
    sys.path.append(module_path)
from src.data.analys import * 
from src.data.text_analys import *
from src.models.CV_TF_Word2Vec_Anal import *
from src.models.LDA_topic_model import *
from src.features.build_features import *
from src.models.LinearSVC_Anal import *
from src.models.modelanalys import *
from src.features.build_features import *

nltk.download('wordnet')
# Now let's take a look at this using pandas datafraem
tag = 'comm'
source = 'anti_dep'
with open('anti_dep_all_comm.json', 'r') as f:
    data = json.load(f)
df_subs = pd.DataFrame(data)
print(len(df_subs))
len(df_subs.columns)
# Note that is far fewer than submission data 
print (df_subs.columns)
# Let's try couple of things 
print (df_subs[[ 'author', 'body','id', 'score'] ].head)
# OK - in this case, 'body' is what we're mining for: ad hoc information ['author', 'id', 'score'] 
filter_cols = [ 'author', 'body','id', 'score']
print (df_subs.head())
df_subs = df_subs.dropna(axis=1, how= 'all')
len(df_subs)
df_subs.author_flair_type.unique()
df_subs.author_flair_text.unique()<jupyter_output><empty_output><jupyter_text>2. Extract list of drugs<jupyter_code>pills = pd.read_csv('antidepressants.txt')
pills['BrandName']= pills['Name'].str.split('\s+').str[0].str.strip()
print (pills['BrandName'])
corp = pd.DataFrame(columns=pills.BrandName.values, index=['match_number'])
print(corp.columns)
import re
# Getting rid of part without body
df_subs = df_subs[pd.notnull(df_subs['body'])]
print (len(df_subs))

# No Na anymore 
print (df_subs['body'].head().values)
print(df_subs['body'][df_subs['body'].str.contains(col,flags=re.IGNORECASE, regex=True)])
print (len(df_subs['body'][df_subs['body'].str.contains(col,flags=re.IGNORECASE, regex=True)]))

# Note that there may be users mentioning anafril twice?? 

# 14 mentions of Anafranil..<jupyter_output><empty_output><jupyter_text>3. Create a corpus of drugs:comments about the drugs and analysis of the corpusAnalyze the frequency of drug mentioned in the comments --> Assumption: comment about a certain drug should mention the name of the drug: this ignores the possibility where the drug might have been alreay mentioned from the submissions; also didn't search for their generic names - 1 there are roughly top 5 drugs that are mentioned far more frequently than the other drugs  - 2 Map antidepressants:comments - 3 pipe out top5 and top10 mentioned drugs and munged data set into pickled/comm/{drugname}.pkl<jupyter_code># Collect'selftext' 'author' 'id' of submissions that contains any of drugs 
d_drug_ment_sub = {}

cwd = Path.cwd()
external_data_fd = '../data/external'
interim_data_fd ='../data/interim'
processed_data_fd = '../data/processed'
newpath_interim = r'{0}//reddit_corpus'.format((cwd/ interim_data_fd).resolve())
newpath_processed= r'{0}//reddit_corpus'.format((cwd/ processed_data_fd).resolve())

if not os.path.exists(newpath_interim):
    os.makedirs(newpath_interim)
if not os.path.exists(newpath_processed):
    os.makedirs(newpath_processed)
    
for drug_name in corp.columns:
    print ('\n')
    print (drug_name )
    d_drug_ment_sub[drug_name] = pd.DataFrame(columns=filter_cols)
    d_drug_ment_sub[drug_name][filter_cols]=df_subs[filter_cols][df_subs['body'].str.contains(drug_name,flags=re.IGNORECASE, regex=True)]
    print (len(d_drug_ment_sub[drug_name]))
    print ( "%f percent out of all comments " %(100*len(d_drug_ment_sub[drug_name])/len(df_subs)))
    print (d_drug_ment_sub[drug_name].describe())
    name = drug_name+'_mentioned_all'+tag+source 
    d_drug_ment_sub[drug_name].to_pickle(newpath_interim+"/%s.pkl"%(name))

# Frequency of mentions of drugs 
%matplotlib inline

freq = []
labels = []
for  (k,v) in d_drug_ment_sub.items():
    freq.append(len(v))
    labels.append(k)
# Note plt.hist() won't work --> Bar is the right way 

#tick_label does the some work as plt.xticks()
plt.bar(range(len(freq)),freq,tick_label=labels)
plt.title('drug appearane frequency')
plt.xticks(rotation=90)
plt.savefig("Drug_mentioned.png")

#tick_label does the some work as plt.xticks()
print (np.array(freq).sum())
plt.figure()
plt.bar(range(len(freq)),freq/np.array(freq).sum(),tick_label=labels)
plt.title('Frequency among comments that mention any drugs')
plt.xticks(rotation=90)
plt.savefig("Frequency_drug_mentioned.png")<jupyter_output>6033<jupyter_text>Note that submissions are significantly undersampled for certain drugs  Let's take a look at the top five and top 10 mentioned drugs<jupyter_code>top_5_drug_ment_sub = sorted(d_drug_ment_sub.items(), key=lambda x: len(x[1]),reverse=True)[0:5]
top_10_drug_ment_sub = sorted(d_drug_ment_sub.items(), key=lambda x: len(x[1]),reverse=True)[0:10]
top_5_drugs=  [x for (x,df) in top_5_drug_ment_sub]
print (top_5_drugs)

for (x,df) in top_5_drug_ment_sub:
    name = 'top5/'+x+'_top5_'+tag+source 
    d_drug_ment_sub[x].to_pickle(newpath_processed+"/%s.pkl"%(name))
   
top_10_drugs=  [x for (x,df) in top_10_drug_ment_sub]
for (x,df) in top_10_drug_ment_sub:
    name = 'top10/'x+'_top10_'+tag+source 
    d_drug_ment_sub[x].to_pickle(newpath_processed+"/%s.pkl"%(name))<jupyter_output>['Wellbutrin', 'Zoloft', 'Effexor', 'Lexapro', 'Prozac']
Zyban
<class 'list'>
<class 'tuple'>
['Wellbutrin', 'Zoloft', 'Effexor', 'Lexapro', 'Prozac', 'Paxil', 'Cymbalta', 'Celexa', 'Remeron', 'Seroquel']
<class 'list'>
<class 'tuple'><jupyter_text>4. Sentiment analysis1. Sentiment analysis: this is really a garbage here...   -1.1 score accordingly to negative/neutral/positive        -1.1.1 However, for most of the drugs, sentiment score is overwhelmingly neural --> This needs to be improved; instead of sentiment analysis on the wholebody - try average by sentence?       -1.1.2 Also, way too many garbage words here.. this may also have to be extracted 2. Create dataframe of Top5 mentioned drugs/ top10 mentioned drugs: author, body, id, score (doesn't have any meaning here), selftext_by_sent, selftexgt_bywords, self_textbody, rating_score (from sentiment analysis on the whole body of the text) Only take the commments metioning one drug in the comment and do the overall sentiment calculationpitfall is, though, overall document score may not even that good - We may have to just look at one sentence before and afterTo build some kinda of recommendation system, I need to have a score for each of the users Okay, let's do this thenGet the dominant sentiment of the given userconvert them to the score from 1-5: negative 1, neutral 2, positive 3 How do you extract the overall sentiment? Extract the data, mentioning only one drug - - > then do the overall sentiment analysis<jupyter_code>message_text = "Personally it took me about 2 months to really notice a difference.', 'Like most people I’ve talked to though, I take it in combination with another antidepressant.', 'I’ve never taken it without something like Lexapro, Cymbalta (which does the exact same thing as Wellbutrin but is not stimulating) or Prozac.', 'In short, wait 4-6 and if you still can’t tell a difference see your doc."

sent, score= sentiment_analysis(message_text) # r is ordered dictionary 
numeric_score= sent_to_score(sent)
print (sent, score)

 # Testing the tokenization scheme on A
# TESTING THIS PART 
# LOOK AT ME! 
name, df = top_5_drug_ment_sub[0]

df['selftext_bysent']= [[]] * len(df)
df['selftext_byWords']= [[]] * len(df)
total_txt_data= []
total_txt_word = []
print (df.head())
for i in df['body'].index[:2]:

    parsed = tokenizer.tokenize(df.at[i,'body'])
    df.at[i, 'selftext_bysent'] = parsed
    print (parsed)
    print (df.at[i, 'selftext_bysent'])
        
#   Parse into words - create list of lists 
    words= list(sent_to_words(df.at[i,'selftext_bysent']))
    words_flatten = [item for sublist in words for item in sublist]     
    df.at[i,'selftext_byWords'] = words_flatten
    total_txt_data.extend(tokenizer.tokenize(df.loc[i]['body'])[:])<jupyter_output>author                                               body       id  \
3   Taylor8675309  I've tried celexa, lexapro, brintellix, and we...  e63suvg   
22   madmax051820  Personally it took me about 2 months to really...  e62vaug   
24      mmlnola66  Wellbutrin 300XL and 40mg Prozac have been the...  e62b515   
32     nanotech23   I don't think it plays well with alcohol, but...  e61mu8b   
35      shinesy57  I was on wellbutrin on and off for 8 years (mo...  e61j8k3   

    score selftext_bysent selftext_byWords  
3       1              []               []  
22      1              []               []  
24      1              []               []  
32      1              []               []  
35      1              []               []  
["I've tried celexa, lexapro, brintellix, and wellbutrin.", 'Everything except wellbutrin has made me gain weight']
["I've tried celexa, lexapro, brintellix, and wellbutrin.", 'Everything except wellbutrin has made me gain weight']
['Personall[...]<jupyter_text>EDA on patients' experience corpora:- See the most prevalent/rare wordss- Distribution of sentence - Distribution of sentiment scoreNote that I've refactored the analysis into a function(sentanal) to save figures and summary of the analysis.<jupyter_code>top5_drug_txt_parse,top_5_drug_ment_sub = sentanal(top_5_drug_ment_sub,newpath_1)
top10_drug_txt_parse,top_10_drug_ment_sub=  sentanal(top_10_drug_ment_sub,newpath_2)

 The analysis in the functions are following:
for drug_name, df in top_5_drug_ment_sub:
    print ('\n')
    print (drug_name)
    df['label'] = drug_name
    # Create new column of selt text parsed into sentences 
    df['selftext_bysent']= [[]] * len(df)
    df['selftext_byWords']= [[]] * len(df)
    df['sentiment_body']= [[]] * len(df)
    df['rating_body']= [[]] * len(df)
#     print (df.head())
    total_txt_data = [] # Sentence list
    total_txt_word = [] # words list
    
    for i in df['body'].index:
        
        # Parse into sentences
        parsed = tokenizer.tokenize(df.at[i,'body'])
        df.at[i,'selftext_bysent'] = parsed
        
        # Parse into words - create list of lists 
        words= list(sent_to_words(df.at[i,'selftext_bysent']))
        words_flatten = [item for sublist in words for item in sublist] 
        
        df.at[i,'selftext_byWords'] = words_flatten
        total_txt_word.extend(words_flatten )
        # total_txt has all sentences 
        total_txt_data.extend(tokenizer.tokenize(df.loc[i]['body'])[:])

        sent, score = sentiment_analysis(df.at[i,'body']) 
        df.at[i,'sentiment_body'] = sent
        df.at[i,'rating_body'] = score
    
    top5_drug_txt_parse[drug_name]=total_txt_data 
#     print ('drugname:')

    plt.figure()
    print (pd.Series(total_txt_word).describe())
    pd.Series(total_txt_word).value_counts().nlargest(20).plot.pie(autopct='%.2f', fontsize=10, figsize=(6, 6))
    plt.title(drug_name+"20 prevalent words")
    
    plt.figure()
    pd.Series(total_txt_word).value_counts().nsmallest(20).plot.pie(autopct='%.2f', fontsize=10, figsize=(6, 6))
    plt.title(drug_name+"20 rare words")
    
    plt.figure()
    pd.Series((df['sentiment_body'].values)).value_counts().plot.pie(autopct='%.2f', fontsize=10, figsize=(6, 6))
    plt.title(drug_name+"sentiment distribution")
    
    sentence_lengths = [len(tokens) for tokens in df["selftext_byWords"]]
    VOCAB = sorted(list(set(total_txt_word)))
    print("%s words total, with a vocabulary size of %s" % (len(total_txt_word), len(VOCAB)))
    print("Max sentence length is %s" % max(sentence_lengths))

    fig = plt.figure(figsize=(10, 10)) 
    plt.xlabel('Sentence length')
    plt.ylabel('Number of sentences')
    plt.hist(sentence_lengths)
    plt.title(drug_name)
    plt.show()<jupyter_output>Wellbutrin
count     109386
unique      5951
top          the
freq        3377
dtype: object
109386 words total, with a vocabulary size of 5951
Max sentence length is 522<jupyter_text>Shows that sentiment analysis cannot differentiate nuance of patient's experience and therefore need to be improved upon  Save the corpora with sentiment rating into a pickle fle<jupyter_code>top_5_all_drugs_clean = pd.DataFrame(columns = ['author', 'body', 'id', 'score', 'selftext_bysent', 'selftext_byWords',
       'label','sentiment_body','rating_body'])
d_list = [m for (n,m)in top_5_drug_ment_sub]
for (n,m) in top_5_drug_ment_sub:
    print(m.columns)
    print(len(m))
    top_5_all_drugs_clean= top_5_all_drugs_clean.append(m)
    print (top_5_all_drugs_clean)

top_10_all_drugs_clean = pd.DataFrame(columns = ['author', 'body', 'id', 'score', 'selftext_bysent', 'selftext_byWords',
       'label','sentiment_body','rating_body'])
d_list = [m for (n,m)in top_10_drug_ment_sub]
for (n,m) in top_10_drug_ment_sub:
    top_10_all_drugs_clean= top_10_all_drugs_clean.append(m)

newpath_1 = r'%s//pickled_refactor_test//%s//top5' %(cwd,tag)
if not os.path.exists(newpath_1):
    os.makedirs(newpath_1)
nm = tag+ source
pickl_list_tupl(top_5_drug_ment_sub, nm, newpath_1)

if not os.path.exists(newpath_2):
    os.makedirs(newpath_2)
nm = tag + source
print("pickl_list_tupl")
pickl_list_tupl(top_10_drug_ment_sub, nm, newpath_2)<jupyter_output><empty_output><jupyter_text>5. train the model with CV and sentiment analysis score 1.1 Training with Bag-of-words features + logistic regression<jupyter_code>list_corpus = top_5_all_drugs_clean["body"].tolist()
list_labels = top_5_all_drugs_clean["label"].tolist()

X_train, X_test, y_train, y_test = train_test_split(list_corpus, list_labels, test_size=0.2, 
                                                                                random_state=40)
cv = CountVectorizer()
X_train_counts, count_vectorizer = cv(X_train)
X_test_counts = count_vectorizer.transform(X_test)
fig = plt.figure(figsize=(16, 16))      
plot_LSA(X_train_counts, y_train)
plt.savefig("LDA_BagOfWords.png")
# Logistic regression
clf = LogisticRegression(C=30.0, class_weight='balanced', solver='newton-cg', 
                         multi_class='multinomial', n_jobs=-1, random_state=40)
clf.fit(X_train_counts, y_train)
y_predicted_counts = clf.predict(X_test_counts)
accuracy, precision, recall, f1 = get_metrics(y_test, y_predicted_counts)
print(" = %.3f, precision = %.3f, recall = %.3f, f1 = %.3f" % (accuracy, precision, recall, f1))
labels =['Lexapro','Effexor','Wellbutrin','Prozac','Zoloft']
cm = confusion_matrix(y_test, y_predicted_counts, labels)
fig = plt.figure(figsize=(10, 10))
plot = plot_confusion_matrix(cm, normalize=True, title='Confusion matrix')
plt.show()
plt.savefig("LogisticRegression_cm.png")
print(cm)<jupyter_output><empty_output><jupyter_text>1.2.1 Training with TF-IDF features + Linear SVC classifier<jupyter_code>top_5_all_drugs_clean['rating_body']= top_5_all_drugs_clean['rating_body'].astype(float)
mean_score = top_5_all_drugs_clean.groupby(['label'], as_index=False)['rating_body'].mean()
weight_dict = {k:v for (k,v) in mean_score.loc[:,['label','rating_body']].values}

count_vect = CountVectorizer()
X_train_counts = count_vect.fit_transform(X_train)
X_test_counts = count_vect.transform(X_test)
tf_transformer = TfidfTransformer().fit(X_train_counts)
X_train_transformed = tf_transformer.transform(X_train_counts)
X_test_transformed = tf_transformer.transform(X_test_counts)

labels = LabelEncoder()
y_train_labels_fit = labels.fit(y_train)
y_train_lables_trf = labels.transform(y_train)
fig = plt.figure(figsize=(16, 16))          
plot_LSA(X_train_tfidf, y_train)
plt.show()
maps=list(labels.inverse_transform(range(len(labels.classes_))))
values=range(len(labels.classes_))
decodekeys= dict(zip(maps,values))
weight_dict_encoded = {decodekeys[k]:v for (k,v) in weight_dict.items()}

linear_svc = LinearSVC(class_weight = weight_dict_encoded)
clf = linear_svc.fit(X_train_transformed,y_train_lables_trf)

calibrated_svc = CalibratedClassifierCV(base_estimator=linear_svc,
                                        cv="prefit")

calibrated_svc.fit(X_train_transformed,y_train_lables_trf)
predicted = calibrated_svc.predict(X_test_transformed)

print('Average accuracy on test set={}'.format(np.mean(predicted == labels.transform(y_test))))
print('Predicted probabilities of demo input string are')
print(calibrated_svc.predict_proba(p_tfidf))

result = pd.DataFrame(calibrated_svc.predict_proba(p_tfidf)*100, columns=labels.classes_)
new = pd.melt(result,var_name='Drug name', value_name= 'likelihood(%)').round(2)
result_sorted =new.sort_values(by=['likelihood(%)'], ascending=False ).reset_index(drop=True)
result_sorted.rename(index= {0:'1st',1:'2nd',2:'3rd',3:'4th',4:'5th'}, inplace=True)
result_sorted.index.name= "Rank"
print (result_sorted)
conf_mat = confusion_matrix(y_test, y_pred)
fig, ax = plt.subplots(figsize=(10,10))
sns.heatmap(conf_mat, annot=True, fmt='d',
            xticklabels=category_id_df.Product.values, yticklabels=category_id_df.Product.values)
plt.ylabel('Actual')
plt.xlabel('Predicted')
plt.show()<jupyter_output><empty_output><jupyter_text>1.2.2 Training with TF-IDF features + Logistic regression<jupyter_code>clf_tfidf = LogisticRegression(C=30.0, class_weight='balanced', solver='newton-cg', 
                         multi_class='multinomial', n_jobs=-1, random_state=40)
clf_tfidf.fit(X_train_tfidf, y_train)
y_predicted_tfidf = clf_tfidf.predict(X_test_tfidf)
accuracy_tfidf, precision_tfidf, recall_tfidf, f1_tfidf = get_metrics(y_test, y_predicted_tfidf)
print("accuracy = %.3f, precision = %.3f, recall = %.3f, f1 = %.3f" % (accuracy_tfidf, precision_tfidf, 
                                                                       recall_tfidf, f1_tfidf))
print(y_test[0:5])
print(y_predicted_tfidf[0:5])
cm2 = confusion_matrix(y_test, y_predicted_tfidf)
fig = plt.figure(figsize=(10, 10))
plot = plot_confusion_matrix(cm2, normalize=True, title='Confusion matrix')
plt.show()
print("TFIDF LR confusion matrix")
print(cm2)
print("TFIDF SVC confusion matrix")
print(conf_mat)
print("BoW LR confusion matrix")
print(cm)<jupyter_output><empty_output><jupyter_text>TFIDF and Bag-of-words do not show discernable performance difference. This is inline with what we see from LSA plot - they the word features for anti-depressants don't separate much from one another.<jupyter_code>importance_tfidf = get_most_important_features(tfidf_vectorizer, clf_tfidf, 10)
for i in range(len(importance_tfidf)):
    top_scores = [a[0] for a in importance_tfidf[i]['tops']]
    top_words = [a[1] for a in importance_tfidf[i]['tops']]
    bottom_scores = [a[0] for a in importance_tfidf[i]['bottom']]
    bottom_words = [a[1] for a in importance_tfidf[i]['bottom']]
    title= importance[i]['name']
    plot_important_words(top_scores, top_words, bottom_scores, bottom_words, "Most important words for relevance", title)<jupyter_output><empty_output><jupyter_text>1.3. Word2Vec feature + LR<jupyter_code>import gensim

word2vec_path = "GoogleNews-vectors-negative300.bin.gz"
word2vec = gensim.models.KeyedVectors.load_word2vec_format(word2vec_path, binary=True)
embeddings = get_word2vec_embeddings(word2vec, top_5_all_drugs_clean)
missing = get_word2vec_missings(word2vec, top_5_all_drugs_clean)
X_train_word2vec, X_test_word2vec, y_train_word2vec, y_test_word2vec = train_test_split(embeddings, list_labels, 
                                                                                        test_size=0.2, random_state=40)
print (y_train_word2vec[:5])
miss= pd.Series(missing)
miss_df= pd.DataFrame({ 'list':miss.values})
missed = miss_df.list.apply(pd.Series).stack().value_counts()

total_missed = missed.values.sum()
missed_divided = missed/total_missed
missed_divided[800:810].plot.bar()
plt.title("missing words: %d " %(len(missed)))
plt.savefig("word2vecmissingwords.png")
fig = plt.figure(figsize=(16, 16))          
plot_LSA(embeddings, list_labels)
plt.show()
clf_w2v = LogisticRegression(C=30.0, class_weight='balanced', solver='newton-cg',  multi_class='multinomial', random_state=40)
clf_w2v.fit(X_train_word2vec, y_train_word2vec)
y_predicted_word2vec = clf_w2v.predict(X_test_word2vec)
accuracy_word2vec, precision_word2vec, recall_word2vec, f1_word2vec = get_metrics(y_test_word2vec, y_predicted_word2vec)
print("accuracy = %.3f, precision = %.3f, recall = %.3f, f1 = %.3f" % (accuracy_word2vec, precision_word2vec, 
                                                                       recall_word2vec, f1_word2vec))
cm_w2v = confusion_matrix(y_test_word2vec, y_predicted_word2vec)
fig = plt.figure(figsize=(10, 10))
plot = plot_confusion_matrix(cm_w2v , normalize=True, title='Confusion matrix')
plt.show()
print("Word2Vec + LR confusion matrix")
print(cm_w2v)
print("TFIDF + LR confusion matrix")
print(cm2)
print("BoW +LR confusion matrix")
print(cm)
# As demonstrated here, W2V + LR performed the best was chosen to be displayed in the web app<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11682326621923937, 'fraction_numerical': 0.018926174496644296, 'mean_word_length': 4.858715596330275, 'pattern_counts': {'":': 0, '<': 49, '<?xml version=': 0, '>': 53, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 22, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '33893', 'license': 'MIT', 'n_tokens_mistral': 8061, 'n_tokens_neox': 7658, 'n_words': 1833, 'path': 'notebooks/RedditComments_EDA_Train_classifier.ipynb', 'repo_name': 'sunnnymskang/ChillPillV1', 'size': '22350'}