from sklearn import tree
import numpy as np
X = np.array([ [0, 0], [1, 1], [0, 1] ]) # training data (2 features 3 samples)
y = np.array([0, 1, 0]) # labelling data
classifier = tree.DecisionTreeClassifier(random_state=0, criterion='entropy',max_depth=None)
classifier.fit(X, y)
print(classifier.predict([[2, 2]]))

import matplotlib.pyplot as plt
def visualize_classifier(model, X, y, ax=None, cmap='rainbow',pa=1):
    # pa para tope izquierda y derecha eje x 
    ax = plt.subplot(111)
    # Dibujamos los puntos
    ax.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=cmap,
    clim=(y.min(), y.max()), zorder=3)
    ax.axis('tight')
    #ax.axis('off')
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    # fit the estimator
    model.fit(X, y)
    xx, yy = np.meshgrid(np.linspace(*xlim, num=200),
    np.linspace(*ylim, num=200))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
    # Create a color plot with the results
    n_classes = len(np.unique(y))
    contours = ax.contourf(xx, yy, Z, alpha=0.3,
        levels=np.arange(n_classes + 1) - 0.5,
        cmap=cmap, 
        zorder=1)
    #ax.set(xlim=xlim, ylim=ylim)
    ax.set_xlim(left=int(min(X[:, 0]))-pa,right=int(max(X[:, 0]))+pa)
    #ax.set_xticks((np.arange(int(min(X[:, 0])-1), int(max(X[:, 0])+1), 1.0)))
    #ax.set_xticks((np.arange(int(min(X[:, 1])-1), int(max(X[:, 1])+1), 1.0)))

%matplotlib inline
visualize_classifier(classifier,X,y,pa=0.1)

from sklearn.externals.six import StringIO  
from IPython.display import Image  
from sklearn.tree import export_graphviz
import pydotplus
dot_data = StringIO()
export_graphviz(classifier, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
Image(graph.create_png())

import sklearn.datasets as datasets
import pandas as pd
iris=datasets.load_iris()
X = iris.data
y = iris.target
df=pd.DataFrame(iris.data, columns=iris.feature_names)
y=iris.target
X[:5,:]

from sklearn.tree import DecisionTreeClassifier
dtree=DecisionTreeClassifier()
dtree.fit(df,y)

from sklearn.externals.six import StringIO  
from IPython.display import Image  
from sklearn.tree import export_graphviz
import pydotplus
dot_data = StringIO()
export_graphviz(dtree, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
Image(graph.create_png())

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
estimator = DecisionTreeClassifier(max_leaf_nodes=3, random_state=0)
estimator.fit(X_train, y_train)

import sklearn
help(sklearn.tree._tree.Tree)

#Obtenemos el número de nodos del modelo
n_nodes = estimator.tree_.node_count
print("Número de nodos del estimador:",n_nodes)
children_left = estimator.tree_.children_left
print("Valores de children_left \n",children_left)
children_right = estimator.tree_.children_right
print("Valores de children_right\n",children_right)
feature = estimator.tree_.feature
print("feature utilizada para para el split del nodo", feature)
threshold = estimator.tree_.threshold
print("Puntos de corte",threshold)

# La estructura anterior puede ser utilizada para obtener varias propiedades 
# la profuncidad de cada nodo o si el mismo es una hoja.
node_depth = np.zeros(shape=n_nodes, dtype=np.int64)
is_leaves = np.zeros(shape=n_nodes, dtype=bool)
stack = [(0, -1)]  # seed is the root node id and its parent depth
while len(stack) > 0:
    node_id, parent_depth = stack.pop()
    node_depth[node_id] = parent_depth + 1

    # If we have a test node
    if (children_left[node_id] != children_right[node_id]):
        stack.append((children_left[node_id], parent_depth + 1))
        stack.append((children_right[node_id], parent_depth + 1))
    else:
        is_leaves[node_id] = True

print("El árbol creado tiene %s nodes y con la siguiente estructura:"
      % n_nodes)
for i in range(n_nodes):
    if is_leaves[i]:
        print("%snodo =%s nodo hoja." % (node_depth[i] * "\t", i))
    else:
        print("%snodo =%s nodo de test: ir al nodo %s if X[:, %s] <= %s y si no al"
              " nodo %s."
              % (node_depth[i] * "\t",
                 i,
                 children_left[i],
                 feature[i],
                 threshold[i],
                 children_right[i],
                 ))
print()

print("Dimensión de X_test: ", X_test.shape)
# Con el método "decision_path" se obtiene el camino seguido paracada elemento de la muestra.
# Un valor distinto de cero en (i,j) indica que el elemento i de la muestra va vía el nodo j. 
#este método devuelve una matriz sparse, y aquí la pasamos a una matriz de tipo dense, con
#la finalidad de ver una estructura más familiar.

node_indicator = estimator.decision_path(X_test)
print( "Dimensión de node_indicator: ",node_indicator.shape)
print("caminos seguidos por los 5 primeros elementos de la muestra: \n",node_indicator.todense()[:5] )

# Con el método "apply" se devuelve el índice de la hoja
# que se predice para cada elemento de la muestra 

leave_id = estimator.apply(X_test)
print("Dimensión de leave_id: ",leave_id.shape)
print(leave_id)

#Ahora, es posible obtener las pruebas que se usaron para predecir una muestra o 
#un grupo de muestras. Primero, hagámoslo para la muestra

sample_id = 0
node_index = node_indicator.indices[node_indicator.indptr[sample_id]:
                                    node_indicator.indptr[sample_id + 1]]

print('Reglas utilizadas para predecir la muestra %s: ' % sample_id)
for node_id in node_index:
    if leave_id[sample_id] == node_id:
        continue

    if (X_test[sample_id, feature[node_id]] <= threshold[node_id]):
        threshold_sign = "<="
    else:
        threshold_sign = ">"

    print("decision id node %s : (X_test[%s, %s] (= %s) %s %s)"
          % (node_id,
             sample_id,
             feature[node_id],
             X_test[sample_id, feature[node_id]],
             threshold_sign,
             threshold[node_id]))

# For a group of samples, we have the following common node.
sample_ids = [0, 1]
common_nodes = (node_indicator.toarray()[sample_ids].sum(axis=0) ==
                len(sample_ids))

common_node_id = np.arange(n_nodes)[common_nodes]

print("\nLas siguientes muestras %s comparte el nodo %s en el árbol"
      % (sample_ids, common_node_id))
print("es el %s %% de todos los nodos." % (100 * len(common_node_id) / n_nodes,))

from sklearn.datasets import make_blobs
X, y = make_blobs(n_samples=300, centers=4,
random_state=0, cluster_std=1)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='rainbow');

tree = DecisionTreeClassifier(max_depth=6).fit(X, y)

visualize_classifier(tree, X, y,pa=1)

import sys
sys.path.append('G:\\modulos_py')

print(sys.path)

%matplotlib inline
for i in range(6):
    tree = DecisionTreeClassifier(max_depth=i+1).fit(X, y)

    helpers_05_08.visualize_tree(tree,X,y)
    plt.show()
    

from sklearn import tree
X = [[0, 0], [2, 2],[1,3]]
y = [0.5, 2.5,3]
clf = tree.DecisionTreeRegressor()
clf = clf.fit(X, y)
clf.predict([[1, 1]])

from sklearn.tree import DecisionTreeRegressor
# Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(5 * rng.rand(80, 1), axis=0)
print("Dimensión de X",X.shape)
y = np.sin(X).ravel()
print("Dimensión de y: ",y.shape)
y[::5] += 3 * (0.5 - rng.rand(16))

# Fit regression model
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
regr_3 = DecisionTreeRegressor(max_depth=3)
regr_1.fit(X, y)
regr_2.fit(X, y)
regr_3.fit(X, y)


# Predict
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)
y_3 = regr_3.predict(X_test)

# Plot the results
plt.figure( figsize=(10,10) )
plt.scatter(X, y, s=20, edgecolor="black",
            c="darkorange", label="datos")
plt.plot(X_test, y_1, color="cornflowerblue",
         label="max_depth=2", linewidth=2)
plt.plot(X_test, y_2, color="yellowgreen", label="max_depth=5", linewidth=2)
plt.plot(X_test, y_3,'--' , color="red", label="max_depth=3", linewidth=1)
plt.xlabel("data")
plt.ylabel("target")
plt.title("Decision Tree Regresión")
plt.legend()
plt.show()

from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_blobs
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.tree import DecisionTreeClassifier

X, y = make_blobs(n_samples=10000, n_features=10, centers=100,
     random_state=0)

clf = DecisionTreeClassifier(max_depth=None, min_samples_split=2,
     random_state=0)
scores = cross_val_score(clf, X, y, cv=5)
print("La media de los scores en modo normal: ", scores.mean())                               
#0.98...

clf = RandomForestClassifier(n_estimators=10, max_depth=None,
     min_samples_split=2, random_state=0)
scores = cross_val_score(clf, X, y, cv=5)
print("La media de los scores para random forest: ", scores.mean())                               
#0.999...

clf = ExtraTreesClassifier(n_estimators=10, max_depth=None,
     min_samples_split=2, random_state=0)
scores = cross_val_score(clf, X, y, cv=5)
print("La media de los scores para un extra random forest: ",scores.mean()) 
#True