In [1]:
%matplotlib inline
import seaborn; seaborn.set()
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
In [2]:
from sklearn.datasets import load_iris
iris = load_iris()
class_names = iris.target_names
In [3]:
print(iris.data.shape)
print(iris.data[0:5])
In [4]:
print("0=Setosa, 1=Versicolor, 2=Virginica\n")
print(iris.target)
In [5]:
x_index = 0
y_index = 3
colors = ['blue', 'red', 'green']
for label, color in zip(range(len(iris.target_names)), colors):
plt.scatter(iris.data[iris.target==label, x_index],
iris.data[iris.target==label, y_index],
label=iris.target_names[label],
c=color)
plt.xlabel(iris.feature_names[x_index])
plt.ylabel(iris.feature_names[y_index])
plt.legend(loc='upper left')
plt.show()
In [6]:
x_index = 3
colors = ['blue', 'red', 'green']
for label, color in zip(range(len(iris.target_names)), colors):
plt.hist(iris.data[iris.target==label, x_index],
label=iris.target_names[label],
color=color)
plt.xlabel(iris.feature_names[x_index])
plt.legend(loc='upper right')
plt.show()
In [7]:
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)
iris_df["clase"] = iris.target
g = seaborn.pairplot(iris_df,hue="clase")
P. Cortez, A. Cerdeira, F. Almeida, T. Matos and J. Reis. Modeling wine preferences by data mining from physicochemical properties. In Decision Support Systems, Elsevier, 47(4):547-553. ISSN: 0167-9236. In the above reference, two datasets were created, using red and white wine samples. The inputs include objective tests (e.g. PH values) and the output is based on sensory data (median of at least 3 evaluations made by wine experts). Each expert graded the wine quality between 0 (very bad) and 10 (very excellent). Several data mining methods were applied to model these datasets under a regression approach. The support vector machine model achieved the best results. Several metrics were computed: MAD, confusion matrix for a fixed error tolerance (T), etc. Also, we plot the relative importances of the input variables (as measured by a sensitivity analysis procedure).
http://archive.ics.uci.edu/ml/datasets/Wine+Quality
Attribute information:
Input variables (based on physicochemical tests):
Output variable (based on sensory data):
In [8]:
# Desde la url
#url= "http://mlr.cs.umass.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv"
#data= pd.read_csv(url)
# Usando la data local
data = pd.read_csv("winequality-red.csv",sep=";")
data.tail()
Out[8]:
In [9]:
data.isnull().sum()
Out[9]:
In [10]:
data.shape
Out[10]:
In [11]:
data.describe()
Out[11]:
In [21]:
g1 = seaborn.pairplot(data,hue="quality")
In [12]:
y = data["quality"].values
In [13]:
X = data.drop("quality",axis=1)
In [14]:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y,
train_size=0.8,
random_state=10,
stratify=y)
Varios algoritmos de aprendizaje automático requieren que los datos posean las propiedades de una distribución normal estándar, es decir media igual a cero (μ= 0) y desviación estándar igual a uno (σ = 1). Debido a que los atributos poseen diferentes escalas, es recomendable normalizarlos.
**Es importante aqui, usar correctamente la API Transform de scikit-learn, esta permite hacer "fit" al paso de preprocesamiento usando los datos de entrenamieno, de la misma forma que se hace fit en un modelo. Posteriormente se puede "transformar" datos futuros. En resumen:
In [15]:
from sklearn import preprocessing
# Realizar el fit en los datos de entrenamiento
std = preprocessing.StandardScaler().fit(X_train)
# Aplicando el "Transformer" a los datos de entrenamiento
X_train_std = std.transform(X_train)
In [16]:
# Aplicando el "Transform" a los datos de prueba
X_test_std = std.transform(X_test)
In [17]:
from sklearn.linear_model import LinearRegression
lr = LinearRegression(fit_intercept=True)
lr.fit(X_train_std, y_train)
y_pred = lr.predict(X_test_std)
In [18]:
sum_of_squares = ((y_test - y_pred) ** 2).sum()
res_sum_of_squares = ((y_test - y_test.mean()) ** 2).sum()
r2_score = 1 - (sum_of_squares / res_sum_of_squares)
print('R2 score: %.3f' % r2_score)
In [19]:
lr.score(X_test_std,y_test)
Out[19]:
In [20]:
from sklearn.decomposition import PCA
n_c = 5
pca = PCA(n_components=n_c)
X_train_pca = pca.fit_transform(X_train_std)
var_exp = pca.explained_variance_ratio_
cum_var_exp = np.cumsum(var_exp)
idx = [i for i in range(len(var_exp))]
labels = [str(i + 1) for i in idx]
with plt.style.context('seaborn-whitegrid'):
plt.bar(range(n_c), var_exp, alpha=0.5, align='center',
label='individual explained variance')
plt.step(range(n_c), cum_var_exp, where='mid',
label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.xticks(idx, labels)
plt.legend(loc='center right')
plt.tight_layout()
plt.show()
In [21]:
pd.DataFrame(pca.components_,columns=X_train.columns,index = ['PC-1','PC-2','PC-3','PC-4','PC-5'])
Out[21]:
In [22]:
X_test_pca = pca.transform(X_test_std)
lr_pca = LinearRegression(fit_intercept=True)
lr_pca.fit(X_train_pca, y_train)
lr_pca.score(X_test_pca,y_test)
Out[22]:
El hundimiento del RMS Titanic es uno de los naufragios más infames de la historia. El 15 de abril de 1912, durante su viaje inaugural, el Titanic se hundió después de chocar con un iceberg, matando a 1502 de 2224 pasajeros y tripulación. Esta sensacional tragedia sorprendió a la comunidad internacional y condujo a mejores reglamentos de seguridad para los buques.
Una de las razones por las que el naufragio causó tal pérdida de vida fue que no había suficientes botes salvavidas para los pasajeros y la tripulación. Aunque hubo algún elemento de suerte involucrado en sobrevivir al hundimiento, algunos grupos de personas tenían más probabilidades de sobrevivir que otros, como mujeres, niños y la clase alta.
Veamos si podemos predecir que personas probablemente sobreviven usando un arbol de decisiones :D ...
In [23]:
titanic = pd.read_csv('titanic_train.csv')
titanic.tail()
Out[23]:
In [24]:
# Algunos pasajeros al parecer tienen informacion faltante
titanic.count()
Out[24]:
In [25]:
titanic_survived = titanic["Survived"]
In [26]:
titanic.groupby('Survived').count()
Out[26]:
In [27]:
numerical_titanic = titanic[['Fare', 'Pclass', 'Age']]
numerical_titanic.count()
Out[27]:
usaremos la funcion de pandas fillna() para agregar la mediana de cada columna a esos valores faltantes
In [28]:
median_titanic = numerical_titanic.dropna().median()
median_titanic
Out[28]:
In [29]:
train_titanic = numerical_titanic.fillna(median_titanic)
train_titanic.count()
Out[29]:
In [30]:
train_titanic.head(5)
Out[30]:
In [31]:
X2_train, X2_test, y2_train, y2_test = train_test_split(train_titanic, titanic_survived,
train_size=0.8,
random_state=10,
stratify=titanic_survived)
In [32]:
from sklearn.tree import DecisionTreeClassifier ,export_graphviz
clf = DecisionTreeClassifier(random_state=0,max_depth=4,criterion="entropy")
clf.fit(X2_train,y2_train)
export_graphviz(clf, feature_names=X2_train.columns)
Se puede visualizar el arbol generado en la pagina http://webgraphviz.com/ Copien el contenido del archivo "tree" generado y peguenlo en el recuadro mostrado en la pagina
In [34]:
from sklearn import metrics
metrics.mean_absolute_error(y2_test, clf.predict(X2_test))
Out[34]:
In [35]:
metrics.confusion_matrix(y2_test,clf.predict(X2_test))
Out[35]:
In [36]:
print(metrics.classification_report(y2_test,clf.predict(X2_test)))