Abraçando o trem facial e o conjunto de dados dividido

A biblioteca Hugging Face não possui uma função específica chamada train_test_split. No entanto, quando se trata de dividir os dados para treinamento e teste em tarefas de aprendizado de máquina, a função train_test_split é comumente usada em outras bibliotecas populares, como o scikit-learn. Aqui, explicaremos os parâmetros que normalmente são usados ​​na função train_test_split do scikit-learn.

O método train_test_split na biblioteca de conjuntos de dados do Hugging Face é usado para dividir um conjunto de dados em dois subconjuntos: um subconjunto de treinamento e um subconjunto de teste. Este método é comumente empregado em aprendizado de máquina para avaliar o desempenho de um modelo em dados não vistos. O subconjunto de treinamento é utilizado para treinar o modelo, enquanto o subconjunto de teste é usado para avaliar seu desempenho e capacidades de generalização.

Aqui está uma visão geral do método train_test_split em Hugging Face:

1. test_size (numpy.random.Generator, opcional) : o tamanho da divisão de teste é determinado por esta opção. O tipo pode ser float ou inteiro.

• Se for fornecido como flutuante, deverá refletir a porcentagem do conjunto de dados a ser incluída na divisão de teste e estar entre 0,0 e 1,0.
• O número exato de amostras de teste é representado pelo valor se for fornecido como um número inteiro.
• Se estiver definido como Nenhum, o complemento do tamanho do trem será usado como valor.
• Se train_size também for Nenhum, será definido como 0,25 (25% do conjunto de dados).

• Se for fornecido como flutuante, deverá refletir a porcentagem do conjunto de dados a ser incluída na divisão do trem e estar entre 0,0 e 1,0.
• O número exato de amostras de trem é representado pelo valor se for fornecido como um número inteiro.
• Se estiver definido como Nenhum, o valor é alterado automaticamente para o complemento do tamanho do teste.

• Este parâmetro determina se os dados devem ou não ser embaralhados antes da divisão.
• Se estiver definido como True, os dados serão embaralhados aleatoriamente antes da divisão.
• Se estiver definido como False, os dados serão divididos sem embaralhamento.

• Este parâmetro é utilizado para a divisão estratificada de dados com base em uma coluna específica.
• Se for especificado, deverá ser o nome da coluna dos rótulos ou classes.
• Os dados serão divididos de forma a manter a mesma distribuição de rótulos ou classes nas divisões de treinamento e teste.

• Este parâmetro permite definir uma semente para inicializar o BitGenerator padrão.
• Se estiver definido como Nenhum, uma entropia nova e imprevisível será extraída do sistema operacional.
• Se um número inteiro ou números inteiros semelhantes a uma matriz forem passados, eles serão usados ​​para derivar o estado inicial do BitGenerator.

• Este parâmetro permite especificar um gerador aleatório NumPy para calcular a permutação das linhas do conjunto de dados.
• Se estiver definido como Nenhum (padrão), ele usa o np.random.default_rng que é o BitGenerator padrão (PCG64) do NumPy.

• Este parâmetro determina se os índices divididos devem ser mantidos na memória em vez de gravá-los em um arquivo de cache.
• Se estiver definido como True, os índices de divisão serão armazenados na memória durante o processo de divisão.
• Se estiver definido como False, os índices divididos serão gravados em um arquivo de cache para uso posterior.

• Este parâmetro determina se deve ser usado um arquivo de cache para carregar os índices divididos em vez de recalculá-los.
• Se estiver definido como True e um arquivo de cache que armazena os índices de divisão puder ser identificado, ele será usado.
• Se for definido como False, os índices divididos serão recalculados mesmo se existir um arquivo de cache.
• O valor padrão é True se o cache estiver ativado.

• Este parâmetro permite fornecer um caminho ou nome específico para o arquivo de cache que armazena os índices de divisão do trem.
• Se for especificado, os índices de divisão do trem serão armazenados neste arquivo de cache em vez do nome do arquivo de cache gerado automaticamente.

• Este parâmetro permite fornecer um caminho ou nome específico para o arquivo de cache que armazena os índices de divisão de teste.
• Se for especificado, os índices de divisão de teste serão armazenados neste arquivo de cache em vez do nome do arquivo de cache gerado automaticamente.

• Este parâmetro determina o número de linhas por operação de gravação para o gravador de arquivo de cache.
• É uma compensação entre o uso de memória e a velocidade de processamento.
• Valores mais altos reduzem o número de operações de gravação, mas consomem mais memória durante o processamento.
• Valores mais baixos consomem menos memória temporária, mas podem afetar ligeiramente a velocidade de processamento.

• Este parâmetro representa a nova impressão digital do conjunto de trens após a aplicação de uma transformação.
• Se for especificado, fornece uma nova impressão digital para o trem.
• Se estiver definido como Nenhum, a nova impressão digital será calculada usando um hash da impressão digital anterior e os argumentos de transformação.

• Este parâmetro representa a nova impressão digital do conjunto de teste após aplicar uma transformação.
• Se for especificado, fornece uma nova impressão digital para o conjunto de teste.
• Se estiver definido como Nenhum, a nova impressão digital será calculada usando um hash da impressão digital anterior e os argumentos de transformação.

Sintaxe:

X : representa os recursos de entrada ou variáveis ​​independentes do seu conjunto de dados.

• e : representa a saída ou variável dependente que você está tentando prever.
• tamanho_teste : este parâmetro determina a proporção do conjunto de dados que será alocada para teste. Pode ser especificado como um número flutuante (por exemplo, 0,2 para 20%) ou um número inteiro (por exemplo, 200 para 200 amostras).
• estado_aleatório : Este é um parâmetro opcional que permite definir uma semente para o gerador de números aleatórios. Ele garante que a divisão seja reproduzível, o que significa que você obterá a mesma divisão se usar o mesmo valor de estado aleatório.

A função train_test_split retorna quatro conjuntos de dados:

• X_trem : O conjunto de treinamento de recursos de entrada.
• X_teste : o conjunto de testes de recursos de entrada.
• y_train : o conjunto de treinamento de rótulos de saída.
• y_teste : O conjunto de teste de rótulos de saída.

Exemplo : O programa de exemplo a seguir é salvo como “ teste.py ”.

Esta declaração de importação é do scikit-learn, não da biblioteca de conjuntos de dados Hugging Face. Certifique-se de ter o scikit-learn instalado em seu ambiente. Você pode instalá-lo usando o seguinte comando:

Explicação: Primeiro, importamos o módulo necessário: train_test_split do scikit-learn.

• Carregamos o conjunto de dados IMDb usando load_dataset('imdb') e o atribuímos à variável do conjunto de dados.
• Para usar train_test_split, precisamos separar os recursos de entrada (X) e os rótulos correspondentes (y). Neste caso, assumimos que o conjunto de dados possui uma divisão denominada “trem” com “texto” como recursos de entrada e “rótulo” como rótulos correspondentes. Talvez seja necessário ajustar as chaves com base na estrutura do seu conjunto de dados.
• Em seguida, passamos os recursos de entrada (X) e os rótulos (y) para train_test_split junto com outros parâmetros. Neste exemplo, definimos test_size como 0,2, o que significa que 20% dos dados serão alocados para teste. O parâmetro shuffle é definido como “True” para embaralhar aleatoriamente os dados antes da divisão, e o parâmetro random_state é definido como 42 para reprodutibilidade.
• A função train_test_split retorna quatro conjuntos de dados: X_train, X_test, y_train e y_test. Eles representam os subconjuntos de treinamento e teste dos recursos e rótulos de entrada, respectivamente.
• Imprimimos o número de exemplos no conjunto de dados original (len(X)), no conjunto de dados de treinamento (len(X_train)) e no conjunto de dados de teste (len(X_test)). Isso nos permite verificar o processo de divisão e garantir que os subconjuntos sejam criados corretamente.
• Por fim, acessamos e imprimimos um exemplo do conjunto de dados de treinamento (X_train[0], y_train[0]) e um exemplo do conjunto de dados de teste (X_test[0], y_test[0]).

Saída : Executamos o programa salvo anteriormente usando o Python “test.py”.

Conclusão

A funcionalidade de divisão train-test fornecida pela biblioteca de conjuntos de dados do Hugging Face, em combinação com a função train_test_split do scikit-learn, oferece uma maneira conveniente e eficiente de dividir um conjunto de dados em subconjuntos separados de treinamento e teste.

Ao utilizar a função train_test_split, você pode controlar o tamanho do conjunto de teste, se deve embaralhar os dados e definir uma semente aleatória para reprodutibilidade. Essa flexibilidade permite a avaliação eficaz de modelos de aprendizado de máquina em dados não vistos e ajuda na detecção de problemas como overfitting ou underfitting.

Os parâmetros da função train_test_split permitem controlar vários aspectos da divisão, como o tamanho do conjunto de teste (test_size), embaralhar os dados (shuffle) e realizar uma divisão estratificada com base em colunas específicas (stratify_by_column). Além disso, você pode especificar um valor inicial (semente) para reprodutibilidade e personalizar os nomes dos arquivos de cache para armazenar os índices divididos (train_cache_file_name e test_cache_file_name).

A funcionalidade que Hugging Face oferece facilita a preparação de seus dados para treinamento e avaliação de modelo. Ao ter subconjuntos de treinamento e teste separados, você pode avaliar com precisão o desempenho do seu modelo em dados não vistos, detectar possíveis problemas como overfitting e tomar decisões informadas para melhorias no modelo.

No geral, a funcionalidade de divisão de teste de trem na biblioteca de conjuntos de dados do Hugging Face, em conjunto com train_test_split do scikit-learn, fornece um conjunto de ferramentas poderoso para divisão de dados eficiente, avaliação de modelo e desenvolvimento de soluções robustas de aprendizado de máquina.