Uma breve palavra introdutória
Acredito que poderíamos fazer mais coisas se recebêssemos instruções passo a passo que nos dissessem o que fazer e como fazer. Eu mesmo me lembro de momentos da minha vida em que não consegui começar algo porque era simplesmente difícil entender por onde começar. Talvez, uma vez na Internet você tenha visto as palavras “Ciência de Dados” e decidido que estava longe disso, e as pessoas que fazem isso estavam em algum lugar lá fora, em outro mundo. Não, eles estão bem aqui. E, talvez, graças a pessoas da área, um artigo apareceu no seu feed. Existem muitos cursos que vão te ajudar a se acostumar com esse ofício, mas aqui vou te ajudar a dar o primeiro passo.
Bem, você está pronto? Deixe-me dizer desde já que você precisará conhecer Python 3, pois é isso que irei usar aqui. Aconselho também que você instale-o no Jupyter Notebook com antecedência ou veja como usar o google colab.
Шаг первый
Kaggle é seu assistente importante neste assunto. Em princípio, você pode passar sem ele, mas falarei sobre isso em outro artigo. Esta é uma plataforma que hospeda competições de Data Science. Em cada uma dessas competições, nos estágios iniciais você ganhará uma quantidade irreal de experiência na resolução de problemas de vários tipos, experiência de desenvolvimento e experiência de trabalho em equipe, o que é importante em nosso tempo.
Assumiremos nossa tarefa a partir daí. Chama-se "Titânico". A condição é esta: prever se cada pessoa sobreviverá. De modo geral, a tarefa de uma pessoa envolvida no DS é coletar dados, processá-los, treinar um modelo, fazer previsões e assim por diante. No kaggle, podemos pular a etapa de coleta de dados - eles são apresentados na plataforma. Precisamos baixá-los e podemos começar!
Você pode fazer isso da seguinte maneira:
a guia Dados contém arquivos que contêm dados
Baixamos os dados, preparamos nossos notebooks Jupyter e...
Шаг второй
Como carregamos esses dados agora?
Primeiro, vamos importar as bibliotecas necessárias:
import pandas as pd
import numpy as np
O Pandas nos permitirá baixar arquivos .csv para processamento posterior.
Numpy é necessário para representar nossa tabela de dados como uma matriz com números.
Vá em frente. Vamos pegar o arquivo train.csv e enviá-lo para nós:
dataset = pd.read_csv('train.csv')
Faremos referência à nossa seleção de dados train.csv por meio da variável dataset. Vamos ver o que há lá:
dataset.head()
A função head() nos permite observar as primeiras linhas de um dataframe.
As colunas Survived são precisamente os nossos resultados, que são conhecidos neste dataframe. Para a questão da tarefa, precisamos prever a coluna Sobrevivido para dados test.csv. Esses dados armazenam informações sobre outros passageiros do Titanic, para os quais, ao resolver o problema, não sabemos o resultado.
Então, vamos dividir nossa tabela em dados dependentes e independentes. Tudo é simples aqui. Dados dependentes são aqueles dados que dependem dos dados independentes que estão nos resultados. Dados independentes são aqueles dados que influenciam o resultado.
Por exemplo, temos o seguinte conjunto de dados:
“Vova ensinava ciência da computação - não.
Vova recebeu nota 2 em ciência da computação.”
A nota em ciência da computação depende da resposta à pergunta: Vova estudou ciência da computação? Está claro? Vamos em frente, já estamos mais perto da meta!
A variável tradicional para dados independentes é X. Para dados dependentes, y.
Fazemos o seguinte:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
O que é isso? Com a função iloc[:, 2: ] dizemos ao Python: Quero ver na variável X os dados a partir da segunda coluna (inclusive e desde que a contagem comece do zero). Na segunda linha dizemos que queremos ver os dados da primeira coluna.
[ a:b, c:d ] é a construção do que usamos entre parênteses. Se você não especificar nenhuma variável, elas serão salvas como padrão. Ou seja, podemos especificar [:,: d] e então obteremos todas as colunas do dataframe, exceto aquelas que vão do número d em diante. As variáveis aeb definem strings, mas precisamos de todas elas, então deixamos isso como padrão.Vamos ver o que temos:
X.head()
y.head()
Para simplificar esta pequena lição, removeremos colunas que requerem cuidados especiais ou que não afetam em nada a capacidade de sobrevivência. Eles contêm dados do tipo str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Vamos para a próxima etapa.
Terceiro Passo
Aqui precisamos codificar nossos dados para que a máquina entenda melhor como esses dados afetam o resultado. Mas não codificaremos tudo, mas apenas os dados str que deixamos. Coluna "Sexo". Como queremos codificar? Vamos representar os dados sobre o gênero de uma pessoa como um vetor: 10 - masculino, 01 - feminino.
Primeiro, vamos converter nossas tabelas em uma matriz NumPy:
X = np.array(X)
y = np.array(y)
E agora vamos dar uma olhada:
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 é uma biblioteca muito legal que nos permite fazer um trabalho completo em Data Science. Ele contém um grande número de modelos interessantes de aprendizado de máquina e também nos permite preparar dados.
OneHotEncoder nos permitirá codificar o gênero de uma pessoa nessa representação, conforme descrevemos. Serão criadas 2 turmas: masculina, feminina. Se a pessoa for homem, será escrito 1 na coluna “masculino” e 0 na coluna “feminino”, respectivamente.
Depois de OneHotEncoder() existe [1] - isso significa que queremos codificar a coluna número 1 (contando de zero).
Super. Vamos avançar ainda mais!
Via de regra, acontece que alguns dados ficam em branco (ou seja, NaN - não um número). Por exemplo, há informações sobre uma pessoa: seu nome, sexo. Mas não há informações sobre sua idade. Neste caso, aplicaremos o seguinte método: encontraremos a média aritmética de todas as colunas e, se faltar algum dado na coluna, preencheremos o vazio com a média aritmética.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Agora vamos levar em conta que acontecem situações quando os dados são muito grandes. Alguns dados estão no intervalo [0:1], enquanto outros podem ultrapassar centenas e milhares. Para eliminar essa dispersão e tornar o computador mais preciso em seus cálculos, iremos escanear os dados e escaloná-los. Que todos os números não excedam três. Para fazer isso, usaremos a função StandardScaler.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Agora nossos dados ficam assim:
Aula. Já estamos perto do nosso objetivo!
Etapa quatro
Vamos treinar nosso primeiro modelo! Na biblioteca sklearn podemos encontrar um grande número de coisas interessantes. Apliquei o modelo Gradient Boosting Classifier a esse problema. Usamos o classificador A porque nossa tarefa é uma tarefa de classificação. O prognóstico deve ser atribuído a 1 (sobreviveu) ou 0 (não sobreviveu).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
A função fit diz ao Python: Deixe o modelo procurar dependências entre X e y.
Menos de um segundo e o modelo está pronto.
Como aplicar? Veremos agora!
Etapa cinco. Conclusão
Agora precisamos carregar uma tabela com nossos dados de teste para os quais precisamos fazer uma previsão. Com esta tabela faremos todas as mesmas ações que fizemos 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:])
Vamos aplicar nosso modelo agora!
gbc_predict = gbc.predict(X_test)
Todos. Fizemos uma previsão. Agora precisa ser gravado em csv e enviado ao site.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Preparar. Recebemos um arquivo contendo previsões para cada passageiro. Resta fazer o upload dessas soluções para o site e obter uma avaliação da previsão. Uma solução tão primitiva dá não apenas 74% de respostas corretas ao público, mas também algum impulso na Ciência de Dados. Os mais curiosos podem me escrever em mensagens privadas a qualquer momento e fazer perguntas. Obrigado a todos!
Fonte: habr.com