Unha breve palabra introdutoria
Creo que poderiamos facer máis cousas se nos proporcionaran instrucións paso a paso que nos indicasen que facer e como facelo. Eu mesmo recordo momentos da miña vida nos que non podía comezar algo porque simplemente era difícil entender por onde comezar. Quizais, unha vez en Internet viches as palabras "Data Science" e decidiches que estabas lonxe diso, e que a xente que o fai estaba nalgún lugar, noutro mundo. Non, están aquí mesmo. E, quizais, grazas a xente deste campo, apareceu un artigo no teu feed. Hai moitos cursos que che axudarán a acostumarte a este oficio, pero aquí axudarei a dar o primeiro paso.
Ben, estás preparado? Déixeme dicirche de inmediato que terás que coñecer Python 3, xa que iso é o que vou usar aquí. Tamén che aconsello que o instales en Jupyter Notebook con antelación ou que vexas como usar google colab.
primeiro paso
Kaggle é o teu asistente importante neste asunto. En principio, podes prescindir del, pero disto falarei noutro artigo. Esta é unha plataforma que acolle competicións de Data Science. En cada unha destas competicións, nas primeiras fases, obterás unha experiencia pouco realista na resolución de problemas de varios tipos, experiencia de desenvolvemento e experiencia de traballo en equipo, o que é importante no noso tempo.
A partir de aí levaremos a nosa tarefa. Chámase "Titanic". A condición é esta: prever se cada persoa individual sobrevivirá. En xeral, a tarefa dunha persoa implicada en DS é recoller datos, procesalas, adestrar un modelo, facer previsións, etc. En kaggle, permítenos saltar a fase de recollida de datos: preséntanse na plataforma. Temos que descargalos e podemos comezar!
Podes facelo do seguinte xeito:
a pestana Datos contén ficheiros que conteñen datos
Descargamos os datos, preparamos os nosos cadernos Jupyter e...
etapa dous
Como cargamos agora estes datos?
En primeiro lugar, imos importar as bibliotecas necesarias:
import pandas as pd
import numpy as np
Pandas permitiranos descargar ficheiros .csv para o seu procesamento posterior.
Necesítase Numpy para representar a nosa táboa de datos como unha matriz con números.
Adiante. Collemos o ficheiro train.csv e subímolo para nós:
dataset = pd.read_csv('train.csv')
Referirémonos á nosa selección de datos train.csv a través da variable do conxunto de datos. A ver que hai:
dataset.head()
A función head() permítenos mirar as primeiras filas dun marco de datos.
As columnas Sobrevividos son precisamente os nosos resultados, que se coñecen neste marco de datos. Para a pregunta da tarefa, necesitamos predecir a columna Sobrevivido para os datos test.csv. Estes datos almacenan información sobre outros pasaxeiros do Titanic, dos que nós, resolvendo o problema, descoñecemos o resultado.
Entón, imos dividir a nosa táboa en datos dependentes e independentes. Aquí todo é sinxelo. Os datos dependentes son aqueles datos que dependen dos datos independentes que hai nos resultados. Os datos independentes son aqueles datos que inflúen no resultado.
Por exemplo, temos o seguinte conxunto de datos:
"Vova ensinou informática - non.
Vova recibiu un 2 en informática.
A nota en informática depende da resposta á pregunta: Vova estudou informática? ¿Está claro? Seguimos, xa estamos máis preto da meta!
A variable tradicional para os datos independentes é X. Para os datos dependentes, y.
Facemos o seguinte:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Que é? Coa función iloc[:, 2: ] dicímoslle a Python: Quero ver na variable X os datos a partir da segunda columna (incluída e sempre que o reconto comece de cero). Na segunda liña dicimos que queremos ver os datos da primeira columna.
[ a:b, c:d ] é a construción do que usamos entre parénteses. Se non especifica ningunha variable, gardaranse por defecto. É dicir, podemos especificar [:,: d] e despois obteremos todas as columnas do marco de datos, excepto as que van do número d en diante. As variables a e b definen cadeas, pero necesitamos todas, polo que deixamos isto por defecto.A ver que temos:
X.head()
y.head()
Para simplificar esta pequena lección, eliminaremos as columnas que requiren coidados especiais ou que non afectan en absoluto á supervivencia. Conteñen datos do tipo str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Pasemos ao seguinte paso.
Paso tres
Aquí necesitamos codificar os nosos datos para que a máquina entenda mellor como afectan estes datos ao resultado. Pero non codificaremos todo, senón só os datos str que deixamos. Columna "Sexo". Como queremos codificar? Imos representar os datos sobre o xénero dunha persoa como un vector: 10 - masculino, 01 - feminino.
Primeiro, imos converter as nosas táboas nunha matriz NumPy:
X = np.array(X)
y = np.array(y)
E agora vexamos:
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))
A biblioteca sklearn é unha biblioteca tan interesante que nos permite facer un traballo completo en Data Science. Contén un gran número de modelos de aprendizaxe automática interesantes e tamén nos permite facer a preparación de datos.
OneHotEncoder permitiranos codificar o xénero dunha persoa nesa representación, como describimos. Crearanse 2 clases: masculina, feminina. Se a persoa é un home, escribirase 1 na columna "masculino" e 0 na columna "feminina", respectivamente.
Despois de OneHotEncoder() hai [1] - isto significa que queremos codificar a columna número 1 (contando desde cero).
Super. Imos aínda máis lonxe!
Como regra xeral, isto ocorre que algúns datos quedan en branco (é dicir, NaN - non un número). Por exemplo, hai información sobre unha persoa: o seu nome, sexo. Pero non hai información sobre a súa idade. Neste caso, aplicaremos o seguinte método: atoparemos a media aritmética en todas as columnas e, se falta algún dato na columna, encheremos o baleiro coa media aritmética.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Agora imos ter en conta que ocorren situacións cando os datos son moi grandes. Algúns datos están no intervalo [0:1], mentres que algúns poden ir máis alá de centos e miles. Para eliminar esa dispersión e facer que o ordenador sexa máis preciso nos seus cálculos, escanearemos os datos e escalaremos. Que todos os números non superen o tres. Para iso, utilizaremos a función StandardScaler.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Agora os nosos datos teñen o seguinte aspecto:
Clase. Xa estamos preto do noso obxectivo!
Paso catro
Imos adestrar o noso primeiro modelo! Desde a biblioteca de sklearn podemos atopar un gran número de cousas interesantes. Apliquei o modelo Gradient Boosting Classifier a este problema. Usamos un clasificador porque a nosa tarefa é unha tarefa de clasificación. O prognóstico debe asignarse a 1 (sobreviviu) ou 0 (non sobreviviu).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
A función fit dille a Python: Deixe o modelo buscar dependencias entre X e y.
Menos dun segundo e o modelo está listo.
Como aplicalo? Xa veremos!
Paso cinco. Conclusión
Agora necesitamos cargar unha táboa cos nosos datos de proba para a que necesitamos facer unha previsión. Con esta táboa faremos todas as mesmas accións que fixemos 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:])
Imos aplicar o noso modelo agora!
gbc_predict = gbc.predict(X_test)
Todos. Fixemos unha previsión. Agora hai que gravalo en csv e envialo ao sitio web.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Listo. Recibimos un ficheiro que contén predicións para cada pasaxeiro. Só queda subir estas solucións á páxina web e facer unha valoración da previsión. Unha solución tan primitiva dá non só o 74% das respostas correctas ao público, senón tamén un certo impulso na Ciencia de Datos. Os máis curiosos poden escribirme en mensaxes privadas en calquera momento e facer unha pregunta. Grazas a todos!
Fonte: www.habr.com