import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

df = pd.read_csv("../recipes.csv")
df.head()

df.head()

df.head()

def make_label(cuisine):
    if cuisine == "italian":
        return 1
    else:
        return 0

df['label'] = df['cuisine'].apply(make_label)
df.head(10)

df['has_spaghetti'] = df['ingredient_list'].str.contains("spaghetti")
df['has_curry_powder'] = df['ingredient_list'].str.contains("curry powder")
df.head(10)

df['label'].head()

df[['has_spaghetti', 'has_curry_powder']].head()

# We need to split into training and testing data
from sklearn.cross_validation import train_test_split

# Splitting into...
# X = are all our features
# y = are all our labels
# X_train are our features to train on (80%)
# y_train are our labels to train on (80%)
# X_test are our features to test on (20%)
# y_train are our labels to test on (20%)

X_train, X_test, y_train, y_test = train_test_split(
    df[['has_spaghetti', 'has_curry_powder']], # the first is our FEATURES
    df['label'], # the second parameter is the LABEL (this is 0/1, not italian/italian)
    test_size=0.2) # 80% training, 20% testing

# Oh hey, it's just our features from the dataframe
X_train

# X is always the features, whether it's for training or for testing
X_test

len(X_train)

len(X_test)

# We're testing on ~8000 and training on ~32000

# y_train is our labels that we are training one
y_train

# And y_test is the labels we're testing on
y_test

print("Length of training labels:", len(y_train))
print("Length of testing labels:", len(y_test))
print("Length of training features:", len(X_train))
print("Length of testing features:", len(X_test))

# Splitting into...
# X = are all our features
# y = are all our labels
# X_train are our features to train on (80%)
# y_train are our labels to train on (80%)
# X_test are our features to test on (20%)
# y_train are our labels to test on (20%)

X_train, X_test, y_train, y_test = train_test_split(
    df[['has_spaghetti', 'has_curry_powder']], # the first is our FEATURES
    df['label'], # the second parameter is the LABEL (this is 0/1, not italian/italian)
    test_size=0.2) # 80% training, 20% testing

# Import naive_bayes to get access to ALL kinds of naive bayes classifiers
# But REMEMBER we're using Bernoulli because it's for true/false which is fine
# for small passages
from sklearn import naive_bayes

# Create a Bernoulli Naive Bayes classifier
clf = naive_bayes.BernoulliNB()

# Feed the classifier two things:
#   * our training features (X_train)
#   * our training labels (y_train)
# To help it study for the exam later when we test it
clf.fit(X_train, y_train)

# This looks ugly but in theory it's what every recipe is
# All those zeroes = not italian
# We know the first three aren't italian and the last three aren't italian
clf.predict(X_test)

# Naive Bayes can't overfit, really
# It can't "study too hard" it can't "memorize the questions"
# (a decision tree can)
# So if we give it the training data back it will get some wrong
clf.score(X_train, y_train)

clf.score(X_test, y_test)

df['cuisine'].value_counts()

df['has_spaghetti']

#df[['has_spaghetti', 'has_curry_powder']]
df[['has_spaghetti']]

df.head()

def make_label(cuisine):
    if cuisine == "brazilian":
        return 1
    else:
        return 0

df['is_brazilian'] = df['cuisine'].apply(make_label)

df.head(2)

df['has_water'] = df['ingredient_list'].str.contains('water')
df['has_salt'] = df['ingredient_list'].str.contains('salt')

df.head(2)

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    df[['has_water', 'has_salt']], # the first is our FEATURES
    df['is_brazilian'], # the second parameter is the LABEL (this is 0/1, not italian/italian)
    test_size=0.2) # 80% training, 20% testing

from sklearn import naive_bayes

# Create a Bernoulli Naive Bayes classifier
clf = naive_bayes.BernoulliNB()

# Fit with our training data
clf.fit(X_train, y_train)

clf.score(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.dummy import DummyClassifier

dummy_clf = DummyClassifier(strategy='most_frequent')

# Fit with our training data
dummy_clf.fit(X_train, y_train)

dummy_clf.score(X_train, y_train)

dummy_clf.score(X_test, y_test)

# P(B|A) = P(A and B)/P(A)

# P(A and B)
# Probability that a recipe has water and is brazilian

# How many recipes have water AND are brazilian?
len(df[(df['has_water']) & (df['cuisine'] == 'brazilian')])

# P(A)
len(df['has_water'])

# P(B|A)
# The chance that a recipe is brazilian if it has water in it
109/39774

# P(A and B)
# Probability that a recipe has water and is NOT brazilian

# How many recipes have water AND are NOT brazilian?
len(df[(df['has_water']) & (df['cuisine'] != 'brazilian')])

# P(A)
# How many recipes have water?
len(df['has_water'])

# P(B|A)
# The chance that a recipe is NOT brazilian if it has water in it
9385/39774

len(df[df['cuisine'] == 'brazilian'])

len(df)

# Only a little bit over 1% of our recipes are brazilian
# so even though it ALWAYS say it "not brazilian", it's usually right
467/39774

1 - 467/39774

from sklearn import preprocessing

le = preprocessing.LabelEncoder()

# LabelEncoder has two parts: FIT and TRANSFORM
# FIT learns all of the possible labels
# TRANSFORM takes a list of categories and converts them into numbers

# Teach the label encoder all of the possible labels
# It doesn't care about duplicates 
le.fit(['orange', 'red', 'red', 'red', 'yellow', 'blue'])

# Get the labels out as numbers
le.transform(['orange', 'blue', 'yellow'])

# Send the label encoder each and every cuisine
le.fit(df['cuisine'])

le.transform(df['cuisine'])

df['cuisine_label'] = le.transform(df['cuisine'])
df.head(3)

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    df[['has_water', 'has_salt']], # the first is our FEATURES
    df['cuisine_label'], # the second parameter is the LABEL (0-16, southern us, brazilian, anything really)
    test_size=0.2) # 80% training, 20% testing

from sklearn import naive_bayes

# Create a Bernoulli Naive Bayes classifier
clf = naive_bayes.BernoulliNB()

# Learn how related every cuisine is to water and salt
clf.fit(X_train, y_train)

clf.score(X_train, y_train)

clf.score(X_test, y_test)

df['has_miso'] = df['ingredient_list'].str.contains("miso")
df['has_soy_sauce'] = df['ingredient_list'].str.contains("soy sauce")
df['has_cilantro'] = df['ingredient_list'].str.contains("cilantro")
df['has_black_olives'] = df['ingredient_list'].str.contains("black olives")
df['has_tortillas'] = df['ingredient_list'].str.contains("tortillas")
df['has_turmeric'] = df['ingredient_list'].str.contains("turmeric")
df['has_pistachios'] = df['ingredient_list'].str.contains("pistachios")
df['has_lemongrass'] = df['ingredient_list'].str.contains("lemongrass")

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    df[['has_spaghetti', 'has_miso', 'has_soy_sauce', 'has_cilantro','has_black_olives','has_tortillas','has_turmeric', 'has_pistachios','has_lemongrass']], # the first is our FEATURES
    df['cuisine_label'], # the second parameter is the LABEL (0-16, southern us, brazilian, anything really)
    test_size=0.2) # 80% training, 20% testing

from sklearn import naive_bayes

# Create a Bernoulli Naive Bayes classifier
clf = naive_bayes.BernoulliNB()

# Learn how related every cuisine is to water and salt
clf.fit(X_train, y_train)

clf.score(X_train, y_train)

clf.score(X_test, y_test)

from sklearn.feature_extraction.text import CountVectorizer

# STEP ONE: .fit to learn all of the words
# STEP TWO: .transform to turn a sentence into numbers

#vectorizer = CountVectorizer()
# So now 'olive' and 'oil' and 'olive oil' instead of just 'olive' and 'oil'
# Only pick the top 3000 most frequent ngrams
vectorizer = CountVectorizer(ngram_range=(1,2), max_features=3000)

# We have some sentences
# We're going to feed it to the vectorizer
# and it's going to learn all of the words
sentences = [
    "cats are cool",
    "dogs are cool"
]
vectorizer.fit(sentences)

# We're going to take some sentences and feed it to the vectorizer
# and its' going to convert it into numbers
vectorizer.transform(sentences)

# But it looks bad to look at so I'll use .toarray()
vectorizer.transform(sentences).toarray()

# In our case, our text is the list of ingredients. We can get it through
df['ingredient_list'].head()

# Dear vectorizer, please learn all of these words
vectorizer.fit(df['ingredient_list'])

# Dear vectorizer, please convert ingredient_list into features
# That we can do machine learning on

every_single_word_features = vectorizer.transform(df['ingredient_list'])
every_single_word_features

from sklearn.cross_validation import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    every_single_word_features,
    df['cuisine_label'], # the second parameter is the LABEL (0-16, southern us, brazilian, anything really)
    test_size=0.2) # 80% training, 20% testing

print("This is Naive Bayes")

from sklearn import naive_bayes
clf = naive_bayes.BernoulliNB()
%time clf.fit(X_train, y_train)

# How does it do on the training data?
print("Training score: (stuff it already knows)", clf.score(X_train, y_train))

# How does it do on the testing data?
print("Testing score: (stuff it hasn't seen before):", clf.score(X_test, y_test))

from sklearn.dummy import DummyClassifier

print("This is the Dummy Classifier")

dummy_clf = DummyClassifier()
%time dummy_clf.fit(X_train, y_train)

# How does it do on the training data?
print("Training score: (stuff it already knows)", dummy_clf.score(X_train, y_train))

# How does it do on the testing data?
print("Testing score: (stuff it hasn't seen before):", dummy_clf.score(X_test, y_test))

print("This is a Decision Tree")

from sklearn import tree
tree_clf = tree.DecisionTreeClassifier()

%time tree_clf.fit(X_train, y_train)

# How does it do on the training data?
print("Training score: (stuff it already knows)", tree_clf.score(X_train, y_train))

# How does it do on the testing data?
print("Testing score: (stuff it hasn't seen before):", tree_clf.score(X_test, y_test))

from sklearn.ensemble import RandomForestClassifier

print("This is a Random Forest")

tree_clf = RandomForestClassifier()

%time tree_clf.fit(X_train, y_train)

# How does it do on the training data?
print("Training score: (stuff it already knows)", tree_clf.score(X_train, y_train))

# How does it do on the testing data?
print("Testing score: (stuff it hasn't seen before):", tree_clf.score(X_test, y_test))

every_single_word_features = vectorizer.transform(df['ingredient_list'])

# Import the Naive bayes thing
from sklearn import naive_bayes
clf = naive_bayes.BernoulliNB()

# Give the classifier EVERYTHING we know, not holding back anything
clf.fit(every_single_word_features, df['cuisine_label'])

# We have some new stuff we have not categorized
incoming_recipes = [
    "spaghetti tomato sauce garlic onion water",
    "soy sauce ginger sugar butter",
    "green papaya thai chilies palm sugar",
    "butter oil salt black pepper water milk bubblegumpie"
]

features_for_new_recipes = vectorizer.transform(incoming_recipes)
features_for_new_recipes

predictions = clf.predict(features_for_new_recipes)
predictions

# The predictions are all categories that the labelencoder decided on
# Let's convert those numeric ones back into real fun cuisine words
le.inverse_transform(predictions)