Una breu paraula introductòria
Crec que podríem fer més coses si ens proporcionessin instruccions pas a pas que ens diguessin què fer i com fer-ho. Jo mateix recordo moments de la meva vida en què no vaig poder començar alguna cosa perquè simplement era difícil entendre per on començar. Potser hi havia una vegada a Internet que vau veure les paraules "Data Science" i vau decidir que estaveu lluny d'això, i que la gent que ho fa eren en algun lloc, en un altre món. No, són aquí mateix. I, potser, gràcies a gent d'aquest camp, va aparèixer un article al vostre feed. Hi ha molts cursos que t'ajudaran a acostumar-te a aquest ofici, però aquí t'ajudaré a fer el primer pas.
Bé, estàs preparat? Permeteu-me que us digui de seguida que haureu de conèixer Python 3, ja que això és el que faré servir aquí. També us aconsello que l'instal·leu a Jupyter Notebook amb antelació o que vegeu com utilitzar google colab.
pas 1
Kaggle és el teu assistent important en aquest assumpte. En principi, pots prescindir-ne, però en parlaré en un altre article. Aquesta és una plataforma que acull concursos de Data Science. En cadascuna d'aquestes competicions, en les primeres etapes obtindreu una quantitat poc realista d'experiència en la resolució de problemes de diversos tipus, experiència de desenvolupament i experiència de treball en equip, que és important en els nostres temps.
A partir d'aquí agafarem la nostra tasca. Es diu "Titanic". La condició és aquesta: predir si sobreviurà cada persona. En termes generals, la tasca d'una persona implicada en DS és recollir dades, processar-les, entrenar un model, fer previsions, etc. A kaggle, podem saltar l'etapa de recollida de dades: es presenten a la plataforma. Els hem de descarregar i ja podem començar!
Podeu fer-ho de la manera següent:
la pestanya Dades conté fitxers que contenen dades
Hem descarregat les dades, hem preparat els nostres quaderns Jupyter i...
pas 2
Com carreguem ara aquestes dades?
Primer, importem les biblioteques necessàries:
import pandas as pd
import numpy as np
Pandas ens permetrà descarregar fitxers .csv per a un posterior processament.
Es necessita Numpy per representar la nostra taula de dades com una matriu amb números.
Endavant. Agafem el fitxer train.csv i ens el pengem:
dataset = pd.read_csv('train.csv')
Ens referirem a la nostra selecció de dades train.csv mitjançant la variable del conjunt de dades. A veure què hi ha:
dataset.head()
La funció head() ens permet mirar les primeres files d'un marc de dades.
Les columnes Survived són precisament els nostres resultats, que es coneixen en aquest marc de dades. Per a la pregunta de la tasca, hem de predir la columna Survived per a les dades test.csv. Aquestes dades emmagatzemen informació sobre altres passatgers del Titanic, dels quals nosaltres, solucionant el problema, desconeixem el resultat.
Per tant, dividim la nostra taula en dades dependents i independents. Aquí tot és senzill. Les dades dependents són aquelles dades que depenen de les dades independents que hi ha als resultats. Les dades independents són aquelles dades que influeixen en el resultat.
Per exemple, tenim el conjunt de dades següent:
"Vova va ensenyar informàtica - no.
Vova va rebre un 2 en informàtica.
La nota en informàtica depèn de la resposta a la pregunta: Vova va estudiar informàtica? Està clar? Seguim endavant, ja estem més a prop de l'objectiu!
La variable tradicional per a dades independents és X. Per a dades dependents, y.
Feu el següent:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Què és això? Amb la funció iloc[:, 2: ] li diem a Python: Vull veure a la variable X les dades a partir de la segona columna (inclosa i sempre que el recompte comenci des de zero). A la segona línia diem que volem veure les dades de la primera columna.
[ a:b, c:d ] és la construcció del que fem servir entre parèntesis. Si no especifiqueu cap variable, es desaran per defecte. És a dir, podem especificar [:,: d] i aleshores obtindrem totes les columnes del dataframe, excepte les que van del número d en endavant. Les variables a i b defineixen cadenes, però les necessitem totes, així que ho deixem per defecte.Vegem què tenim:
X.head()
y.head()
Per tal de simplificar aquesta petita lliçó, eliminarem les columnes que requereixin una cura especial o que no afectin en absolut la supervivència. Contenen dades del tipus str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Súper! Passem al següent pas.
Pas tercer
Aquí hem de codificar les nostres dades perquè la màquina entengui millor com aquestes dades afecten el resultat. Però no codificarem tot, sinó només les dades str que hem deixat. Columna "Sexe". Com volem codificar? Representem les dades sobre el gènere d'una persona com a vector: 10 - home, 01 - femení.
Primer, convertim les nostres taules en una matriu NumPy:
X = np.array(X)
y = np.array(y)
I ara mirem:
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 és una biblioteca tan fantàstica que ens permet fer un treball complet a Data Science. Conté un gran nombre de models d'aprenentatge automàtic interessants i també ens permet fer la preparació de dades.
OneHotEncoder ens permetrà codificar el gènere d'una persona en aquesta representació, tal com hem descrit. Es crearan 2 classes: masculina, femenina. Si la persona és un home, s'escriurà 1 a la columna "masculina" i 0 a la columna "dona", respectivament.
Després de OneHotEncoder() hi ha [1]: això vol dir que volem codificar la columna número 1 (comptant des de zero).
Súper. Anem més lluny encara!
Per regla general, això passa que algunes dades es deixen en blanc (és a dir, NaN, no un nombre). Per exemple, hi ha informació sobre una persona: el seu nom, gènere. Però no hi ha informació sobre la seva edat. En aquest cas, aplicarem el següent mètode: trobarem la mitjana aritmètica a totes les columnes i, si falten algunes dades a la columna, aleshores omplirem el buit amb la mitjana aritmètica.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Ara tinguem en compte que es produeixen situacions quan les dades són molt grans. Algunes dades es troben a l'interval [0:1], mentre que algunes poden anar més enllà de centenars i milers. Per eliminar aquesta dispersió i fer que l'ordinador sigui més precís en els seus càlculs, escanejarem les dades i les escalarem. Que tots els nombres no superin els tres. Per fer-ho, utilitzarem la funció StandardScaler.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Ara les nostres dades es veuen així:
Classe. Ja estem a prop del nostre objectiu!
Pas quatre
Entrenem el nostre primer model! A la biblioteca sklearn podem trobar un gran nombre de coses interessants. Vaig aplicar el model Gradient Boosting Classifier a aquest problema. Utilitzem un classificador perquè la nostra tasca és una tasca de classificació. El pronòstic s'ha d'assignar a 1 (va sobreviure) o 0 (no va sobreviure).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
La funció d'ajust diu a Python: Deixeu que el model cerqui dependències entre X i y.
Menys d'un segon i el model està llest.
Com aplicar-ho? Ja ho veurem!
Pas cinc. Conclusió
Ara hem de carregar una taula amb les nostres dades de prova per a les quals hem de fer una previsió. Amb aquesta taula farem les mateixes accions que vam fer per a 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:])
Apliquem el nostre model ara!
gbc_predict = gbc.predict(X_test)
Tots. Hem fet una previsió. Ara s'ha d'enregistrar en csv i enviar-lo al lloc web.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
A punt. Hem rebut un fitxer amb prediccions per a cada passatger. Només queda penjar aquestes solucions al lloc web i obtenir una valoració de la previsió. Una solució tan primitiva no només dóna el 74% de les respostes correctes al públic, sinó també un cert impuls a la ciència de dades. Els més curiosos poden escriure'm en missatges privats en qualsevol moment i fer una pregunta. Gràcies a tots!
Font: www.habr.com