12 Exercícios
12.1 Exercício 1 — Panorama de Decisões
Uma autoridade do Tribunal de Justiça de São Paulo (TJSP) solicitou um relatório preliminar que apresente um panorama geral das decisões proferidas nas Câmaras Criminais.
O objetivo é compreender a distribuição das decisões conforme o tipo de provimento concedido — se os recursos foram negados, providos, parcialmente providos ou se houve extinção da punibilidade.
Esse levantamento servirá como base para um estudo comparativo futuro entre o TJSP e outros tribunais estaduais, buscando identificar possíveis padrões de julgamento e variações na aplicação de precedentes.
Utilizando a base de dados camaras, elabore um resumo quantitativo das decisões, agrupando-as por tipo de decisão.
Use camaras["decisao"].value_counts() para contar quantas vezes cada tipo de decisão aparece na base.
Depois de obter a contagem, transforme o resultado em um DataFrame usando .reset_index(name="qtd_decisoes")
e renomeie a coluna "index" para "decisao" com: total_decisoes = total_decisoes.rename(columns={"index": "decisao"}).
Por fim, use .reset_index(drop=True) para garantir que os índices fiquem limpos antes de retornar o DataFrame.
total_decisoes = camaras["decisao"].value_counts().reset_index(name="qtd_decisoes")
total_decisoes = total_decisoes.rename(columns={"index": "decisao"})
total_decisoes12.1.1 Exercício 1.1 — Visualização do Panorama de Decisões
A autoridade responsável avaliou o relatório preliminar e solicitou que os resultados fossem apresentados de forma mais visual, para facilitar a compreensão em reuniões e apresentações públicas.
Ela pediu que você represente graficamente a quantidade de decisões por tipo de provimento, a fim de destacar de maneira intuitiva quais tipos de decisão são mais comuns.
Com base no DataFrame total_decisoes, elabore um gráfico de barras horizontais que mostre a quantidade de decisões em cada categoria.
O DataFrame total_decisoes já contém as colunas decisao e qtd_decisoes.
Use sns.barplot() para representar visualmente os valores.
Defina y="decisao" e x="qtd_decisoes" para gerar um gráfico de barras horizontais.
A cor pode ser escolhida com color="royalblue".
sns.barplot(
data=total_decisoes,
y="decisao",
x="qtd_decisoes",
color="royalblue"
)
plt.title("Distribuição das Decisões por Tipo de Provimento", fontsize=12)
plt.xlabel("Quantidade de Decisões")
plt.ylabel("Tipo de Decisão")
plt.tight_layout()
plt.show()A visualização de dados é uma ferramenta poderosa para a gestão judiciária e para a pesquisa empírica do Direito. Gráficos simples podem revelar padrões que passam despercebidos em planilhas — como a frequência de negativas de provimento ou a raridade de determinadas decisões.
12.2 Exercício 2 — Distribuição de Decisões por Câmara
Em seguida, vamos supor que a mesma autoridade tenha solicitado uma análise complementar com o objetivo de verificar a quantidade de decisões proferidas por cada Câmara do Tribunal de Justiça de São Paulo (TJSP).
Como essa apresentação será encaminhada para um congresso dedicado ao estudo da distribuição de decisões entre as Câmaras, optou-se por representar os resultados em formato gráfico, de modo a proporcionar uma visualização mais clara, comparativa e intuitiva do volume de decisões analisadas.
Utilizando a base camaras, elabore um gráfico de barras que mostre a quantidade total de decisões por Câmara (camara).
Use value_counts() para contar quantas decisões há em cada Câmara.
Para visualizar, use sns.barplot() com x='qtd_decisoes', y='camara' e uma cor (color='royalblue').
total_decisoes_por_camara = camaras["camara"].value_counts().reset_index(name="qtd_decisoes")
sns.barplot(data=total_decisoes_por_camara, y="camara", x="qtd_decisoes", color="royalblue")
plt.title("Decisões por Câmara")
plt.xlabel("Quantidade")
plt.ylabel("Câmara")
plt.tight_layout()
plt.show()A realização desse tipo de análise é especialmente relevante para o profissional do Direito, porque promove uma compreensão empírica e quantitativa da atuação jurisdicional.
Ao examinar a distribuição de decisões entre as Câmaras, o operador do Direito pode identificar padrões de produtividade, especialização e volume de demandas — elementos essenciais para a gestão judiciária eficiente e para o aperfeiçoamento das políticas públicas de justiça.
12.3 Exercício 3 — Padrão Decisório Comparado
Uma equipe de pesquisa da Escola da Magistratura está conduzindo um estudo sobre padrões de decisão entre diferentes relatores das Câmaras Criminais do TJSP.
O objetivo é verificar se existem diferenças perceptíveis no comportamento decisório de magistrados — por exemplo, se um relator tende a negar mais recursos do que outro, ou se há maior propensão a decisões parcialmente providas.
Para iniciar o estudo, a equipe selecionou dois relatores com grande volume de decisões no acervo:
- Mário Devienne Ferraz
- Alberto Anderson Filho
O foco é comparar o perfil decisório desses dois magistrados quanto à variável “decisão”, que representa o resultado do julgamento do recurso.
Filtre a base camaras para manter somente as decisões proferidas pelos relatores acima e salvar o resultado em rel_comparacao e utilize o Seaborn para criar um gráfico de barras horizontais que compare a quantidade de decisões de cada tipo (DECISAO) entre os dois relatores.
A ideia é gerar barras agrupadas por DECISAO com hue indicando o RELATOR.
Crie uma lista com os dois nomes de relatores e use query('RELATOR == @rel_comparacao') para filtrar a base.
Para o gráfico, use sns.countplot() e mapeie y='RELATOR', hue='DECISAO' e palette='flare'.
rel_comparacao_nomes = ['MÁRIO DEVIENNE FERRAZ', 'ALBERTO ANDERSON FILHO']
rel_comparacao = camaras_upper[camaras_upper['RELATOR'].isin(rel_comparacao_nomes)]
sns.countplot(
data=rel_comparacao,
y='RELATOR',
hue='DECISAO',
palette='flare'
)
plt.title("Padrão Decisório Comparado — TJSP", fontsize=12)
plt.xlabel("Quantidade de Decisões")
plt.ylabel("Relator")
plt.tight_layout()
plt.show()Comparar padrões decisórios entre relatores é uma técnica frequentemente utilizada em estudos de Direito e Tecnologia.
Essa abordagem permite investigar a consistência e previsibilidade das decisões judiciais, bem como discutir o papel da subjetividade judicial no contexto dos tribunais.
12.4 Exercício 4 — Idade x Padrão Decisório
Dando sequência ao estudo desenvolvido pela equipe de pesquisa em Direito e Ciência de Dados, que vem atendendo às solicitações de uma autoridade do Tribunal de Justiça de São Paulo (TJSP), surge uma nova questão de interesse.
Após observar diferenças de comportamento entre relatores nas análises anteriores, a equipe foi instigada a investigar se a idade dos magistrados pode estar relacionada ao tipo de decisão proferida.
A hipótese é de que relatores mais experientes — e, portanto, com maior idade — possam apresentar tendências distintas em relação à concessão ou negação de recursos.
O objetivo deste exercício é verificar se há alguma correlação entre a idade dos relatores e o padrão de decisões proferidas.
Crie tabelas que permitam comparar a idade dos relatores com a quantidade de decisões de cada tipo.
A autoridade do TJSP solicitou que a equipe apresentasse uma visualização gráfica que pudesse indicar se existe relação entre a idade dos relatores e o número de decisões negativas (“Negaram”).
O objetivo é observar possíveis tendências etárias no comportamento decisório das Câmaras Criminais.
Crie uma tabela com o número de decisões de cada tipo por relator.
Crie outra tabela com a idade de cada relator (rel_idade).
Faça um merge das duas tabelas, resultando em decisoes_idade.
Elabore um gráfico de dispersão (sns.scatterplot) mostrando rel_idade (x) versus o número de decisões “Negaram” (y).
Use groupby(['relator','decisao']).size().unstack(fill_value=0) para montar a tabela de decisões por relator.
Para associar a idade de cada relator, remova duplicatas (drop_duplicates('relator')) e selecione ['relator','rel_idade'].
Depois, use pd.merge() para juntar as duas tabelas e gere o gráfico de dispersão (sns.scatterplot).
# TABELA DE TIPO DE DECISÕES POR RELATOR
decisoes_relator = camaras.groupby(['relator', 'decisao']).size().unstack(fill_value=0)
# Capitaliza os nomes das colunas para garantir "Negaram"
decisoes_relator.columns = [c.capitalize() for c in decisoes_relator.columns]
decisoes_relator = decisoes_relator.reset_index()
# TABELA DE IDADES POR RELATOR
idade_relator = camaras.drop_duplicates('relator')[['relator', 'rel_idade']]
# JUNÇÃO DA IDADE COM AS DECISÕES
decisoes_idade = pd.merge(decisoes_relator, idade_relator, on='relator')
# Converte idade para numérico
decisoes_idade['rel_idade'] = pd.to_numeric(decisoes_idade['rel_idade'], errors='coerce')
# GRÁFICO DE DISPERSÃO
if 'Negaram' in decisoes_idade.columns:
sns.scatterplot(data=decisoes_idade, x='rel_idade', y='Negaram')
plt.title("Relação entre Idade e Decisões Negativas (TJSP)")
plt.xlabel("Idade do Relator")
plt.ylabel("Número de Decisões 'Negaram'")
plt.tight_layout()
plt.show()
else:
print("⚠️ Coluna 'Negaram' não encontrada. Colunas:", decisoes_idade.columns.tolist())12.5 Exercício 5 — Idade x Tempo de Magistratura
Dando prosseguimento ao estudo conduzido pela equipe de pesquisa em Direito e Ciência de Dados, que tem elaborado relatórios analíticos para uma autoridade do Tribunal de Justiça de São Paulo (TJSP), o grupo decidiu agora examinar a relação entre a idade dos relatores e o tempo de magistratura.
A intenção é compreender se existe correlação entre essas duas variáveis — o que pode ajudar a validar os dados coletados e oferecer um retrato mais preciso do perfil dos julgadores que atuam nas Câmaras Criminais.
Selecione apenas uma linha por relator, contendo suas informações de idade (rel_idade) e tempo de magistratura (rel_tempo_magistratura).
Crie um gráfico de dispersão (sns.scatterplot), em que:
- o eixo x representa a idade (rel_idade);
- o eixo y representa o tempo de magistratura (rel_tempo_magistratura).
O objetivo é verificar visualmente se existe correlação positiva entre idade e tempo de magistratura — hipótese que validaria a consistência dos dados.
Use drop_duplicates('relator') para garantir apenas uma linha por relator no DataFrame.
Monte o gráfico com sns.scatterplot(), definindo x='rel_idade' e y='rel_tempo_magistratura'.
Isso criará um gráfico de dispersão que permite observar a correlação entre idade e tempo de carreira.
relatores = camaras.drop_duplicates('relator')[['relator', 'rel_idade', 'rel_tempo_magistratura']]
# Converte para numérico
relatores['rel_idade'] = pd.to_numeric(relatores['rel_idade'], errors='coerce')
relatores['rel_tempo_magistratura'] = pd.to_numeric(relatores['rel_tempo_magistratura'], errors='coerce')
sns.scatterplot(
data=relatores,
x='rel_idade',
y='rel_tempo_magistratura'
)
plt.title("Correlação entre Idade e Tempo de Magistratura (TJSP)", fontsize=12)
plt.xlabel("Idade do Relator")
plt.ylabel("Tempo de Magistratura (anos)")
plt.tight_layout()
plt.show()A análise da correlação entre idade e tempo de magistratura permite não apenas validar a qualidade dos dados, mas também compreender melhor o perfil dos magistrados que compõem as Câmaras Criminais.
Essa investigação pode revelar padrões de progressão na carreira e oferecer subsídios para políticas de formação continuada e gestão de recursos humanos no Poder Judiciário.
12.6 Exercício 6 — Preparação da Base Vivo
Imagine que você foi contratado para integrar o time jurídico contencioso da Vivo, responsável por analisar e acompanhar milhares de ações judiciais movidas contra a empresa em todo o país. Seu papel será auxiliar na criação de indicadores e modelos preditivos capazes de antecipar os riscos e custos dessas demandas.
Antes de iniciar as análises, a equipe de dados da Vivo notificou que foram encontradas algumas inconsistências na base de dados, que precisam ser corrigidas para garantir a confiabilidade dos resultados.
Para esta primeira etapa, seu objetivo é preparar a base de dados de modo que ela contenha apenas as informações relevantes e completas para os casos em que já se conhece o desfecho da Vivo (isto é, se a empresa ganhou ou perdeu a ação).
Faça o filtro da base de dados para conter apenas as linhas correspondentes à vitória ou derrota da Vivo e remova as linhas com valores ausentes nas variáveis juiz_tempo_vara, pags_inicial e pags_contestacao. Em seguida, informe quantas linhas restaram na base de dados após esses filtros.
Para filtrar a coluna desfecho_vivo, você pode criar uma lista com os dois valores desejados (['Vitória', 'Derrota (Total ou Parcial)']) e usar o método .isin(lista) para selecionar as linhas.
Use .dropna(subset=[...]) para remover linhas com valores nulos apenas nas colunas especificadas. Para obter a contagem final de linhas, use a função len(seu_dataframe)
vivo_filtrado = vivo[vivo['desfecho_vivo'].isin(['Vitória', 'Derrota (Total ou Parcial)'])]
vivo_filtrado = vivo_filtrado.dropna(subset=['juiz_tempo_vara', 'pags_inicial', 'pags_contestacao'])
qtd_linhas = len(vivo_filtrado)
qtd_linhasA qualidade dos dados (data quality) é a etapa mais crítica em qualquer projeto de Jurimetria. Modelos preditivos construídos sobre bases de dados “sujas” (com valores ausentes, duplicados ou inconsistentes) geram previsões não confiáveis.
No contexto corporativo, isso pode levar o escritório a tomar decisões estratégicas erradas, como provisionar valores incorretos para perdas, subestimar custos processuais ou perder oportunidades valiosas de acordo
12.7 Exercício 7 — Criação da Variável de Desfecho da Vivo
Após a etapa inicial de limpeza dos dados, o time de dados da Vivo solicitou uma nova verificação. Durante o desenvolvimento do painel de acompanhamento de resultados judiciais, a equipe percebeu que não havia uma variável numérica que identificasse, de forma padronizada, se a decisão foi favorável ou desfavorável à empresa.
Para possibilitar análises estatísticas e a futura construção de modelos preditivos, o jurídico analítico pediu que você criasse uma nova coluna chamada y, que receba o valor 1 quando a decisão for favorável à Vivo e 0 caso contrário.
Com base nessa nova variável, calcule também a proporção de decisões favoráveis à Vivo na base de dados. Essa métrica servirá como indicador preliminar de desempenho da empresa no contencioso.
Crie a coluna y no DataFrame vivo (onde 1 = ‘Vitória’ e 0 para os demais casos). Em seguida, calcule a proporção de vitórias e armazene o resultado na variável proporcao_vitorias.
Para criar a nova coluna y de forma condicional, a função np.where() (do NumPy) é ideal. A sintaxe é: np.where(condição, valor_se_verdadeiro, valor_se_falso)
Depois de criar a coluna y (que contém apenas 1s e 0s), a proporção de vitórias é simplesmente a média dessa coluna. Você pode calcular isso usando o método .mean().
# 1. Criar a variável 'y'
vivo['y'] = np.where(vivo['desfecho_vivo'] == 'Vitória', 1, 0)
# 2. Calcular a proporção de vitórias
proporcao_vitorias = vivo['y'].mean()
proporcao_vitoriasTransformar resultados categóricos (como “Vitória” ou “Derrota”) em variáveis numéricas binárias (1 ou 0) é um passo fundamental em machine learning. Isso permite que algoritmos matemáticos, que não entendem texto, possam processar e modelar desfechos.
A proporção de vitórias (a média da coluna y) é uma métrica crucial. Ela é conhecida como taxa de base (ou baseline). Qualquer modelo preditivo futuro que construir só será útil se conseguir prever os resultados com uma acurácia maior do que essa taxa de base.
12.8 Exercício 8 — Criação de Variáveis Dummies para o Juiz
Após as etapas iniciais de limpeza e estruturação dos dados, o time jurídico-analítico da Vivo começou a planejar a construção de modelos estatísticos para prever o desfecho dos processos.
Durante as reuniões técnicas, os analistas de dados destacaram que, para aplicar técnicas de regressão logística e outros modelos de classificação, é necessário transformar variáveis categóricas em valores numéricos.
Uma das variáveis que precisam ser tratadas é a que identifica o juiz responsável pelo processo. Cada magistrado pode ter características e históricos de decisão distintos, que podem influenciar o resultado das ações.
Por isso, a equipe solicitou que você criasse uma base de variáveis dummies para a coluna juiz, utilizando a função pd.get_dummies(). Essas dummies representarão cada juiz da base de dados, com o valor 1 indicando a presença daquele juiz no processo, e 0 caso contrário.
Crie a base de dummies a partir da coluna juiz do DataFrame vivo_filtrado (criado no Exercício 6). Armazene o resultado em dummies_juiz. Não remova a primeira categoria (isto é, não utilize o parâmetro drop_first=True). Por fim, armazene o número de colunas da base resultante na variável n_col_dummies e imprima esse valor.
A função para criar variáveis dummies (One-Hot Encoding) no pandas é pd.get_dummies(). Basta passar a coluna do DataFrame como argumento (ex: pd.get_dummies(seu_dataframe['sua_coluna'])).
Todo DataFrame do pandas possui o atributo .shape, que retorna uma tupla (linhas, colunas). Para pegar apenas o número de colunas, você pode usar seu_dataframe.shape[1].
dummies_juiz = pd.get_dummies(vivo_filtrado['juiz'])
n_col_dummies = dummies_juiz.shape[1]
print(n_col_dummies)Transformar variáveis categóricas como “juiz” em dummies (também chamado de One-Hot Encoding) é essencial. Modelos matemáticos, como a regressão logística, não entendem categorias de texto (“Juiz A”, “Juiz B”).
Ao criar uma coluna para cada juiz (ex: juiz_A, juiz_B), o modelo pode atribuir um peso (coeficiente) individual a cada magistrado, aprendendo se a presença de um juiz específico aumenta ou diminui estatisticamente a chance de “Vitória” da empresa.
12.9 Exercício 9 — Seleção de Dummies Relevantes
Com a base de variáveis dummies criada, o time jurídico-analítico da Vivo identificou um novo desafio. Alguns juízes possuem apenas poucos processos na amostra, o que pode introduzir ruído estatístico nos modelos preditivos e dificultar a interpretação dos resultados.
Para garantir análises mais robustas, a equipe solicitou que fossem mantidos apenas os juízes com quantidade relevante de observações na base de dados.
Com base na estrutura criada em dummies_juiz (do Exercício 8), gere uma nova base contendo apenas as colunas correspondentes aos juízes que possuem mais de 50 processos registrados.
Armazene o resultado na variável dummies_juiz_select e informe quantas colunas a base resultante possui, armazenando este número na variável n_col_dummies_select e imprimindo o valor.
Como o DataFrame dummies_juiz contém 1s e 0s, você pode obter a contagem de processos por juiz simplesmente somando as colunas. Use o método .sum() no DataFrame. O resultado será uma Series onde o índice é o nome do juiz e o valor é a contagem.
Filtre a Series da Dica 1 para manter apenas os valores > 50. Em seguida, extraia o .index (que são os nomes dos juízes selecionados) e use essa lista para filtrar as colunas do DataFrame dummies_juiz original.
frequencias = dummies_juiz.sum()
juizes_selecionados = frequencias[frequencias > 50].index
dummies_juiz_select = dummies_juiz[juizes_selecionados]
n_col_dummies_select = dummies_juiz_select.shape[1]
print(n_col_dummies_select)Esta etapa é um exemplo clássico de seleção de features (feature selection). No contexto jurídico, um juiz com pouquíssimos casos (ex: 2 ou 3 processos) não oferece informação estatística suficiente para o modelo aprender um padrão.
Manter essas dummies “raras” pode ser prejudicial, fazendo o modelo dar um peso indevido a uma coincidência (ex: se um juiz julgou 2 casos e a Vivo perdeu ambos). Ao filtrar e manter apenas juízes com um volume relevante (ex: > 50 casos), garantimos que o modelo aprenda padrões mais robustos e estatisticamente estáveis.
12.10 Exercício 10 — Consolidação da Base de Modelagem
Com as etapas anteriores concluídas, o time jurídico-analítico da Vivo está pronto para iniciar a fase de modelagem preditiva. O objetivo agora é criar uma base consolidada que contenha apenas as variáveis consideradas mais relevantes para prever o desfecho dos processos.
Após reuniões com os advogados internos e especialistas em dados, foi definido que a base final deve incluir:
- as variáveis numéricas principais:
valor,pags_inicial,pags_contestacaoejuiz_tempo_vara, que representam aspectos financeiros e processuais relevantes; - e as variáveis dummies correspondentes aos juízes com mais de 50 processos, previamente armazenadas na base
dummies_juiz_select.
Com base nisso, crie uma nova base chamada vivo_f, contendo as variáveis listadas acima. Em seguida, armazene o número de linhas e colunas da base resultante nas variáveis n_linhas e n_colunas, e imprima o resultado.
Primeiro, crie uma lista com os nomes das colunas numéricas (ex: cols = ['valor', 'pags_inicial', ...]). Use essa lista para selecionar apenas essas colunas do DataFrame vivo_filtrado.
Para juntar o DataFrame numérico (da Dica 1) com o dummies_juiz_select, use a função pd.concat(). Lembre-se de especificar axis=1 para juntar as colunas lado a lado.
# Define as colunas numéricas
numeric_cols = ['valor', 'pags_inicial', 'pags_contestacao', 'juiz_tempo_vara']
vivo_numeric = vivo_filtrado[numeric_cols]
# Concatena com as dummies (do exercício anterior)
vivo_f = pd.concat([vivo_numeric, dummies_juiz_select], axis=1)
# Informa as dimensões
n_linhas = vivo_f.shape[0]
n_colunas = vivo_f.shape[1]
print(f"Base final criada com {n_linhas} linhas e {n_colunas} colunas.")Esta é a etapa final de preparação de dados, onde criamos a matriz de features (ou X). Esta base vivo_f contém todas as informações que o modelo preditivo usará para “aprender” os padrões que levam a uma vitória ou derrota (que está na variável y, criada no Exercício 7).
A escolha de quais colunas incluir (numéricas, dummies) é um passo crucial que combina conhecimento jurídico (o que realmente importa para o caso?) e estatístico (o que o modelo consegue usar para prever?).
12.11 Exercício 11 — Ajuste de um Modelo Logístico Simplificado
Após a criação da base de dados completa, a equipe de dados da Vivo solicitou um primeiro teste de modelagem.
Antes de usar o modelo completo (com todas as dummies de juízes), a equipe quer avaliar o poder preditivo de um modelo mais simples, usando apenas as variáveis valor e juiz_tempo_vara.
O objetivo é criar um “modelo de base” simplificado para comparar com as versões mais complexas no futuro.
Crie um modelo de regressão logística usando apenas valor e juiz_tempo_vara do vivo_f como X, e a coluna y do vivo_filtrado como y.
Divida os dados em treino e teste (30% para teste, random_state=1, estratificado por y).
Ajuste o modelo (LogisticRegression(max_iter=10000)) e, por fim, imprima na mesma linha: 1. A proporção de vitórias na base de treino (prop_y_train). 2. A proporção de vitórias na base de teste (prop_y_test). 3. A acurácia final do modelo (acc).
Desta vez, seu X não será o vivo_f inteiro. Crie o X selecionando apenas as duas colunas pedidas: X = vivo_f[['valor', 'juiz_tempo_vara']]. O y continua vindo do vivo_filtrado['y'].
Lembre-se de usar random_state=1 no train_test_split para este exercício. Para calcular as proporções, use .mean() nas variáveis y_train e y_test.
# 1. Definir X (simplificado) e y
X = vivo_f[['valor', 'juiz_tempo_vara']]
y = vivo_filtrado['y'] # Corrigido (não está em vivo_f)
# 2. Dividir os dados com random_state=1
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=1, stratify=y
)
# 3. Calcular proporções
prop_y_train = y_train.mean()
prop_y_test = y_test.mean()
# 4. Criar e treinar o modelo
model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)
# 5. Fazer previsões e calcular acurácia
y_pred = model.predict(X_test)
acc = accuracy_score(y_test, y_pred)
print(prop_y_train, prop_y_test, acc)A acurácia é a métrica mais fundamental para um modelo de classificação. Ela responde à pergunta: “De 100 processos que o modelo analisou, quantos ele acertou (Vitória/Derrota)?”
Neste exercício, usamos um modelo “simples” (com apenas 2 variáveis). Ele serve como um baseline de performance. Qualquer modelo futuro, mais complexo (como o que usa todas as dummies de juízes), só será considerado “melhor” se apresentar uma acurácia significativamente maior do que esta.