Uma Analista está desenvolvendo um modelo de aprendizado de máquina em Python 3, em condições ideais. Após dividir o conjunto de dados em treinamento e teste, deseja criar um pipeline no scikit-leam para pré-processamento e treino do modelo. O pipeline deve lidar com variáveis categóricas utilizando OneHotEncoder e treinar um modelo de árvore de decisão com os parâmetros padrão. Isso pode ser feito com base no trecho de código abaixo.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder
from sklearn.tree import DecisionTreeClassifier

pipeline = Pipeline(([
   ___I___
])

pipeline.fit(X_train, y_train)

A lacuna I deve ser corretamente

('encoder', OneHotEncoder(handle_unknown='error')),
('modelo', DecisionTreeRegressor())

('encoder', OneHotEncoder(sparse='False')),
('modelo', DecisionTreeRegressor(criterion='gini'))

('encoder', Label_Encoder()),
('modelo', DecisionTreeClassifier())

('encoder', OneHotEncoder(handle_unknown='ignore')),
('modelo', DecisionTreeClassifier())

('encoder', LabelBinarizer()),
('modelo', DecisionTreeClassifier(maxdepth=3))

Uma equipe está trabalhando em um projeto de análise preditiva com base em dados estruturados provenientes de diferentes fontes de um Tribunal Regional do Trabalho. Durante a etapa de pré-processamento, o time precisa lidar com valores ausentes/faltantes, escalonar os dados para uniformizar as unidades e selecionar as variáveis mais importantes para treinar um modelo supervisionado. Para realizar estas tarefas nesta etapa, a equipe deve

Considere o código Python abaixo que utiliza a biblioteca pandas para manipular um conjunto de dados.

import pandas as pd

dados = {
    'numero_processo': ['12345-67', '98765-43', '56789-01', '34567-89'],
    'valor_processo': [10000.0, 5000.0, 7500.0, 12000.0],
    'peso': [1.2, 0.8, 1.5, 1.0],
    'status': ['Encerrado', 'Pendente', 'Pendente', 'Encerrado']
}

df = pd.DataFrame(dados)

# Filtro para selecionar apenas processos com status 'Pendente'
filtro = df['status'] == 'Pendente'

# Aplicar o filtro e calcular a média ponderada
media_ponderada = ___I___

print(f"A média ponderada do valor dos processos pendentes é: {media_ponderada}")

 

Considerando que o cálculo da média ponderada utiliza a fórmula Média Ponderada= \(\sum(\text{valor}\times\text{peso}) / \sum(\text{peso})\). e que o código será executado em condições ideais, a lacuna I é corretamente preenchida com

O analista Jonas está desenvolvendo um Large Language Model (LLM) para ser utilizado nas soluções de inteligência artificial do MPU. Para isso, Jonas utilizou o modelo pré-treinado BERTimbau, mas observou que as respostas eram genéricas e não específicas para o domínio.
Para treinar um modelo pré-treinado adaptando-o às tarefas e aos conjuntos de dados específicos do domínio do MPU, Jonas deve realizar um(a):

A biblioteca Pandas da linguagem de programação Python é utilizada para analisar dados e possui diversos recursos para realizar a limpeza inicial dos dados. Observe o código Python a seguir.

import pandas as pd
a={"id_processo":[1,2],"tipo":['A',pd.NA]}
df=pd.DataFrame(a)
df.dropna()
df.loc[1, 'tipo'] = 'B'
print(df.to_string())
df.dropna(inplace = True)
print(df.to_string())

O resultado da execução do código é:

      id_processo tipo
0           1        A
1           2     <NA>
      id_processo tipo
0           1        A

      id_processo tipo
0           1        A
1           2     <NA>
      id_processo tipo
0           1        B
1           2     <NA>

      id_processo tipo
0           1        A
1           2     <NA>
      id_processo tipo
0           1        A
1           2     <NA>

      id_processo tipo
0           1        B
1           2        B
      id_processo tipo
0           1        B
1           2        B

      id_processo tipo
0           1        A
1           2        B
      id_processo tipo
0           1        A
1           2        B

O analista Otávio está avaliando a solução de Business Intelligence do MPU desenvolvida por uma empresa contratada. Ao observar o banco de dados implementado, Otávio verificou que havia um esquema estrela, e que os dados armazenados estavam desnormalizados e alimentavam um cubo de dados para serem acessados e analisados via ferramenta OLAP.
A partir do observado, Otávio concluiu que o banco de dados era um:

O analista de Business Intelligence Luiz está desenvolvendo uma solução aplicando técnicas de mineração de dados na base de dados de processos judiciais do MPU para descobrir padrões que mostrem resultados como o exemplificado a seguir.

Roubo, Antecedentes Criminais, RJ, 2024} → {Pena > 5 anos}
[Suporte = 50%, Confiança = 80%]

Para descobrir esse tipo de padrão, com antecedente e consequente, Luiz deve minerar:

A analista de Business Intelligence Lúcia está elaborando o modelo multidimensional do Data Mart Processos Judiciais (DMProcJ). Durante sua análise, ela observou que o número do processo judicial (num_processo) não é uma métrica, mas sim um atributo importante, pois representa o menor grão do DMProcJ e pode ser usado para navegar até o sistema transacional de origem para analisar outras informações de um processo específico.

Para modelar o atributo num_processo, Lúcia deve implementar um(a):

As operações em vetores e matrizes é uma importante tarefa no desenvolvimento de Sistemas de Informação, especialmente os que manipulam dados. Observe o seguinte código Python.

import numpy as np
arr = np.array([1, 2, 3])
y = arr.copy()
arr[0] = 4
x = arr.view()
print(arr, x, y)
print(x.base, y.base, arr.shape)

O resultado da execução do código apresentado é:

O gestor de qualidade do MPU solicitou à analista de Business Intelligence Maria um Dashboard para monitorar o desempenho da tramitação dos processos ao longo do tempo.

O programador Pedro havia implementado o banco de dados MongoProc, no MongoDB, para armazenar os dados do sistema de tramitação de processos judiciais. Então, Maria solicitou a ele a consulta ao MongoProc para alimentar as tabelas: fato_proc (quantidade), dim_data, dim_estado. Pedro respondeu que não poderia fornecer apenas uma consulta, pois seria necessário transformar os dados NoSQL em relacional. Para implementar a solução, Maria poderá utilizar apenas as ferramentas disponíveis no MPU: MongoDB, PostgreSQL, MySQL, Flyway, Pentaho, QlikView e MicroStrategy.

Para transformar os dados NoSQL visando a alimentar as tabelas e construir o Dashboard, Maria deve: