Empregabilidade — Como foi feito (explicado fácil)
Pensa numa professora que, depois de 20 anos de sala de aula, "bate o olho" no aluno e fala: "esse aí vai se dar bem". Ela aprendeu padrões. Machine Learning é ensinar um computador a fazer isso — só que com 10.000 alunos e matemática no lugar do feeling.
O que é isso, em uma frase?
É um modelo de IA que olha pro histórico de um aluno (notas, frequência, estágios, idade) e responde uma pergunta de SIM/NÃO: "esse aluno vai conseguir se colocar no mercado?". Trabalhei com 10.000 alunos reais.
Isso é o que chamam de classificação binária: a IA só pode dar duas respostas — colocado ou não colocado. O objetivo não é mágica futurista; é priorização: a faculdade descobre cedo quem precisa de mais apoio (mentoria, monitoria, encaminhamento pra estágio) e age antes de perder o aluno.
Por que importa? Porque "ajudar todo mundo igualmente" não funciona. Recurso é finito. O modelo ajuda a apontar onde a ajuda rende mais.
Como ensinar a IA a prever
1 · Conhecer os dados (EDA). Antes de qualquer modelo, eu olho os dados. Quantas colunas? Tem campo vazio? Quantos alunos colocados vs não colocados? Se o dataset tiver 95% de "colocado", o modelo aprende a chutar "sim" sempre e parece bom — mas não é.
import pandas as pd
df = pd.read_csv("student_dataset_10000_rows.csv")
print(df.shape) # (10000, 11)
print(df.isnull().sum()) # quantos NaN por coluna
print(df["placed"].value_counts(normalize=True)) # proporção colocado/não
2 · Preparar os dados. Computador não entende "Masculino"/"Feminino" — só números. Então transformo texto em número (encoding) e ajusto escalas (idade vai de 18-30, nota vai de 0-10; sem ajuste, a "idade" pesa mais só porque tem número maior).
from sklearn.preprocessing import LabelEncoder, StandardScaler
# texto → número
for col in ["gender", "stream", "internship"]:
df[col] = LabelEncoder().fit_transform(df[col])
# escalas equilibradas
scaler = StandardScaler()
X = scaler.fit_transform(df.drop("placed", axis=1))
y = df["placed"]
3 · Separar treino e teste. Aqui mora a regra de ouro: o modelo só pode ser avaliado com dados que ele nunca viu. Senão é igual aluno que decorou o gabarito — vai bem na prova, mal na vida. Separo 80% pra treinar e 20% guardo "fechado num cofre" pra testar depois.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y,
test_size=0.2,
random_state=42,
stratify=y # mantém proporção de "colocados" igual nos dois conjuntos
)
4 · Testar vários modelos. Não tem "o melhor modelo do mundo" — depende do problema. Testei vários e comparei: KNN (vizinhos parecidos), Árvore de Decisão (sequência de "se/então"), Random Forest (várias árvores votando) e XGBoost (árvores corrigindo erros umas das outras, geralmente o campeão).
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
modelos = {
"Random Forest": RandomForestClassifier(n_estimators=200, random_state=42),
"XGBoost": XGBClassifier(n_estimators=200, random_state=42),
}
for nome, modelo in modelos.items():
modelo.fit(X_train, y_train)
pred = modelo.predict(X_test)
print(nome, "F1:", f1_score(y_test, pred))
5 · Medir certo (não só "acertou %"). Acurácia engana em dataset desbalanceado. Uso F1-score, que equilibra precisão (dos que disse "vai colocar", quantos colocaram mesmo?) e recall (dos que de fato colocaram, quantos o modelo pegou?). O modelo final ficou com F1 ≈ 0,99 no conjunto-teste.
| métrica | resultado |
|---|---|
| Acurácia | ≈ 99% |
| F1-score | ≈ 0,99 |
| Conjunto de teste | 2.000 alunos (20%) |
6 · Olhar quais variáveis mais "pesaram". Modelos de árvore mostram a importância de cada feature. Histórico acadêmico, estágios anteriores e área de atuação foram os mais relevantes — confirma a intuição.
O que o modelo aprendeu
Em uma linha: o que esse projeto ensina
Que preparar dado é 80% do trabalho. O modelo é a parte glamourosa, mas o que decide o resultado é encoding, escalonamento, separação treino/teste e escolha da métrica certa. Aprender ML é, na prática, aprender essas decisões.
Coisas técnicas que apareceram aqui: EDA com pandas, encoding (LabelEncoder), normalização (StandardScaler), train/test split estratificado, comparação de modelos (KNN, Random Forest, XGBoost), métricas para classe desbalanceada (F1, matriz de confusão), feature importance.