Pesquisa em grade com MLflow

Pesquisa Em Grade Com Mlflow



Os hiperparâmetros em modelos de aprendizado de máquina são otimizados usando a abordagem de pesquisa em grade. Um usuário pode comparar rapidamente várias configurações de hiperparâmetros e descobrir quais delas apresentam melhor desempenho porque o MLflow monitora os resultados dos experimentos de pesquisa em grade. No MLflow, o experimento de pesquisa em grade pode ser compartilhado rapidamente com outros membros da equipe. Usando o MLflow, o modelo mais eficaz de um experimento de pesquisa em grade pode ser implantado.

Benefícios da pesquisa em grade

  • Ajuste automatizado de hiperparâmetros: A pesquisa em grade automatiza o ajuste de hiperparâmetros, o que permite a exploração sistemática sem tentativa e erro manual.
  • Reprodutibilidade: A pesquisa em grade garante a validade do teste, obtendo de forma reproduzível os resultados reproduzíveis, o que melhora a comunicação e a confiabilidade.
  • Pesquisa exaustiva: O GS encontra com eficiência hiperparâmetros ideais para um modelo, pesquisando exaustivamente combinações.
  • Robustez: A pesquisa em grade é uma técnica robusta, resistente ao ruído de dados, o que reduz o sobreajuste.
  • Simples de usar: A pesquisa em grade é simples de usar e compreender, o que a torna um método viável para ajuste de hiperparâmetros.
  • Comparações de modelos: a pesquisa em grade simplifica a comparação de modelos e a seleção de métricas de avaliação.

Desvantagens da pesquisa em grade

  • Custo computacional: A pesquisa em grade é computacionalmente cara para ajustar um grande número de hiperparâmetros.
  • Demorado: É demorado para ajustes complexos de hiperparâmetros.
  • Nem sempre é necessário: Agora é sempre necessário; a pesquisa aleatória é a melhor alternativa para isso.

Exemplo: Encontrando as melhores configurações de modelo para sistema de admissão universitária

Vejamos um exemplo de pesquisa em grade para ajuste de hiperparâmetros dentro da estrutura de um sistema de admissão universitária online. Neste exemplo, usamos o scikit-learn e um classificador Gradient Boosting Classifier (GBC) direto para prever a probabilidade de um aluno ser aceito em uma universidade com base em fatores como pontos GPA, pontuações SAT, pontuações ACT e atividades extracurriculares. Várias opções estão disponíveis para pesquisa em grade em vez de GBC, incluindo Regressão Logística (LR), SVM (Support Vector Machine), etc.

Gere dados aleatórios para sistema de admissão online usando MLflow para pesquisa em grade

Os Pandas e pacotes aleatórios do Python podem ser usados ​​para criar um conjunto de dados fictício para o sistema de admissão. Com valores aleatórios para as colunas APP_NO, GPA, pontuação SAT, pontuação ACT, atividades extracurriculares e status de admissão, esse código gera um conjunto de dados de admissão sintético. A variável num_students controla quantas linhas existem no conjunto de dados.







O status de admissão é definido aleatoriamente com base em uma taxa de aceitação de 70%, e o módulo aleatório é usado para produzir valores aleatórios para diversas colunas. Para fins de demonstração, o código a seguir cria um conjunto de dados de admissão falso com valores aleatórios e é salvo no arquivo std_admission_dataset.csv:



Fragmento de código:



# Importe as bibliotecas Panda e Random
importar pandas como panda_obj
importar aleatório como random_obj

# Defina o número de registros para o conjunto de dados do aluno gerar
registros_alunos = 1000

# Crie listas para armazenar dados
std_application_numbers = [ 'APLICATIVO-' + str(obj_aleatório.randint( 1000 , 9999 )) para _ no intervalo (registros_alunos)]
std_gpa = [round(random_obj.uniform( 2,5 , 4,0 ), 2 ) para _ no intervalo (registros_alunos)]
std_sat_scores = [random_obj.randint( 900 , 1600 ) para _ no intervalo (registros_alunos)]
std_act_scores = [random_obj.randint( vinte , 36 ) para _ no intervalo (registros_alunos)]
std_extra_curriculars = [random_obj.choice ([ 'Sim' , 'Não' ]) para _ no intervalo(registros_alunos)]

# Calcule o status de admissão com base na taxa de aceitação aleatória
std_admission_status = [ 1 se random_obj.random() < 0,7 outro 0 para _ no intervalo (registros_alunos)]

# Crie um dicionário para armazenar os dados dos alunos
dados_std = {

'APLICATIVO_NÃO' : std_application_numbers,

'GPA' : std_gpa,

'SAT_Pontuação' : std_sat_scores,

'ACT_Pontuação' : std_act_scores,

'Atividades extracurriculares' : std_extra_curriculares,

'Admissão_Status' : std_admission_status

}

# Cria um DataFrame DataFrame_Student a partir do dicionário
DataFrame_Student = panda_obj.DataFrame(std_data)

# Salve o DataFrame DataFrame_Student em um arquivo CSV chamado std_admission_dataset.csv
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , índice=Falso)
imprimir( 'Dados dos alunos exportados com sucesso para arquivo CSV!' )

Execução de código:

Use o comando Python para compilar o código e, em seguida, use o comando pip para instalar um módulo específico se você encontrar um erro de módulo. Use o comando pip3 install para instalar a biblioteca fornecida se o Python for versão 3.X ou superior.





Execução bem sucedida:



Captura de tela de dados de amostra:

Etapa 1: importar as bibliotecas

  • A biblioteca MLflow para rastreamento de experimentos de aprendizado de máquina
  • A biblioteca Pandas para tratamento e análise de dados, bem como o pacote mlflow.sklearn para integração dos modelos Scikit-Learn
  • A quarta linha importa a biblioteca “warnings” para suprimir os erros
  • A classe ParameterGrid para pesquisa de grade no módulo sklearn.model_selection
  • GridSearchCV e GradientBoostingClassifier de sklearn.model_selection e ensemble, respectivamente, para pesquisa de grade e modelos de classificador de aumento de gradiente
  • As funções exactidão_score e classificação_report do módulo sklearn.metrics para calcular a precisão do modelo e gerar relatórios de classificação
  • O código importa o módulo do sistema operacional e define a variável de ambiente GIT_PYTHON_REFRESH como silenciosa.

Fragmento de código:

# Etapa I Importar Bibliotecas Necessárias
importar mlflow
importar mlflow.sklearn
importar avisos como avisar
importar pandas como panda_obj
de sklearn.model_selection importar train_test_split como tts, ParameterGrid como pg, GridSearchCV como gscv
importe-nos
de sklearn.ensemble importar GradientBoostingClassifier como GBC
de sklearn.metrics importar precisão_score como acs, rating_report como cr
os.environ[ 'GIT_PYTHON_REFRESH' ] = 'quieto'

Etapa 2: definir o URI de rastreamento

O URI de rastreamento do servidor MLflow é definido usando a função mlflow.set_tracking_uri(), garantindo uma máquina local na porta 5000 para experimentos e modelos.

mlflow.set_tracking_uri( 'http://localhost:5000' )

Etapa 3: carregar e preparar o conjunto de dados de admissão

Importe a biblioteca Pandas como panda_obj para manipulação e análise de dados. A função read_csv() é aplicada para carregar o conjunto de dados de admissão. O caminho para o conjunto de dados é o único argumento exigido pela função read_csv(). O caminho para o conjunto de dados nesta instância é std_admission_dataset.csv. Ao empregar a função read_csv(), o conjunto de dados é carregado em um Pandas DataFrame.

A coluna Admission_Status do DataFrame std_admissions_data é removida primeiro pelo código. Como esta coluna contém a variável de destino, o pré-processamento não é necessário.

Em seguida, o código cria duas novas variáveis: “F” e “t”. Os recursos estão contidos na variável “F”, enquanto a variável alvo está contida na variável “t”.

Os dados são então distribuídos em conjuntos de teste e treinamento. Isso é feito usando a função tts() do pacote sklearn.model_selection. Os recursos, a variável de destino, o tamanho do teste e o estado aleatório são os quatro argumentos exigidos pela função tts(). O parâmetro test_size estipula a parte dos dados que é utilizada para fins de teste. Como o tamanho do teste neste caso está definido como 0,2, 20% dos dados serão usados ​​para o teste.

A opção random_state especifica a semente do gerador de números aleatórios. Isso é feito para garantir que os dados sejam separados aleatoriamente. Os conjuntos de treinamento e teste agora são armazenados nas variáveis ​​F_training, F_testing, t_training e t_testing. Esses conjuntos podem ser usados ​​para avaliar e treinar os modelos de aprendizado de máquina.

Fragmento de código:

# Etapa 3: Carregar o conjunto de dados de admissão
std_admissions_data=panda_obj.read_csv( 'std_admission_dataset.csv' )

# Pré-processe os dados e divida em recursos (F) e destino (t)
F = std_admissions_data.drop([ 'Admissão_Status' ], eixo= 1 )
t = std_admissions_data[ 'Admissão_Status' ]

# Converta variáveis ​​categóricas em numéricas usando codificação one-hot
F = panda_obj.get_dummies(F)
F_treinamento, F_testing, t_training, t_testing = tts(F, t, test_size= 0,2 , estado_aleatório= 42 )

Etapa 4: definir o nome do experimento MLflow

adm_experiment_name = 'University_Admission_Experiment'
mlflow.set_experiment(adm_experiment_name)

Etapa 5: definir o classificador Gradient Boosting

O modelo do classificador de aumento de gradiente agora está armazenado na variável gbc_obj. O conjunto de dados de admissão pode ser empregado para testar e treinar este modelo. O valor do argumento random_state é 42. Isso garante que o modelo seja treinado usando exatamente a mesma semente do gerador de números aleatórios, o que torna os resultados repetíveis.

gbc_obj = GBC(estado_aleatório= 42 )

Etapa 6: definir a grade de hiperparâmetros

O código cria inicialmente o dicionário param_grid. Os hiperparâmetros ajustados por meio da pesquisa em grade estão contidos neste dicionário. Três chaves constituem o dicionário param_grid: n_estimators, learning_rate e max_profundidade. Estes são os hiperparâmetros do modelo classificador de aumento de gradiente. O número de árvores no modelo é especificado pelo hiperparâmetro n_estimators. A taxa de aprendizagem do modelo é especificada por meio do hiperparâmetro learning_rate. O hiperparâmetro max_profundidade define a maior profundidade possível das árvores do modelo.

Fragmento de código:

param_grid = {

'n_estimadores' :[ 100 , 150 , 200 ],

'taxa de Aprendizagem' :[ 0,01 , 0,1 , 0,2 ],

'profundidade máxima' :[ 4 , 5 , 6 ]

}

Etapa 7: Execute a pesquisa em grade com rastreamento MLflow

O código então itera no dicionário param_grid. Para cada conjunto de hiperparâmetros no dicionário, o código faz o seguinte:

  • Inicia uma nova execução do MLflow
  • Converte os hiperparâmetros em uma lista se eles ainda não forem uma lista
  • Registra os hiperparâmetros no MLflow
  • Treina um modelo de pesquisa em grade com os hiperparâmetros especificados
  • Obtém o melhor modelo da pesquisa em grade
  • Faz previsões sobre os dados de teste trabalhando no melhor modelo
  • Calcula a precisão do modelo
  • Imprime o relatório de hiperparâmetros, precisão e classificação
  • Registra a precisão e o modelo no MLflow

Fragmento de código:

com warning.catch_warnings():
avisar.filterwarnings( 'ignorar' , categoria=Aviso do usuário, módulo= '.*distutil.*' )
para parâmetros em pg(param_grid):
com mlflow.start_run(run_name= 'Execução de Admissions_Status' ):
# Converte valores únicos em listas
params = {key: [valor] if not isinstance(value, list) else valor para chave, valor em params.items()}
mlflow.log_params(params)
grid_search = gscv(gbc_obj, param_grid=params, cv= 5 )
grid_search.fit(F_training, t_training)
std_best_model = grid_search.best_estimator_
model_predictions = std_best_model.predict(F_testing)
model_accuracy_score = acs(t_testing, model_predictions)
imprimir( 'Hiperparâmetros:' , parâmetros)
imprimir( 'Precisão:' , model_accuracy_score)
# Ignore explicitamente o UndefinedMetricWarning
com warning.catch_warnings():
avisar.filterwarnings( 'ignorar' , categoria=Aviso)
imprimir( 'Relatório de Classificação:' )
print(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'precisão' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, 'gb_classifier_model' )

Etapa 8: execute o programa usando Python

Aqui está a saída no servidor MLflow:

Conclusão

A ferramenta de pesquisa em grade do MLflow automatiza ajustes, rastreamento de resultados e modificação de hiperparâmetros em modelos de aprendizado de máquina. Ajuda a determinar os hiperparâmetros ideais e garante resultados confiáveis, mas pode ser caro do ponto de vista computacional para experimentos extensos de hiperparâmetros.