Una breve palabra introductoria
Creo que podríamos hacer más cosas si recibiéramos instrucciones paso a paso que nos dijeran qué hacer y cómo hacerlo. Yo mismo recuerdo momentos de mi vida en los que no podía empezar algo porque simplemente era difícil entender por dónde empezar. Quizás una vez en Internet viste las palabras "Ciencia de datos" y decidiste que estabas lejos de esto y que las personas que hacen esto estaban en algún lugar, en otro mundo. No, están justo aquí. Y, quizás, gracias a personas de este campo, apareció un artículo en tu feed. Hay muchos cursos que te ayudarán a acostumbrarte a este oficio, pero aquí te ayudaré a dar el primer paso.
Bueno, ¿estás listo? Déjame decirte de inmediato que necesitarás conocer Python 3, ya que eso es lo que usaré aquí. También le recomiendo que lo instale en Jupyter Notebook con anticipación o que vea cómo usar Google Colab.
paso uno
Kaggle es su importante asistente en este asunto. En principio, puedes prescindir de él, pero de esto hablaré en otro artículo. Esta es una plataforma que alberga competencias de ciencia de datos. En cada una de estas competiciones, en las primeras etapas adquirirás una cantidad irreal de experiencia en la resolución de problemas de diversos tipos, experiencia en desarrollo y experiencia en el trabajo en equipo, lo cual es importante en nuestro tiempo.
A partir de ahí emprenderemos nuestra tarea. Se llama "Titanic". La condición es ésta: predecir si cada persona individual sobrevivirá. En términos generales, la tarea de una persona involucrada en DS es recopilar datos, procesarlos, entrenar un modelo, realizar pronósticos, etc. En Kaggle, podemos saltarnos la etapa de recopilación de datos: se presentan en la plataforma. ¡Necesitamos descargarlos y podemos comenzar!
Puede hacer esto de la siguiente manera:
la pestaña Datos contiene archivos que contienen datos
Descargamos los datos, preparamos nuestros cuadernos Jupyter y...
paso dos
¿Cómo cargamos ahora estos datos?
Primero, importemos las bibliotecas necesarias:
import pandas as pd
import numpy as np
Pandas nos permitirá descargar archivos .csv para su posterior procesamiento.
Se necesita Numpy para representar nuestra tabla de datos como una matriz con números.
Adelante. Tomemos el archivo train.csv y subámoslo:
dataset = pd.read_csv('train.csv')
Nos referiremos a nuestra selección de datos train.csv a través de la variable del conjunto de datos. Veamos qué hay ahí:
dataset.head()
La función head() nos permite ver las primeras filas de un marco de datos.
Las columnas Sobrevividas son precisamente nuestros resultados, que se conocen en este marco de datos. Para la pregunta de la tarea, necesitamos predecir la columna Sobrevivido para los datos test.csv. Estos datos almacenan información sobre otros pasajeros del Titanic, cuyo resultado, al resolver el problema, no sabemos.
Entonces, dividamos nuestra tabla en datos dependientes e independientes. Aquí todo es sencillo. Los datos dependientes son aquellos datos que dependen de los datos independientes que se encuentran en los resultados. Los datos independientes son aquellos datos que influyen en el resultado.
Por ejemplo, tenemos el siguiente conjunto de datos:
“Vova enseñó informática, no.
Vova recibió un 2 en informática”.
La nota en informática depende de la respuesta a la pregunta: ¿Vova estudió informática? ¿Está limpio? ¡Sigamos adelante que ya estamos más cerca de la meta!
La variable tradicional para datos independientes es X. Para datos dependientes, y.
Hacemos lo siguiente:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
¿Lo que es? Con la función iloc[:, 2: ] le decimos a Python: Quiero ver en la variable X los datos empezando por la segunda columna (inclusive y siempre que el conteo comience desde cero). En la segunda línea decimos que queremos ver los datos de la primera columna.
[a:b, c:d] es la construcción de lo que usamos entre paréntesis. Si no especifica ninguna variable, se guardarán de forma predeterminada. Es decir, podemos especificar [:,:d] y luego obtendremos todas las columnas del dataframe, excepto las que van del número d en adelante. Las variables a y b definen cadenas, pero las necesitamos todas, así que dejamos esto como predeterminado.Veamos qué tenemos:
X.head()
y.head()
Para simplificar esta pequeña lección, eliminaremos las columnas que requieren cuidados especiales o que no afectan en absoluto la supervivencia. Contienen datos de tipo str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
¡Súper! Pasemos al siguiente paso.
Paso tres
Aquí necesitamos codificar nuestros datos para que la máquina comprenda mejor cómo estos datos afectan el resultado. Pero no codificaremos todo, sino solo los datos str que dejamos. Columna "Sexo". ¿Cómo queremos codificar? Representemos datos sobre el género de una persona como un vector: 10 - masculino, 01 - femenino.
Primero, conviertamos nuestras tablas en una matriz NumPy:
X = np.array(X)
y = np.array(y)
Y ahora veamos:
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X = np.array(ct.fit_transform(X))
La biblioteca sklearn es una biblioteca genial que nos permite realizar un trabajo completo en ciencia de datos. Contiene una gran cantidad de modelos interesantes de aprendizaje automático y también nos permite preparar datos.
OneHotEncoder nos permitirá codificar el género de una persona en esa representación, como describimos. Se crearán 2 clases: masculina, femenina. Si la persona es un hombre, entonces se escribirá 1 en la columna “masculino” y 0 en la columna “femenina”, respectivamente.
Después de OneHotEncoder() está [1]; esto significa que queremos codificar la columna número 1 (contando desde cero).
Súper. ¡Avancemos aún más!
Como regla general, esto sucede cuando algunos datos se dejan en blanco (es decir, NaN, no un número). Por ejemplo, hay información sobre una persona: su nombre, sexo. Pero no hay información sobre su edad. En este caso, aplicaremos el siguiente método: encontraremos la media aritmética en todas las columnas y, si falta algún dato en la columna, llenaremos el vacío con la media aritmética.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Ahora tengamos en cuenta que se dan situaciones en las que los datos son muy grandes. Algunos datos están en el intervalo [0:1], mientras que otros pueden ir más allá de cientos y miles. Para eliminar dicha dispersión y hacer que la computadora sea más precisa en sus cálculos, escanearemos los datos y los escalaremos. Que todos los números no excedan de tres. Para ello utilizaremos la función StandardScaler.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Ahora nuestros datos se ven así:
Clase. ¡Ya estamos cerca de nuestra meta!
Paso cuatro
¡Entrenemos a nuestro primer modelo! En la biblioteca de sklearn podemos encontrar una gran cantidad de cosas interesantes. Apliqué el modelo Clasificador de aumento de gradiente a este problema. Usamos un clasificador porque nuestra tarea es una tarea de clasificación. El pronóstico debe asignarse a 1 (sobrevivió) o 0 (no sobrevivió).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
La función de ajuste le dice a Python: Deje que el modelo busque dependencias entre X e y.
Menos de un segundo y el modelo está listo.
¿Cómo aplicarlo? ¡Ya veremos!
Paso cinco. Conclusión
Ahora necesitamos cargar una tabla con nuestros datos de prueba para los cuales necesitamos hacer un pronóstico. Con esta tabla haremos las mismas acciones que hicimos para X.
X_test = pd.read_csv('test.csv', index_col=0)
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X_test.drop(count, inplace=True, axis=1)
X_test = np.array(X_test)
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X_test = np.array(ct.fit_transform(X_test))
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X_test)
X_test = imputer.transform(X_test)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_test[:, 2:] = sc.fit_transform(X_test[:, 2:])
¡Apliquemos nuestro modelo ahora!
gbc_predict = gbc.predict(X_test)
Todo. Hicimos un pronóstico. Ahora debe grabarse en csv y enviarse al sitio.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Listo. Recibimos un archivo que contiene predicciones para cada pasajero. Todo lo que queda es cargar estas soluciones en el sitio web y obtener una evaluación del pronóstico. Una solución tan primitiva no sólo proporciona un 74% de respuestas correctas al público, sino también cierto impulso en la ciencia de datos. Los más curiosos pueden escribirme en mensajes privados en cualquier momento y hacerme una pregunta. ¡Gracias a todos!
Fuente: habr.com