Cómo empezar con el aprendizaje automático en unos 10 minutos

Con el auge del aprendizaje automático dentro de las industrias, la necesidad de una herramienta que pueda ayudarlo a recorrer el proceso rápidamente se ha vuelto vital. Python, una estrella en ascenso en la tecnología de aprendizaje automático, suele ser la primera opción para lograr el éxito. Por lo tanto, es realmente necesaria una guía de aprendizaje automático con Python.

Introducción al aprendizaje automático con Python

Entonces, ¿por qué Python? En mi experiencia, Python es uno de los lenguajes de programación más fáciles de aprender. Es necesario repetir el proceso rápidamente, y el científico de datos no necesita tener un conocimiento profundo del lenguaje, ya que puede dominarlo muy rápido.

¿Cuan sencillo?

for anything in the_list: print(anything)

Así de fácil . La sintaxis está estrechamente relacionada con el inglés (o el lenguaje humano, no una máquina). Y no hay paréntesis tontos que confundan a los humanos. Tengo una colega que trabaja en Control de calidad, no es ingeniera de software, y puede escribir código Python en un día a nivel de producción. (¡De verdad!)

Entonces, los creadores de las bibliotecas que discutiremos a continuación eligieron Python para su elección de lenguaje. Y como analista de datos y científico, podemos usar sus obras maestras para ayudarnos a completar las tareas. Estas son las increíbles bibliotecas, imprescindibles para el aprendizaje automático con Python .

  1. Numpy

La famosa biblioteca de análisis numérico. Le ayudará a hacer muchas cosas, desde calcular la mediana de distribución de datos hasta procesar matrices multidimensionales.

2. Pandas

Para procesar archivos CSV. Por supuesto, necesitará procesar algunas tablas y ver estadísticas, y esta es la herramienta adecuada que desea utilizar.

3. Matplotlib

Una vez que tenga los datos almacenados en los marcos de datos de Pandas, es posible que necesite algunas visualizaciones para comprender más sobre los datos. Las imágenes siguen siendo mejores que miles de palabras.

4. Seaborn

Esta es también otra herramienta de visualización, pero más centrada en la visualización estadística. Cosas como histogramas, gráficos circulares o curvas, o quizás tablas de correlación.

5. Scikit-Learn

Este es el jefe final de Machine Learning con Python. EL LLAMADO Machine Learning con Python es este tipo. Scikit-Learn. Todo lo que necesita, desde algoritmos hasta mejoras, está aquí.

6. Tensorflow y Pytorch

No hablo mucho de estos dos. Pero si estás interesado en Deep Learning, échales un vistazo, valdrá la pena tu tiempo. (La próxima vez daré otro tutorial sobre Deep Learning, ¡estad atentos!)

Proyectos de aprendizaje automático de Python

Por supuesto, leer y estudiar solos no lo llevarán a donde necesita ir. Necesitas práctica real. Como dije en mi blog, aprender las herramientas no tiene sentido si no te lanzas a los datos. Entonces, les presento un lugar donde pueden encontrar proyectos de aprendizaje automático de Python fácilmente.

Kaggle es una plataforma donde puede sumergirse directamente en los datos. Resolverá proyectos y se volverá realmente bueno en el aprendizaje automático. Algo que podría hacer que te interese más: las competencias de aprendizaje automático que organiza pueden darte un premio de hasta $ 100,000. Y es posible que desee probar suerte. Jaja.

Pero lo más importante no es el dinero, es realmente un lugar donde puede encontrar Machine Learning con Python Projects. Hay muchos proyectos que puedes probar. Pero si eres un novato, y supongo que lo eres, querrás unirte a esta competencia.

Aquí hay un proyecto de ejemplo que usaremos en el siguiente tutorial:

Titanic: aprendizaje automático a partir de desastres

Sí, el infame Titanic. Un trágico desastre en 1912, que se cobró la vida de 1502 personas de 2224 pasajeros y tripulación. Esta competencia de Kaggle (o puedo decir tutorial) le brinda los datos reales sobre el desastre. Y su tarea es explicar los datos para que pueda predecir si un personal sobrevivió o no durante el incidente.

Aprendizaje automático con tutorial de Python

Antes de profundizar en los datos del Titanic, instalemos algunas herramientas que necesita.

Por supuesto, Python. Primero debe instalarlo desde el sitio web oficial de Python. Necesita instalar la versión 3.6+ para mantenerse actualizado con las bibliotecas.

Después de eso, debe instalar todas las bibliotecas a través de Python pip. Pip debería instalarse automáticamente con la distribución de Python que acaba de descargar.

Luego instale las cosas que necesita a través de pip. Abra su terminal, línea de comando o Powershell y escriba lo siguiente:

pip install numpypip install pandaspip install matplotlibpip install seabornpip install scikit-learnpip install jupyter

Bueno, todo se ve bien. Pero espera, ¿qué es jupyter? Jupyter significa Julia, Python y R, de ahí Jupytr. Pero es una extraña combinación de palabras, así que la cambiaron a Jupyter. Es un cuaderno famoso donde puedes escribir código Python de forma interactiva.

Simplemente escriba jupyter notebook en su terminal y abrirá una página de navegador como esta:

Escriba el código dentro del rectángulo verde y podrá escribir y evaluar el código Python de forma interactiva.

Ahora ha instalado todas las herramientas. ¡Vámonos!

Exploración de datos

El primer paso es explorar los datos. Debes descargar los datos de la página del Titanic en Kaggle. Luego, coloque los datos extraídos dentro de una carpeta donde inicia su cuaderno de Jupyter.

Luego importe las bibliotecas necesarias:

import numpy as np import pandas as pdimport matplotlib.pyplot as pltimport seaborn as snsimport warningswarnings.filterwarnings('ignore')%matplotlib inline

Luego cargue los datos:

train_df=pd.read_csv("train.csv")train_df.head()

Verá algo como esto:

Esos son nuestros datos. Tiene las siguientes columnas:

  1. PassengerId, el identificador del pasajero
  2. Sobrevivido, haya sobrevivido o no
  3. Pclass, la clase del servicio, tal vez 1 es económica, 2 es empresarial y 3 es de primera clase
  4. Nombre, el nombre del pasajero
  5. Sexo
  6. Años
  7. Hermanos, o hermanos y cónyuges, número de hermanos y cónyuges a bordo
  8. Parch, o padres e hijos, número de ellos a bordo
  9. Ticket, detalle del ticket
  10. Cabin, their cabin. NaN means unknown
  11. Embarked, the origin of embarkation, S for Southampton, Q for Queenstown, C for Cherbourg

While exploring data, we often find missing data. Let’s see them:

def missingdata(data): total = data.isnull().sum().sort_values(ascending = False) percent = (data.isnull().sum()/data.isnull().count()*100).sort_values(ascending = False) ms=pd.concat([total, percent], axis=1, keys=['Total', 'Percent']) ms= ms[ms["Percent"] > 0] f,ax =plt.subplots(figsize=(8,6)) plt.xticks(rotation='90') fig=sns.barplot(ms.index, ms["Percent"],color="green",alpha=0.8) plt.xlabel('Features', fontsize=15) plt.ylabel('Percent of missing values', fontsize=15) plt.title('Percent missing data by feature', fontsize=15) return ms
missingdata(train_df)

We will see a result like this:

The cabin, age, and embarked data has some missing values. And cabin information is largely missing. We need to do something about them. This is what we call Data Cleaning.

Data Cleaning

This is what we use 90% of the time. We will do Data Cleaning a lot for every single Machine Learning project. When the data is clean, we can easily jump ahead to the next step without worrying about anything.

The most common technique in Data Cleaning is filling missing data. You can fill the data missing with Mode, Mean, or Median. There is no absolute rule on these choices — you can try to choose one after another and see the performance. But, for a rule of thumb, you can only use mode for categorized data, and you can use median or mean for continuous data.

So let’s fill the embarkation data with Mode and the Age data with median.

train_df['Embarked'].fillna(train_df['Embarked'].mode()[0], inplace = True)train_df['Age'].fillna(train_df['Age'].median(), inplace = True)

The next important technique is to just remove the data, especially for largely missing data. Let’s do it for the cabin data.

drop_column = ['Cabin']train_df.drop(drop_column, axis=1, inplace = True)

Now we can check the data we have cleaned.

print('check the nan value in train data')print(train_df.isnull().sum())

Perfect! No missing data found. Means the data has been cleaned.

Feature Engineering

Now we have cleaned the data. The next thing we can do is Feature Engineering.

Feature Engineering is basically a technique for finding Feature or Data from the currently available data. There are several ways to do this technique. More often, it is about common sense.

Let’s take a look at the Embarked data: it is filled with Q, S, or C. The Python library will not be able to process this, since it is only able to process numbers. So you need to do something called One Hot Vectorization, changing the column into three columns. Let’s say Embarked_Q, Embarked_S, and Embarked_C which are filled with 0 or 1 whether the person embarked from that harbor or not.

The other example is SibSp and Parch. Maybe there is nothing interesting in both of those columns, but you might want to know how big the family was of the passenger who boarded in the ship. You might assume that if the family was bigger, then the chance of survival would increase, since they could help each other. On other hand, solo people would’ve had it hard.

So you want to create another column called family size, which consists of sibsp + parch + 1 (the passenger themself).

The last example is called bin columns. It is a technique which creates ranges of values to group several things together, since you assume it is hard to differentiate things with similar value. For example, Age. For a person aged 5 and 6, is there any significant difference? or for person aged 45 and 46, is there any big difference?

That’s why we create bin columns. Maybe for age, we will create 4 bins. Children (0–14 years), Teenager (14–20), Adult (20–40), and Elders (40+)

Let’s code them:

all_data = train_df
for dataset in all_data : dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
import re# Define function to extract titles from passenger namesdef get_title(name): title_search = re.search(' ([A-Za-z]+)\.', name) # If the title exists, extract and return it. if title_search: return title_search.group(1) return ""# Create a new feature Title, containing the titles of passenger namesfor dataset in all_data: dataset['Title'] = dataset['Name'].apply(get_title)# Group all non-common titles into one single grouping "Rare"for dataset in all_data: dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss') dataset['Title'] = dataset['Title'].replace('Ms', 'Miss') dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')
for dataset in all_data: dataset['Age_bin'] = pd.cut(dataset['Age'], bins=[0,14,20,40,120], labels=['Children','Teenage','Adult','Elder'])
for dataset in all_data: dataset['Fare_bin'] = pd.cut(dataset['Fare'], bins=[0,7.91,14.45,31,120], labels ['Low_fare','median_fare', 'Average_fare','high_fare']) traindf=train_dffor dataset in traindf: drop_column = ['Age','Fare','Name','Ticket'] dataset.drop(drop_column, axis=1, inplace = True)
drop_column = ['PassengerId']traindf.drop(drop_column, axis=1, inplace = True)traindf = pd.get_dummies(traindf, columns = ["Sex","Title","Age_bin","Embarked","Fare_bin"], prefix=["Sex","Title","Age_type","Em_type","Fare_type"])

Now, you have finished all the features. Let’s take a look into the correlation for each feature:

sns.heatmap(traindf.corr(),annot=True,cmap='RdYlGn',linewidths=0.2) #data.corr()-->correlation matrixfig=plt.gcf()fig.set_size_inches(20,12)plt.show()

Las correlaciones con un valor de 1 significan una alta correlación positiva, -1 significa una alta correlación negativa . Por ejemplo, el sexo masculino y el sexo femenino se correlacionarán negativamente, ya que los pasajeros tuvieron que identificarse con uno u otro sexo. Aparte de eso, puede ver que nada relacionado con nada altamente excepto los creados a través de la ingeniería de funciones. Esto significa que estamos listos para comenzar.

¿Qué pasará si algo se correlaciona mucho con otra cosa? Podemos eliminar uno de ellos ya que agregar otra información a través de una nueva columna no le dará al sistema información nueva ya que ambos son exactamente iguales.

Aprendizaje automático con Python

Ahora hemos llegado al ápice del tutorial: Modelado de Machine Learning.

from sklearn.model_selection import train_test_split #for split the datafrom sklearn.metrics import accuracy_score #for accuracy_scorefrom sklearn.model_selection import KFold #for K-fold cross validationfrom sklearn.model_selection import cross_val_score #score evaluationfrom sklearn.model_selection import cross_val_predict #predictionfrom sklearn.metrics import confusion_matrix #for confusion matrixall_features = traindf.drop("Survived",axis=1)Targeted_feature = traindf["Survived"]X_train,X_test,y_train,y_test = train_test_split(all_features,Targeted_feature,test_size=0.3,random_state=42)X_train.shape,X_test.shape,y_train.shape,y_test.shape

Puede elegir muchos algoritmos incluidos dentro de la biblioteca scikit-learn.

  1. Regresión logística
  2. Bosque aleatorio
  3. SVM
  4. K Vecino más cercano
  5. Naive Bayes
  6. Decision Trees
  7. AdaBoost
  8. LDA
  9. Gradient Boosting

You might be overwhelmed trying to figure out what is what. Don’t worry, just treat is as a black box: choose one with the best performance. (I will create a whole article on these algorithms later.)

Let’s try it with my favorite one: the Random Forest Algorithm

from sklearn.ensemble import RandomForestClassifiermodel = RandomForestClassifier(criterion='gini', n_estimators=700, min_samples_split=10,min_samples_leaf=1, max_features="auto",oob_score=True, random_state=1,n_jobs=-1)model.fit(X_train,y_train)prediction_rm=model.predict(X_test)print('--------------The Accuracy of the model----------------------------')print('The accuracy of the Random Forest Classifier is', round(accuracy_score(prediction_rm,y_test)*100,2))kfold = KFold(n_splits=10, random_state=22) # k=10, split the data into 10 equal partsresult_rm=cross_val_score(model,all_features,Targeted_feature,cv=10,scoring='accuracy')print('The cross validated score for Random Forest Classifier is:',round(result_rm.mean()*100,2))y_pred = cross_val_predict(model,all_features,Targeted_feature,cv=10)sns.heatmap(confusion_matrix(Targeted_feature,y_pred),annot=True,fmt='3.0f',cmap="summer")plt.title('Confusion_matrix', y=1.05, size=15)

Wow! It gives us 83% accuracy. That’s good enough for our first time.

The cross validated score means a K Fold Validation method. If K = 10, it means you split the data in 10 variations and compute the mean of all scores as the final score.

Fine Tuning

Now you are done with the steps in Machine Learning with Python. But, there is one more step which can bring you better results: fine tuning. Fine tuning means finding the best parameter for Machine Learning Algorithms. If you see the code for random forest above:

model = RandomForestClassifier(criterion='gini', n_estimators=700, min_samples_split=10,min_samples_leaf=1, max_features="auto",oob_score=True, random_state=1,n_jobs=-1)

There are many parameters you need to set. These are the defaults, by the way. And you can change the parameters however you want. But of course, it will takes a lot of time.

Don’t worry — there is a tool called Grid Search, which finds the optimal parameters automatically. Sounds great, right?

# Random Forest Classifier Parameters tunning model = RandomForestClassifier()n_estim=range(100,1000,100)
## Search grid for optimal parametersparam_grid = {"n_estimators" :n_estim}
model_rf = GridSearchCV(model,param_grid = param_grid, cv=5, scoring="accuracy", n_jobs= 4, verbose = 1)
model_rf.fit(train_X,train_Y)
# Best scoreprint(model_rf.best_score_)
#best estimatormodel_rf.best_estimator_

Well, you can try it out for yourself. And have fun with Machine Learning.

Conclusion

How was it? It doesn’t seem very difficult does it? Machine Learning with Python is easy. Everything has been laid out for you. You can just do the magic. And bring happiness to people.

This piece was originally released on my blog at thedatamage.com