<jupyter_start><jupyter_text>Parte 1: Análise Exploratória  Distribuição por Categoria<jupyter_code>plt.figure(figsize=(8,4))
sb.countplot(y="obito", data=df_train)<jupyter_output><empty_output><jupyter_text>Distribuição por Idade da Mãe<jupyter_code>g = sb.displot(data=df_train, x="idademae", hue="obito", col="obito")
g.fig.set_figwidth(10)
g.fig.set_figheight(5)<jupyter_output><empty_output><jupyter_text>Distribuição por Estado Civil da Mãe<jupyter_code>sb.catplot(data=df_train, x="estadocivilmae", hue="obito", col="obito", kind="count")<jupyter_output><empty_output><jupyter_text>Distribuição por Quantidade de Consultas de Pré-Natal Realizadas<jupyter_code>sb.catplot(data=df_train, x="catprenatal", hue="obito", col="obito", kind="count")<jupyter_output><empty_output><jupyter_text>Distribuição por Quantidade de Semanas de Gestação<jupyter_code>g = sb.displot(data=df_train, x="qtdsemanas", hue="obito", col="obito")
g.fig.set_figwidth(10)
g.fig.set_figheight(4)<jupyter_output><empty_output><jupyter_text>Distribuição por Tipo de Parto<jupyter_code>sb.catplot(data=df_train, x="tipoparto", hue="obito", kind="count")<jupyter_output><empty_output><jupyter_text>Distribuição por Peso do Bebê<jupyter_code>g = sb.displot(data=df_train, x="peso", hue="obito", col="obito")
g.fig.set_figwidth(12)
g.fig.set_figheight(5)<jupyter_output><empty_output><jupyter_text>Distribuição por Malformação<jupyter_code>sb.catplot(data=df_train, x="malformacao", hue="obito", kind="count")<jupyter_output><empty_output><jupyter_text>Nota do Apgar 1 vs. Óbitos<jupyter_code>plt.figure(figsize=(10,5))
sb.histplot(data=df_train, x="apgar1", hue="obito", multiple="stack")<jupyter_output><empty_output><jupyter_text>Nota do Apgar 5 vs. Óbitos<jupyter_code>plt.figure(figsize=(10,5))
sb.histplot(data=df_train, x="apgar5", hue="obito", multiple="stack")<jupyter_output><empty_output><jupyter_text>Distribuição por Sexo do Bebê<jupyter_code>sb.catplot(data=df_train, x="sexo", hue="obito", kind="count")<jupyter_output><empty_output><jupyter_text>Matriz de Correlação - Atributos Numéricos<jupyter_code>corr_df = df_train.corr(method='pearson')

plt.figure(figsize=(8, 6))
sb.heatmap(corr_df, annot=True, cmap='Greens')
plt.show()<jupyter_output><empty_output><jupyter_text>Parte 2: Pré-processamento  2.1 Tratamento de Valores Faltantes (Missing) ***Quantidade de registros nos datasets***<jupyter_code>df_train.shape
df_test.shape<jupyter_output><empty_output><jupyter_text>***Quantidade de valores nulos por coluna do dataset***<jupyter_code>df_train.isnull().sum()
df_test.isnull().sum()<jupyter_output><empty_output><jupyter_text>Atributos categóricos *TÉCNICA ESCOLHIDA -> Substituição pelo valor que mais aparece (Moda)* ***Atributo: Estado civil da mãe***<jupyter_code>df_train["estadocivilmae"].fillna(df_train["estadocivilmae"].mode()[0], inplace=True)
df_test["estadocivilmae"].fillna(df_test["estadocivilmae"].mode()[0], inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Quantidade de consultas de Pré-Natal realizadas***<jupyter_code>df_train["catprenatal"].fillna(df_train["catprenatal"].mode()[0], inplace=True)
df_test["catprenatal"].fillna(df_test["catprenatal"].mode()[0], inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Tipo do parto***<jupyter_code>df_train["tipoparto"].fillna(df_train["tipoparto"].mode()[0], inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Malformação***<jupyter_code>df_train["malformacao"].fillna(df_train["malformacao"].mode()[0], inplace=True)
df_test["malformacao"].fillna(df_test["malformacao"].mode()[0], inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Sexo do bebê***<jupyter_code>df_train["sexo"].fillna(df_train["sexo"].mode()[0], inplace=True)
df_test["sexo"].fillna(df_test["sexo"].mode()[0], inplace=True)<jupyter_output><empty_output><jupyter_text>Atributos numéricos *TÉCNICA ESCOLHIDA -> Substituição pela melhor métrica entre Moda, Média ou Mediana* ***Atributo: Idade da mãe -> Mediana***<jupyter_code>sb.boxplot(x=df_test["idademae"], 
           showfliers=False, 
           color="blue",
           showmeans=True, 
           meanprops={"marker":"o",
                       "markerfacecolor":"yellow", 
                       "markeredgecolor":"black",
                      "markersize":"10"})
df_test["idademae"].fillna(df_test["idademae"].median(), inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Quantidade de semanas de gestação -> Mediana***<jupyter_code>sb.boxplot(x=df_train["qtdsemanas"], 
           showfliers=False, 
           color="green",
           showmeans=True, 
           meanprops={"marker":"o",
                       "markerfacecolor":"yellow", 
                       "markeredgecolor":"black",
                      "markersize":"10"})
df_train["qtdsemanas"].fillna(df_train["qtdsemanas"].median(), inplace=True)
df_test["qtdsemanas"].fillna(df_test["qtdsemanas"].median(), inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Peso do bebê -> Média***<jupyter_code>sb.boxplot(x=df_train["peso"], 
           showfliers=False, 
           color="purple",
           showmeans=True, 
           meanprops={"marker":"o",
                       "markerfacecolor":"yellow", 
                       "markeredgecolor":"black",
                      "markersize":"10"})
df_train["peso"].fillna(df_train["peso"].mean(), inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Nota Apgar 1 -> Média***<jupyter_code>sb.boxplot(x=df_train["apgar1"], 
           showfliers=False, 
           color="red",
           showmeans=True, 
           meanprops={"marker":"o",
                       "markerfacecolor":"yellow", 
                       "markeredgecolor":"black",
                      "markersize":"10"})
df_train["apgar1"].fillna(df_train["apgar1"].mean(), inplace=True)
df_test["apgar1"].fillna(df_test["apgar1"].mean(), inplace=True)<jupyter_output><empty_output><jupyter_text>***Atributo: Nota Apgar 5 -> Média***<jupyter_code>sb.boxplot(x=df_train["apgar5"], 
           showfliers=False, 
           color="orange",
           showmeans=True, 
           meanprops={"marker":"o",
                       "markerfacecolor":"yellow", 
                       "markeredgecolor":"black",
                      "markersize":"10"})
df_train["apgar5"].fillna(df_train["apgar5"].mean(), inplace=True)
df_test["apgar5"].fillna(df_test["apgar5"].mean(), inplace=True)
df_train.isnull().sum()
df_test.isnull().sum()<jupyter_output><empty_output><jupyter_text>2.2 Tratamento de Valores Discrepantes (Outliers) *TÉCNICA ESCOLHIDA -> Nenhuma* \*MOTIVO -> Não foi verificado nenhum valor fora do domínio para nenhum dos atributos numéricos. Não é possível saber se os valores mínimos e máximos foram erros ou se realmente ocorreram, portanto não serão excluídos os registros com tais valores*<jupyter_code>df_train.describe()
print(df_train.sort_values('idademae', ascending=False).head(10)['idademae'])
print(df_train.sort_values('idademae', ascending=True).head(10)['idademae'])
print(df_train.sort_values('qtdsemanas', ascending=False).head(10)['qtdsemanas'])
print(df_train.sort_values('qtdsemanas', ascending=True).head(10)['qtdsemanas'])
print(df_train.sort_values('peso', ascending=False).head(10)['peso'])
print(df_train.sort_values('peso', ascending=True).head(10)['peso'])<jupyter_output>3262     150.0
5709     160.0
6804     175.0
3223     180.0
8611     190.0
10165    230.0
4011     230.0
7179     247.0
1829     275.0
10108    280.0
Name: peso, dtype: float64<jupyter_text>2.3 Transformação de Dados  Removendo coluna de identificação dos registros<jupyter_code>df_train = df_train.drop(columns=['id'])
df_test = df_test.drop(columns=['id'])<jupyter_output><empty_output><jupyter_text>Transformando atributos categóricos em numéricos<jupyter_code>df_train = pd.get_dummies(df_train, drop_first=True)
df_train.head()
df_test = pd.get_dummies(df_test, drop_first=True)
df_test.head()<jupyter_output><empty_output><jupyter_text>Redimensionando os dados *TÉCNICA ESCOLHIDA -> Normalização* \*DESCRIÇÃO -> Coloca todos os valores na escala entre 0 e 1* \*MOTIVO -> Menos sensível a outliers*<jupyter_code>from sklearn import preprocessing
df_train_norm = pd.DataFrame(preprocessing.MinMaxScaler().fit_transform(df_train.values))
df_test_norm = pd.DataFrame(preprocessing.MinMaxScaler().fit_transform(df_test.values))
df_train_norm
df_test_norm<jupyter_output><empty_output><jupyter_text>Parte 3: Aprendizado de máquina  3.1 Separando atributos (X) da variável alvo (y)<jupyter_code>X = df_train_norm.drop(5, axis=1).values
y = df_train_norm[5].values
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)<jupyter_output><empty_output><jupyter_text>3.2 Balanceamento das classes *TÉCNICA ESCOLHIDA -> Undersampling* \*DESCRIÇÃO -> Seleção aleatória de elementos da classe majoritária* \*MOTIVO -> A técnica oposta (oversampling) requer maior processamento e gera dados que não são reais*<jupyter_code>from imblearn.under_sampling import RandomUnderSampler, NearMiss, OneSidedSelection

# Random Undersampler
rus = RandomUnderSampler(random_state = 42)
X_rus_res, y_rus_res = rus.fit_resample(X_train, y_train)

# NearMiss
nm = NearMiss(version=1)
X_nm_res, y_nm_res = nm.fit_resample(X_train, y_train)

# OneSidedSelection (Algoritmo tipo KNN)
oss = OneSidedSelection(random_state = 42)
X_oss_res, y_oss_res = oss.fit_resample(X_train, y_train)<jupyter_output><empty_output><jupyter_text>3.3 Criação dos modelos<jupyter_code>from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
models = []
models.append(('LR', LogisticRegression()))
models.append(('CART', DecisionTreeClassifier()))
models.append(('KNN', KNeighborsClassifier()))
models.append(('NB', GaussianNB()))
models.append(('SVM', SVC()))<jupyter_output><empty_output><jupyter_text>3.4 Treino com Validação Cruzada *Melhores Resultados: Navie Bayes com Random UnderSampler*<jupyter_code>from sklearn.model_selection import cross_validate
np.random.seed(42)
names = []
results_rus = []
results_nm = []
results_oss = []

for name, model in models:
    rus = cross_validate(model, X_rus_res, y_rus_res, cv=10, scoring='accuracy')
    nm = cross_validate(model, X_nm_res, y_nm_res, cv=10, scoring='accuracy')
    oss = cross_validate(model, X_oss_res, y_oss_res, cv=10, scoring='accuracy')
    results_rus.append(rus['test_score'])
    results_nm.append(nm['test_score'])
    results_oss.append(oss['test_score'])
    names.append(name)
fig = plt.figure()
fig.suptitle('Comparação dos Modelos - RUS')
ax = fig.add_subplot(111)
plt.boxplot(results_rus)
ax.set_xticklabels(names)
plt.show()
fig = plt.figure()
fig.suptitle('Comparação dos Modelos - NM')
ax = fig.add_subplot(111)
plt.boxplot(results_nm)
ax.set_xticklabels(names)
plt.show()
fig = plt.figure()
fig.suptitle('Comparação dos Modelos - OSS')
ax = fig.add_subplot(111)
plt.boxplot(results_nm)
ax.set_xticklabels(names)
plt.show()<jupyter_output><empty_output><jupyter_text>3.5 Ajuste do melhor modelo *TÉCNICA ESCOLHIDA -> Acurácia* \*MOTIVO -> Avaliar o percentual de acertos na classificação*<jupyter_code>#param_grid = {'C': [0.1,1, 10, 100], 'gamma': [1,0.1,0.01,0.001],'kernel': ['rbf', 'poly', 'sigmoid']}
param_grid_nb = {
    'var_smoothing': np.logspace(0,-9, num=100)
}

from sklearn.model_selection import GridSearchCV
nbModel_grid = GridSearchCV(estimator=models[3][1], param_grid=param_grid_nb, verbose=1, cv=10, n_jobs=-1)
nbModel_grid.fit(X_rus_res, y_rus_res)
print(nbModel_grid.best_estimator_)
y_pred = nbModel_grid.predict(X_test)
from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sb.heatmap(cm, annot=True, fmt='g', cmap='Blues')
plt.title('Matriz de Confusão')
plt.ylabel('Classe verdadeira')
plt.xlabel('Classe predita')
print("Relatório de Classificação:\n", classification_report(y_test, y_pred, digits=2))<jupyter_output>Relatório de Classificação:
               precision    recall  f1-score   support

         0.0       0.93      0.95      0.94      2530
         1.0       0.86      0.79      0.83       887

    accuracy                           0.91      3417
   macro avg       0.90      0.87      0.88      3417
weighted avg       0.91      0.91      0.91      3417<jupyter_text>Parte 4: Avaliação<jupyter_code>X_final = df_test_norm.values
y_final = nbModel_grid.predict(X_final)
y_final
y_final_proba = nbModel_grid.predict_proba(X_final)
y_final_proba = np.round(y_final_proba, 4)
y_final_proba
df_final = pd.read_csv("teste.csv")
df_final.head()
df_final['obito'] = y_final_proba[:,1]
df_final.head()
df_final.to_csv('submission_danielle.csv')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1432321828430237, 'fraction_numerical': 0.022855377963091655, 'mean_word_length': 5.963440860215054, 'pattern_counts': {'":': 20, '<': 135, '<?xml version=': 0, '>': 152, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '34', 'dir': 'jupyter-structured-clean-dedup', 'id': '618568', 'license': 'MIT', 'n_tokens_mistral': 5140, 'n_tokens_neox': 4857, 'n_words': 714, 'path': 'md-kaggle-danielle.ipynb', 'repo_name': 'daniellealmeidagms/child-mortality-brazil-kaggle', 'size': '12951'}