Recrutamento no campus: um problema de classificação com regressão logística

Introdução

Neste projeto, estaremos nos concentrando em dados da Índia. E nosso objetivo é criar um modelo preditivo, como Regressão Logística, etc. para que, quando damos as características de um candidato, o modelo possa prever se ele irá recrutar.

A conjunto de dados gira em torno da temporada de colocação de uma escola de negócios na Índia. O conjunto de dados contém vários fatores sobre os candidatos, como experiência de trabalho, porcentagem do exame, etc. Por fim, contém o status do recrutamento e os detalhes da remuneração.

O recrutamento no campus é uma estratégia para buscar, engajar e contratar jovens talentos para estágios e cargos iniciantes. Freqüentemente, envolve trabalhar com centros de serviços de carreira universitários e participar de feiras de carreira para se encontrar pessoalmente com estudantes universitários e recém-formados.

Este artigo foi publicado como parte do Blogatona de Ciência de Dados.

Conteúdo

1. Etapas envolvidas na solução do problema
2. Prepare os dados
3. Construir um modelo de regressão logística
4. Resultados do Modelo de Regressão Logística
5. Conclusão

Etapas envolvidas na solução do problema

Neste artigo, vamos importar esse conjunto de dados, limpá-lo e prepará-lo para construir um modelo de regressão logística. Nossos objetivos aqui são os seguintes:

Primeiro, vamos preparar nosso conjunto de dados para classificação binária. Agora, o que quero dizer? quando tentamos prever um valor contínuo, como o preço de um apartamento, pode ser qualquer número entre zero e muitos milhões de dólares. Nós o chamamos de problema de regressão.

Mas neste projeto, as coisas são um pouco diferentes. Em vez de prever um valor contínuo, temos grupos ou classes discretas que estamos tentando prever entre eles. Isso é chamado de problema de classificação e, como em nosso projeto, teremos apenas dois grupos entre os quais estamos tentando escolher, isso o torna uma classificação binária.

O segundo objetivo é criar um modelo de regressão logística para prever o recrutamento. E nosso terceiro objetivo é explicar as previsões de nosso modelo usando a razão de chances.

Agora, em termos de fluxo de trabalho de aprendizado de máquina, as etapas que seguiremos e algumas das coisas novas que aprenderemos ao longo do caminho. Portanto, na fase de importação, prepararemos nossos dados para trabalhar com um destino binário. Na fase de exploração, veremos o equilíbrio da classe. Então, basicamente, que proporção de candidatos era a terceira e que proporção não era? e na fase de codificação de recursos, faremos a codificação de nossos recursos categóricos. Na parte de divisão, faremos uma divisão de teste de trem aleatório.

Para a fase de construção do modelo, primeiro definiremos nossa linha de base e, como usaremos pontuações de precisão, falaremos mais sobre o que é uma pontuação de precisão e como construir uma linha de base quando essa é a métrica em que estamos interessados. Em segundo lugar, faremos regressão logística. E por último, mas não menos importante, teremos a fase de avaliação. Vamos nos concentrar novamente na pontuação de precisão. Por fim, para comunicar os resultados, veremos a razão de chances.

Por fim, antes de mergulhar no trabalho, vamos nos apresentar às bibliotecas que usaremos no projeto. Primeiro, importaremos nossos dados para o bloco de anotações do Google Colabe na biblioteca io. Então, como usaremos um modelo de regressão logística, vamos importá-lo do scikit-learn. Depois disso, também de scikit-learn, importaremos nossas métricas de desempenho, a pontuação de precisão e a divisão de teste de treinamento.

Nós vamos usar matplotlib e marítimos para nossa visualização, e NumPy  será apenas para um pouco de matemática.
Nós precisamos pandas para manipular nossos dados, labelencoder para codificar nossas variáveis ​​categóricas e escalador padrão para normalizar os dados. Essas serão as bibliotecas de que precisamos.

Vamos começar a preparar os dados.

#import libraries
import io
import warnings import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler warnings.simplefilter(action="ignore", category=FutureWarning)

Prepare os dados

importação

Para começar a preparar os dados, vamos começar nosso importante trabalho. Primeiro, carregamos nosso arquivo de dados e, em seguida, precisamos colocá-los em um DataFrame `df.`

from google.colab import files
uploaded = files.upload()

# Read CSV file
df = pd.read_csv(io.BytesIO(uploaded["Placement_Data_Full_Class.csv"]))
print(df.shape)
df.head()

Podemos ver nosso lindo DataFrame, e temos 215 registros e 15 colunas que incluem o atributo `status`, nosso alvo. Esta é a descrição de todos os recursos.

Explore

Agora temos todos esses recursos que vamos explorar. Então vamos começar nosso Análise exploratória de dados. Primeiro, vamos dar uma olhada nas informações desse dataframe e ver se precisamos manter alguma delas ou se talvez precisemos descartar.

# Inspect DataFrame
df.info() <class 'pandas.core.frame.DataFrame'>
RangeIndex: 215 entries, 0 to 214
Data columns (total 15 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 sl_no 215 non-null int64 1 gender 215 non-null object 2 ssc_p 215 non-null float64 3 ssc_b 215 non-null object 4 hsc_p 215 non-null float64 5 hsc_b 215 non-null object 6 hsc_s 215 non-null object 7 degree_p 215 non-null float64 8 degree_t 215 non-null object 9 workex 215 non-null object 10 etest_p 215 non-null float64 11 specialisation 215 non-null object 12 mba_p 215 non-null float64 13 status 215 non-null object 14 salary 148 non-null float64
dtypes: float64(6), int64(1), object(8)
memory usage: 25.3+ KB

Agora, quando olhamos para as informações de `df`, há algumas coisas que procuramos, temos 215 linhas em nosso dataframe e a pergunta que queremos fazer a nós mesmos é: há algum dado ausente? E se olharmos aqui, parece que não faltam dados a não ser na coluna salário, como era de se esperar, devido a candidatos que não foram contratados.

Outra preocupação para nós aqui é: há algum recurso com vazamento que forneceria informações ao nosso modelo que ele não teria se fosse implantado no mundo real? Lembre-se de que queremos que nosso modelo preveja se um candidato será colocado ou não, e queremos que nosso modelo faça essas previsões antes que o recrutamento aconteça. Portanto, não queremos fornecer nenhuma informação sobre esses candidatos após o recrutamento.

Portanto, fica bastante claro que esse recurso de 'salário' fornece informações sobre o salário oferecido pela empresa. E porque esse salário é para os aceitos, esse recurso aqui é vazamento, e a gente tem que largar.

df.drop(columns="salary", inplace=True)

A segunda coisa que quero ver são os tipos de dados para esses diferentes recursos. Então, olhando para esses tipos de dados, temos oito feições categóricas com nosso alvo e sete feições numéricas, e tudo está correto. Então, agora que temos essas ideias, vamos dedicar algum tempo para explorá-las mais profundamente.

Sabemos que nosso alvo tem duas classes. Colocamos candidatos e não colocamos candidatos. A questão é: qual é a proporção relativa dessas duas classes? Eles são sobre o mesmo equilíbrio? Ou um é muito mais do que o outro? Isso é algo que você precisa observar quando estiver resolvendo problemas de classificação. Portanto, este é um passo significativo em nossa EDA.

# Plot class balance
df["status"].value_counts(normalize=True).plot( kind="bar", xlabel="Class", ylabel="Relative Frequency", title="Class Balance"
);

Nossa classe positiva 'colocado' conta com mais de 65% de nossas observações, e nossa classe negativa 'Não colocado' está em torno de 30%. Agora, se essas fossem super desequilibradas, tipo, se fossem mais uns 80 ou até mais que isso, eu diria que são classes desequilibradas. E teríamos que fazer algum trabalho para garantir que nosso modelo funcionaria da maneira certa. Mas este é um bom equilíbrio.

Vamos fazer outra visualização para perceber a conexão entre nossos recursos e o alvo. Vamos começar com os recursos numéricos.

Primeiro, veremos a distribuição individual dos recursos usando um gráfico de distribuição e também veremos a relação entre os recursos numéricos e nosso alvo usando um gráfico de caixa.

fig,ax=plt.subplots(5,2,figsize=(15,35))
for index,i in enumerate(df.select_dtypes("number").drop(columns="sl_no")): plt.suptitle("Visualizing Distribution of Numerical Columns Indivualy and by Class",size=20) sns.histplot(data=df, x=i, kde=True, ax=ax[index,0]) sns.boxplot(data=df, x='status', y=i, ax=ax[index,1]);

Na primeira coluna do nosso gráfico, podemos ver que todas as distribuições seguem uma distribuição normal, e a maioria dos desempenhos educacionais do candidato estão entre 60-80%.

Na segunda coluna, temos um gráfico de caixa dupla com a classe 'Colocado' à direita e a classe 'Não colocado' à esquerda. Para os recursos 'etest_p' e 'mba_p', não há muita diferença nessas duas distribuições de uma perspectiva de construção de modelo. Há uma sobreposição significativa na distribuição das classes, portanto, esses recursos não seriam um bom indicador de nosso destino. Quanto ao restante dos recursos, eles são distintos o suficiente para considerá-los bons preditores em potencial de nosso alvo. Vamos passar para os recursos categóricos. E para explorá-los, usaremos um gráfico de contagem.

fig,ax=plt.subplots(7,2,figsize=(15,35))
for index,i in enumerate(df.select_dtypes("object").drop(columns="status")): plt.suptitle("Visualizing Count of Categorical Columns",size=20) sns.countplot(data=df,x=i,ax=ax[index,0]) sns.countplot(data=df,x=i,ax=ax[index,1],hue="status")

Olhando para o enredo, vemos que temos mais candidatos do sexo masculino do que do sexo feminino. E a maioria dos nossos candidatos não tem nenhuma experiência de trabalho, mas esses candidatos foram contratados mais do que os que tiveram. Temos candidatos que fizeram comércio como seu curso 'hsc' e, além de graduação, os candidatos com formação em ciências são os segundos mais altos em ambos os casos.

Uma pequena observação sobre os modelos de regressão logística, embora sejam para classificação, estão no mesmo grupo de outros modelos lineares como a regressão linear, e por isso, já que são ambos modelos lineares. Também precisamos nos preocupar com a questão da multicolinearidade. Portanto, precisamos criar uma matriz de correlação e depois plotá-la em um mapa de calor. Não queremos ver todos os recursos aqui, queremos ver apenas os recursos numéricos e não queremos incluir nosso destino. Já que se nosso alvo se correlaciona com algumas de nossas características, isso é muito bom.

corr = df.select_dtypes("number").corr()
# Plot heatmap of `correlation`
plt.title('Correlation Matrix')
sns.heatmap(corr, vmax=1, square=True, annot=True, cmap='GnBu');

Aqui estão o azul claro, que significa pouca ou nenhuma correlação, e o azul escuro, com o qual temos uma correlação maior. Por isso, queremos estar atentos aos azuis escuros. Podemos ver uma linha azul escura, uma linha diagonal descendo no meio deste gráfico. Essas são as características que estão correlacionadas consigo mesmas. E então, vemos alguns quadrados escuros. Isso significa que temos um monte de correlações entre os recursos.

Na etapa final de nossa EDA, precisamos verificar a cardinalidade alta-baixa nos recursos categóricos. Cardinalidade refere-se ao número de valores únicos em uma variável categórica. A alta cardinalidade significa que os recursos categóricos têm um grande número de valores exclusivos. Não há um número exato de valores exclusivos que tornam um recurso de alta cardinalidade. Mas se o valor da feição categórica for único para quase todas as observações, geralmente pode ser descartado.

# Check for high- and low-cardinality categorical features
df.select_dtypes("object").nunique() gender 2
ssc_b 2
hsc_b 2
hsc_s 3
degree_t 3
workex 2
specialisation 2
status 2
dtype: int64

Não vejo nenhuma coluna em que o número de valores exclusivos seja um ou qualquer coisa super alta. Mas acho que há uma coluna de tipo categórico que está faltando aqui. E a razão é que não é codificado como um objeto, mas como um número inteiro. A coluna 'sl_no' não é um inteiro no sentido que conhecemos. Esses candidatos são classificados em alguma ordem. Apenas uma etiqueta de nome exclusiva e o nome é como uma categoria, certo? Portanto, esta é uma variável categórica. E ele não tem nenhuma informação, então precisamos descartá-lo.

df.drop(columns="sl_no", inplace=True)

Codificação de recursos

Terminamos nossa análise e a próxima coisa que precisamos fazer é codificar nossos recursos categóricos, usarei o 'LabelEncoder'. A codificação de rótulo é uma técnica de codificação popular para lidar com variáveis ​​categóricas. Com o uso dessa técnica, cada rótulo recebe um número inteiro exclusivo com base na ordem alfabética.

lb = LabelEncoder () cat_data = ['gender', 'ssc_b', 'hsc_b', 'hsc_s', 'degree_t', 'workex', 'specialisation', 'status']
for i in cat_data: df[i] = lb.fit_transform(df[i]) df.head()

Split

Importamos e limpamos nossos dados. Fizemos um pouco de análise exploratória de dados e agora precisamos dividir nossos dados. Temos dois tipos de divisão: divisão vertical ou recursos-alvo e divisão horizontal ou conjuntos de teste de treinamento. Vamos começar com o vertical. Criaremos nossa matriz de recursos 'X' e o vetor de destino 'y'. Nosso alvo é “status”. Nossos recursos devem ser todas as colunas que permanecem no 'df.'

#vertical split
target = "status"
X = df.drop(columns = target)
y = df[target]

Os modelos geralmente funcionam melhor quando têm dados normalizados para treinar, então o que é normalização? Normalização está transformando os valores de várias variáveis ​​em um intervalo semelhante. Nosso objetivo é normalizar nossas variáveis. Portanto, seus intervalos de valor serão de 0 a 1. Vamos fazer isso e usarei o `StandardScaler.`

scaler = StandardScaler()
X = scaler.fit_transform(X)

Agora vamos fazer a divisão horizontal ou conjuntos de teste de treinamento. Precisamos dividir nossos dados (X e y) em conjuntos de treinamento e teste usando uma divisão aleatória de teste de treinamento. nosso conjunto de teste deve ser 20% de nossos dados totais. E não esquecemos de definir um random_state para reprodutibilidade.

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size = 0.2, random_state = 42 ) print("X_train shape:", X_train.shape)
print("y_train shape:", y_train.shape)
print("X_test shape:", X_test.shape)
print("y_test shape:", y_test.shape) X_train shape: (172, 12)
y_train shape: (172,)
X_test shape: (43, 12)
y_test shape: (43,)

Construir um modelo de regressão logística

Linha de Base

Portanto, agora precisamos começar a construir nosso modelo e começar a ordenar para definir nossa linha de base. Lembre-se de que o tipo de problema com o qual estamos lidando é um problema de classificação e existem diferentes métricas para avaliar os modelos de classificação. O que eu quero focar é a pontuação de precisão.

Agora, qual é a pontuação de precisão? A pontuação de precisão no aprendizado de máquina é uma métrica de avaliação que mede o número de previsões corretas feitas por um modelo em relação ao número total de previsões feitas. Nós o calculamos dividindo o número de previsões corretas pelo número total de previsões. Isso significa que a pontuação de precisão varia entre 0 e 1. Zero não é bom. É onde você não quer estar, e um é perfeito. Portanto, vamos manter isso em mente e lembrar que a linha de base é um modelo que fornece uma previsão repetidas vezes, independentemente de qual seja a observação, apenas um palpite para nós.

No nosso caso, temos duas turmas, colocadas ou não. Então, se pudéssemos fazer apenas uma previsão, qual seria nosso único palpite? Se você disse a classe da maioria. Acho que faz sentido, certo? Se pudermos ter apenas uma previsão, provavelmente devemos escolher aquela com as maiores observações em nosso conjunto de dados. Portanto, nossa linha de base usará a porcentagem que a classe majoritária mostra nos dados de treinamento. Se o modelo não está superando essa linha de base, os recursos não estão adicionando informações valiosas para classificar nossas observações.

Podemos usar o método 'value_counts' com o argumento `normalize = True` para calcular a precisão da linha de base:

acc_baseline = y_train.value_counts(normalize=True).max()
print("Baseline Accuracy:", round(acc_baseline, 2)) Baseline Accuracy: 0.68

Podemos ver que nossa precisão de linha de base é de 68% ou 0.68 como proporção. Então, para agregar valor para ser útil, queremos ficar acima desse número e chegar mais perto de um. Esse é o nosso objetivo, e agora vamos começar a construir nosso modelo.

Iterar

Agora é hora de construir nosso modelo usando regressão logística. Usaremos a regressão logística, mas antes, vamos falar um pouco sobre o que é a regressão logística e como ela funciona, e então podemos fazer o código. E para isso, aqui temos uma pequena grade.

Ao longo do eixo x, digamos que eu tenha p_degrees de candidatos em nosso conjunto de dados. E à medida que me movo da direita para a esquerda, os graus ficam cada vez mais altos e, ao longo do eixo Y, tenho as classes possíveis de posicionamento: zero e um.

Então, se fôssemos plotar nossos pontos de dados, como seria? Nossa análise mostra que um candidato com alto `p_degree` tem mais chances de ser contratado. Então, provavelmente seria mais ou menos assim, onde o candidato com um `p_degree` pequeno cairia em zero. E o candidato com um `p_degree` alto estaria em um.

Agora, digamos que queremos fazer uma regressão linear com isso. Digamos que queremos traçar uma linha.
Agora, se fizéssemos isso, o que aconteceria é que essa linha seria traçada de forma que tentasse estar o mais próximo possível de todos os pontos. Provavelmente teríamos uma linha parecida com esta. Seria este um bom modelo?

Na verdade. O que aconteceria é que, independentemente do p_degree do candidato, sempre obteríamos um tipo de valor. E isso não vai nos ajudar porque os números, nesse contexto, não significam nada. Esse problema de classificação precisa ser zero ou um. Então, não vai funcionar assim.

Por outro lado, como se trata de uma linha, e se tivermos um candidato com um p_degree muito baixo? Bem, de repente, nossa estimativa é um número negativo. E, novamente, isso não faz sentido. Não existe número negativo ou precisa ser zero ou um. E da mesma forma, se tivermos um candidato com um p_degree muito alto, posso ter um positivo, algo acima de um. E, novamente, isso não faz o menor sentido. Precisamos ter um zero ou um.

Então, o que vemos aqui são algumas limitações sérias ao uso de regressão linear para classificação. Então o que precisamos fazer? Precisamos criar um modelo que número um: não vá abaixo de zero ou acima de um, então ele precisa estar entre zero e um. E o número dois, o que quer que saia dessa função, dessa equação que criamos, talvez não devêssemos tratá-lo como a previsão em si, mas como um passo para fazer nossa previsão final.

Agora, deixe-me descompactar o que acabei de dizer, e vamos nos lembrar que quando estamos fazendo nossos modelos de regressão linear, acabamos com esta equação linear, que é a forma mais simples. E esta é aquela equação ou função que nos dá aquela linha reta.

Existe uma maneira de vincular essa linha entre 0 e 1. E o que podemos fazer é pegar essa função que acabamos de criar e colocá-la em outra função, chamada de função sigmoide.

Então, vou pegar a equação linear que acabamos de ter, e vou reduzi-la na função sigmoide e colocá-la como a exponencial.

O que acontece é que, em vez de obter uma linha reta, obtemos uma linha que se parece com esta. Está preso em um. Ele vem e rabiscos para baixo. Em seguida, ele está preso em zero.

Certo, é assim que a linha se parece, e podemos ver que resolvemos nosso primeiro problema. O que quer que saia dessa função estará entre 0 e 1. Na segunda etapa, não trataremos o que quer que saia dessa equação como a previsão final. Em vez disso, vamos tratá-lo como uma probabilidade.

O que quero dizer? Isso significa que quando faço uma previsão, obterei algum valor de ponto flutuante entre 0 e 1. E o que farei é tratá-lo como a probabilidade de que minha previsão pertença à classe positiva.

Então eu obtenho um valor de 0.9999. Direi que a probabilidade de esse candidato pertencer à nossa classe positiva é de 99%. Portanto, tenho quase certeza de que pertence à classe positiva. Por outro lado, se cair no ponto 0.001 ou qualquer outro, direi que esse número é baixo. A probabilidade de que esta observação particular pertença ao positivo, a classe colocada é quase zero. E assim, vou dizer que pertence à classe zero.

Isso faz sentido para números próximos de um ou próximos de zero. Mas você pode se perguntar: o que eu faço com outros valores intermediários? A maneira como funciona é colocarmos uma linha de corte em 0.5, então qualquer valor que eu obtiver abaixo dessa linha, colocarei em zero, então minha previsão é não, e se estiver acima dessa linha, se estiver acima do ponto cinco , Vou colocar isso na classe positiva, minha previsão é uma.

Então, agora tenho uma função que me dá uma previsão entre zero e um, e trato isso como uma probabilidade. E se essa probabilidade estiver acima de 0.5 ou 50%, eu digo, ok, classe positiva um. E se for abaixo de 50%, eu digo, é classe negativa, zero. Então é assim que a regressão logística funciona. E agora que entendemos isso, vamos codificá-lo e ajustá-lo. Vou definir o hiperparâmetro 'max_iter' para 1000. Este parâmetro refere-se ao número máximo de iterações para os solucionadores convergirem.

# Build model
model = LogisticRegression(max_iter=1000) # Fit model to training data
model.fit(X_train, y_train) LogisticRegression(max_iter=1000)

Avaliação

Agora é hora de ver como nosso modelo se sai. É hora de avaliar o modelo de Regressão Logística. Portanto, vamos lembrar que, desta vez, a métrica de desempenho em que estamos interessados ​​é a pontuação de precisão e queremos uma pontuação precisa. E queremos bater a linha de base de 0.68. A precisão do modelo pode ser calculada usando a função Accuracy_Score. A função requer dois argumentos, os rótulos verdadeiros e os rótulos previstos.

acc_train = accuracy_score(y_train, model.predict(X_train))
acc_test = model.score(X_test, y_test) print("Training Accuracy:", round(acc_train, 2))
print("Test Accuracy:", round(acc_test, 2)) Training Accuracy: 0.9
Test Accuracy: 0.88

Podemos ver nossa precisão de treinamento em 90%. Está batendo a linha de base. Nossa precisão de teste foi um pouco menor em 88%. Também superou a linha de base e ficou muito próximo da precisão do nosso treinamento. Isso é uma boa notícia porque significa que nosso modelo não está superajustado nem nada.

Resultados do Modelo de Regressão Logística

Lembre-se de que, com a regressão logística, acabamos com essas previsões finais de zero ou um. Mas por trás dessa previsão, há uma probabilidade de um número de ponto flutuante entre zero ou um e, às vezes, pode ser útil ver quais são essas estimativas de probabilidade. Vejamos nossas previsões de treinamento e vejamos as cinco primeiras. O método 'prever' prevê o alvo de uma observação não rotulada.

model.predict(X_train)[:5] array([0, 1, 1, 1, 1])

Essas foram as previsões finais, mas quais são as probabilidades por trás delas? Para obtê-los, precisamos fazer um código ligeiramente diferente. Em vez de usar o método `predict` com nosso modelo, usarei o método 'predict_proba' com nossos dados de treinamento.

y_train_pred_proba = model.predict_proba(X_train)
print(y_train_pred_proba[:5]) [[0.92003219 0.07996781] [0.03202019 0.96797981] [0.00678421 0.99321579] [0.03889446 0.96110554] [0.00245525 0.99754475]]

Podemos ver uma espécie de lista aninhada com duas colunas diferentes. A coluna da esquerda representa a probabilidade de um candidato não ser colocado ou nossa classe negativa 'Não colocado'. A outra coluna representa a classe positiva `Colocado` ou a probabilidade de um candidato ser colocado. Vamos nos concentrar na segunda coluna. Se olharmos para a primeira estimativa de probabilidade corretamente, podemos ver que é 0.07. Como está abaixo de 50%, diz nosso modelo, minha previsão é zero. E para as previsões a seguir, podemos ver que todas estão acima de 0.5, e é por isso que nosso modelo previu uma no final.

Agora queremos extrair os nomes e a importância dos recursos e colocá-los em uma série. E como precisamos exibir a importância do recurso como razões de chances, precisamos fazer apenas uma pequena transformação matemática tomando o exponencial de nossa importância.

# Features names
features = ['gender', 'ssc_p', 'ssc_b', 'hsc_p', 'hsc_b', 'hsc_s', 'degree_p' ,'degree_t', 'workex', 'etest_p', 'specialisation', 'mba_p']
# Get importances
importances = model.coef_[0]
# Put importances into a Series
odds_ratios = pd.Series(np.exp(importances), index= features).sort_values()
# Review odds_ratios.head() mba_p 0.406590
degree_t 0.706021
specialisation 0.850301
hsc_b 0.876864
etest_p 0.877831
dtype: float64

Antes de discutir as razões de chances e o que são, vamos colocá-las em um gráfico de barras horizontais. Vamos usar pandas para fazer o gráfico e lembre-se de que procuraremos os cinco maiores coeficientes. E não queremos usar todas as razões de chances. Então, queremos usar a cauda.

# Horizontal bar chart, five largest coefficients
odds_ratios.tail().plot(kind="barh")
plt.xlabel("Odds Ratio")
plt.ylabel("Feature")
plt.title("High Importance Features");

Agora eu quero que você imagine uma linha vertical bem no 5, e eu quero começar olhando para ela. Vamos falar sobre cada um deles individualmente ou apenas o primeiro casal. Então vamos começar aqui com o 'ssc_p', que se refere ao 'percentual do Ensino Secundário – 10º ano'. E podemos ver que a razão de chances é de 30. Agora, o que isso significa? Isso significa que se um candidato tem um 'ssc_p' alto, as chances de sua colocação são seis vezes maiores do que outros candidatos, todas as coisas sendo iguais. Então, outra maneira de pensar é quando o candidato tem `ssc_p`, a chance de recrutamento do candidato aumenta seis vezes.

Portanto, qualquer razão de chances acima de cinco aumenta as chances de os candidatos serem colocados. E é por isso que temos essa linha vertical em cinco. E esses cinco tipos de recursos são as características mais associadas ao aumento do recrutamento. Então, é isso que é nossa razão de chances. Agora, examinamos os recursos mais associados a um aumento no recrutamento. Vejamos as características que lhe estão associadas, a diminuição do recrutamento. Então agora é hora de olhar para os menores. Então, em vez de olhar para a cauda, ​​vamos olhar para ela.

odds_ratios.head().plot(kind="barh")
plt.xlabel("Odds Ratio")
plt.xlabel("Odds Ratio")
plt.ylabel("Feature")
plt.title("Low Importance Features");

A primeira coisa que precisamos ver aqui é que observe que no eixo x tudo é um ou abaixo. Agora, o que isso significa? Então, vamos dar uma olhada em nossa menor razão de chances aqui. É mba_p que se refere à porcentagem de MBA. Podemos ver que está pronto em cerca de 0.45. Agora, o que isso significa? Bem, a diferença entre 0.45 e 1 é 0.55. Tudo bem? E o que significa esse número? Os candidatos com MBA têm menos probabilidade de serem recrutados em 55%, todas as outras coisas sendo iguais. Tudo bem? Portanto, diminuiu as chances de recrutamento por um fator de 0.55 ou 55%. E isso é verdade para tudo aqui.

Conclusão

Então, o que aprendemos? Primeiramente, na fase de preparação de dados, aprendemos que estamos trabalhando com classificação, especificamente classificação binária, usando Regressão Logística. Em termos de exploração dos dados, fizemos um monte de coisas, mas em termos de destaques, olhamos para o equilíbrio das classes, certo? A proporção de nossas classes positivas e negativas. Em seguida, dividimos nossos dados.

Como a regressão logística é um modelo de classificação, aprendemos sobre uma nova métrica de desempenho, a pontuação de precisão. Agora, a pontuação de precisão varia entre 0 e 1. Zero é ruim e um é bom. Quando estávamos iterando, aprendemos sobre regressão logística. Essa é uma maneira mágica, onde você pode pegar uma equação linear, uma linha reta, e colocá-la dentro de outra função, uma função sigmoide e uma função de ativação, e obter uma estimativa de probabilidade dela e transformar essa estimativa de probabilidade em previsão.

Por fim, aprendemos sobre a razão de chances e a maneira como podemos interpretar os coeficientes para ver se uma determinada característica aumentará as chances de termos recrutado um candidato ou não.

Código fonte do projeto: https://github.com/SawsanYusuf/Campus-Recruitment.git

A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do Autor. 

Relacionado

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• Platoblockchain. Inteligência Metaverso Web3. Conhecimento Ampliado. Acesse aqui.
• Fonte: https://www.analyticsvidhya.com/blog/2023/03/campus-recruitment-a-classification-problem-with-logistic-regression/