<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 Session 26/6/2017 - machine learning
Découverte des trois problèmes de machine learning exposé dans l'article Machine Learning - session 6.
Step1:  Problème 1 
Step2:  Random Forest
Step3:  On s'inspire de l'exemple Feature importances with forests of trees.
Step4:  Modèle linéaire
Step5:  TPOT
TPOT est un module d'apprentissage automatique.
Step6:  Le module optimise les hyperparamètres, parfois un peu trop à en juger la mauvaise performance obtenue sur la base de test.
Step7:  Feature importance pour une observations
On reprend la première random forest et on utilise le module treeinterpreter.
Step8:  Problème 2 
Step9:  Méthode non linéaire
On construire la matrice des séries décalées. Cette méthode permet de sortir du cadre linéaire et d'ajouter d'autres variables.
Step10:  Texte
On cherche à comparer une LDA avec word2vec et kmeans et les données qui sont sur ensae_teaching_cs/src/ensae_teaching_cs/data/data_web/.
Step11:  Des mots aux coordonnées - tf-idf
Step12:  LDA
Step13:  On obtient dix vecteurs qui représentent les dix vecteurs associés aux dix clusters. Chaque dimension relié au fait que le mot appartient ou non au cluster.
Step14:  Clustering
<ASSISTANT_TASK:>
Python Code:
from jyquickhelper import add_notebook_menu
add_notebook_menu()
Explanation: Session 26/6/2017 - machine learning
Découverte des trois problèmes de machine learning exposé dans l'article Machine Learning - session 6.
End of explanation
import pandas
df = pandas.read_csv("data/housing.data", delim_whitespace=True, header=None)
df.head()
cols = "CRIM ZN INDUS CHAS NOX RM AGE DIS RAD TAX PTRATIO B LSTAT MEDV".split()
df.columns = cols
df.head()
X = df.drop("MEDV", axis=1)
y = df["MEDV"]
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
Explanation: Problème 1 : comparaison random forest, linéaire
C'est un problème de régression. On cherche à comparer une random forest avec un modèle linéaire.
Comparaison des tests de coefficients pour un modèle linéaire
  OLS
  et des features importance
Résultat au niveau d'une observation treeinterpreter
Données : Housing, Forest Fire
Données
End of explanation
from sklearn.ensemble import RandomForestRegressor
clr = RandomForestRegressor()
clr.fit(X, y)
importances = clr.feature_importances_
importances
Explanation: Random Forest
End of explanation
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
plt.figure(figsize=(12,4))
indices = np.argsort(importances)[::-1]
std = np.std([tree.feature_importances_ for tree in clr.estimators_],
             axis=0)
plt.title("Feature importances")
plt.bar(range(X.shape[1]), importances[indices],
        color="r", yerr=std[indices], align="center")
xlabels = list(df.columns[:-1])
xlabels = [xlabels[i] for i in indices]
plt.xticks(range(X.shape[1]), xlabels)
plt.xlim([-1, X.shape[1]])
plt.show()
from sklearn.metrics import r2_score
r2_score(y_train, clr.predict(X_train))
r2_score(y_test, clr.predict(X_test))
Explanation: On s'inspire de l'exemple Feature importances with forests of trees.
End of explanation
import statsmodels.api as sm
model = sm.OLS(y_train, X_train)
results = model.fit()
results.params
results.summary()
model = sm.OLS(y,X.drop("LSTAT", axis=1))
results = model.fit()
results.summary()
Explanation: Modèle linéaire
End of explanation
try:
    from tpot import TPOTRegressor
except ImportError:
    # for sklearn 0.22
    import sklearn.preprocessing    
    from sklearn.impute import SimpleImputer
    sklearn.preprocessing.Imputer = SimpleImputer
    from tpot import TPOTRegressor
tpot = TPOTRegressor(generations=2, population_size=50, verbosity=2)
tpot.fit(X_train, y_train)
print(tpot.score(X_test, y_test))
tpot.export('tpot_boston_pipeline.py')
Explanation: TPOT
TPOT est un module d'apprentissage automatique.
End of explanation
r2_score(y_train, tpot.predict(X_train))
r2_score(y_test, tpot.predict(X_test))
Explanation: Le module optimise les hyperparamètres, parfois un peu trop à en juger la mauvaise performance obtenue sur la base de test.
End of explanation
clr = RandomForestRegressor()
clr.fit(X, y)
from treeinterpreter import treeinterpreter as ti
prediction, bias, contributions = ti.predict(clr, X_test)
for i in range(min(2, X_train.shape[0])):
    print("Instance", i)
    print("Bias (trainset mean)", bias[i])
    print("Feature contributions:")
    for c, feature in sorted(zip(contributions[i], df.columns), 
                             key=lambda x: -abs(x[0])):
        print(feature, round(c, 2))
    print( "-"*20)
Explanation: Feature importance pour une observations
On reprend la première random forest et on utilise le module treeinterpreter.
End of explanation
import pandas
df = pandas.read_csv("data/multiTimeline.csv", skiprows=1)
df.columns= ["Semaine", "compte"]
df["SemaineDt"] = pandas.to_datetime(df.Semaine)
df=df.set_index("SemaineDt")
df["compte"] = df["compte"].astype(float)
df.head()
%matplotlib inline
df.plot()
from statsmodels.tsa.arima_model import ARIMA
arma_mod = ARIMA(df["compte"].values, order=(6 ,1, 1))
res = arma_mod.fit()
res.params
res.summary()
Explanation: Problème 2 : série temporelle
On prend une série sur Google Trends, dans notre cas, c'est la requête tennis live. On compare une approche linéaire et une approche non linéaire.
Approche linéaire
End of explanation
from statsmodels.tsa.tsatools import lagmat
lag = 8
X = lagmat(df["compte"], lag)
lagged = df.copy()
for c in range(1,lag+1):
    lagged["lag%d" % c] = X[:, c-1]
pandas.concat([lagged.head(), lagged.tail()])
xc = ["lag%d" % i for i in range(1,lag+1)]
split = 0.66
isplit = int(len(lagged) * split)
xt = lagged[10:][xc]
yt = lagged[10:]["compte"]
X_train, y_train, X_test, y_test = xt[:isplit], yt[:isplit], xt[isplit:], yt[isplit:]
from sklearn.ensemble import RandomForestRegressor
clr = RandomForestRegressor()
clr.fit(X_train, y_train)
from sklearn.metrics import r2_score
r2 = r2_score(y_test.values, clr.predict(X_test))
r2
plt.scatter(y_test.values, clr.predict(X_test));
Explanation: Méthode non linéaire
On construire la matrice des séries décalées. Cette méthode permet de sortir du cadre linéaire et d'ajouter d'autres variables.
End of explanation
from ensae_teaching_cs.data import twitter_zip
df = twitter_zip(as_df=True)
df.head(n=2).T
Explanation: Texte
On cherche à comparer une LDA avec word2vec et kmeans et les données qui sont sur ensae_teaching_cs/src/ensae_teaching_cs/data/data_web/.
End of explanation
keep = df.text.dropna().index
dfnonan = df.iloc[keep, :]
dfnonan.shape
from sklearn.feature_extraction.text import TfidfVectorizer
tfidf_vectorizer = TfidfVectorizer(max_df=0.95, min_df=2, max_features=1000)
tfidf = tfidf_vectorizer.fit_transform(dfnonan["text"])
tfidf[:2, :]
tfidf[:2, :].todense()
Explanation: Des mots aux coordonnées - tf-idf
End of explanation
from sklearn.decomposition import LatentDirichletAllocation
lda = LatentDirichletAllocation(n_components=10, max_iter=5,
                                learning_method='online',
                                learning_offset=50.,
                                random_state=0)
lda.fit(tfidf)
tf_feature_names = tfidf_vectorizer.get_feature_names()
tf_feature_names[100:103]
lda.components_.shape
Explanation: LDA
End of explanation
def print_top_words(model, feature_names, n_top_words):
    for topic_idx, topic in enumerate(model.components_):
        print("Topic #%d:" % topic_idx)
        print(" ".join([feature_names[i]
                        for i in topic.argsort()[:-n_top_words - 1:-1]]))
    print()
print_top_words(lda, tf_feature_names, 10)
Explanation: On obtient dix vecteurs qui représentent les dix vecteurs associés aux dix clusters. Chaque dimension relié au fait que le mot appartient ou non au cluster.
End of explanation
from sklearn.cluster import KMeans
km = KMeans(n_clusters=10)
km.fit(tfidf)
km.cluster_centers_.shape
def print_top_words(model, feature_names, n_top_words):
    for topic_idx, topic in enumerate(model.cluster_centers_):
        print("Topic #%d:" % topic_idx)
        print(" ".join([feature_names[i]
                        for i in topic.argsort()[:-n_top_words - 1:-1]]))
    print()
print_top_words(km, tf_feature_names, 10)
Explanation: Clustering
End of explanation
<END_TASK>