Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

Para combinar seus dados personalizados com o conjunto de dados Common Voice, você…

  1. User

    Para combinar seus dados personalizados com o conjunto de dados Common Voice, você precisará carregar ambos os conjuntos de dados e, em seguida, concatená-los usando a biblioteca datasets. Vamos adaptar o código para realizar essa combinação:

    from datasets import load_dataset, concatenate_datasets, Audio import pandas as pd from datasets import Dataset

    Caminho para os metadados e os arquivos de áudio do seu conjunto de dados personalizado

    csv_file_path = ‘C:\m1\meta.csv’ audio_folder_path = ‘C:\m1\’

    Carregar dados personalizados

    def load_dataset_from_csv_and_audio_folder(csv_path, audio_folder_path): df = pd.read_csv(csv_path) df[‘file’] = df[‘file’].apply(lambda x: f’{audio_folder_path}{x}') return Dataset.from_pandas(df)

    Função carregar e transmitir Common Voice (versão mais recente)

    def load_streaming_dataset(name, lang, split, use_auth_token): return load_dataset(name, lang, split=split, streaming=True, use_auth_token=use_auth_token)

    Função para carregar e transmitir Common Voice (utilize a versão correta)

    raw_datasets = {} raw_datasets[“train”] = load_streaming_dataset(“mozilla-foundation/common_voice_13_0”, “pt”, split=“train”, use_auth_token=True) raw_datasets[“test”] = load_streaming_dataset(“mozilla-foundation/common_voice_13_0”, “pt”, split=“test”, use_auth_token=True)

    Carregar dataset personalizado

    custom_dataset = load_dataset_from_csv_and_audio_folder(csv_file_path, audio_folder_path)

    Converter o dataset de transmissão para uma versão com download se necessário

    Isso depende da quantidade de RAM disponível e pode ser desnecessário se a RAM for suficiente

    raw_datasets[“train”] = raw_datasets[“train”].with_format(“pandas”).to_pandas()

    raw_datasets[“test”] = raw_datasets[“test”].with_format(“pandas”).to_pandas()

    custom_dataset = Dataset.from_pandas(raw_datasets[“train”])

    Verifique se os nomes das colunas e formatos dos datasets combinam

    print(“Custom dataset:”, custom_dataset.column_names) print(“Common Voice dataset:”, next(iter(raw_datasets[“train”])).keys())

    As duas próximas linhas são apenas para demonstração, elas devem ser ajustadas conforme necessário

    Se as colunas não correspondem, você pode precisar renomear ou reformatar antes da concatenação

    Concatenar datasets

    combined_datasets = {} combined_datasets[“train”] = concatenate_datasets([custom_dataset, raw_datasets[“train”]]) combined_datasets[“test”] = concatenate_datasets([custom_dataset, raw_datasets[“test”]])

    Por favor, tenha em atenção que o acesso ao conjunto de dados Common Voice através da Hugging Face pode exigir a utilização de um token de autenticação que você pode receber criando uma conta na Hugging Face e criando um token de acesso.

    Além disso, como o conjunto de dados Common Voice é grande, você pode querer baixá-lo completamente em vez de transmiti-lo para garantir um processamento mais eficiente. Se preferir processar os dados sem transmitir diretamente da Hugging Face, você pode baixar o conjunto de dados Common Voice de seu site oficial e carregá-los de maneira semelhante ao seu conjunto de dados personalizado.

    Lembre-se de que a concatenação dos datasets exige que os dois datasets tenham o mesmo esquema de colunas; caso contrário, você precisará realizar uma etapa de transformação em seus dados para alinhar os esquemas antes da concatenação. Lembre-se de que a concatenação dos datasets exige que os dois datasets tenham o mesmo esquema de colunas; caso contrário, você precisará realizar uma etapa de transformação em seus dados para alinhar os esquemas antes da concatenação. acho isto importante, como faço, os da commom teem mais colunas Se os conjuntos de dados têm esquemas diferentes, você precisará harmonizar os esquemas antes de poder concatená-los. Isso geralmente significa selecionar ou renomear colunas para garantir que elas correspondam entre os conjuntos de dados. Aqui está um exemplo de como você pode fazer isso:

    1. Determine quais colunas são compartilhadas entre os dois conjuntos de dados, quais precisam ser renomeadas e quais devem ser descartadas.

    2. Modifique o esquema do conjunto de dados para se alinhar com o outro, acrescentando ou eliminando colunas conforme necessário.

    3. Concatene os conjuntos de dados modificados.

    Vamos adaptar o código anterior para incluir essas etapas:

    … (o código anterior até ‘load_dataset_from_csv_and_audio_folder’ vem aqui)

    Supondo que nosso conjunto de dados personalizado tenha as colunas ‘path’ e ‘sentence’

    e que queremos alinhá-lo com as colunas ‘path’ e ‘sentence’ padrão do conjunto de dados Common Voice

    Primeiramente, obtenha um exemplo do conjunto de dados Common Voice para visualizar as colunas

    example_cv_batch = next(iter(raw_datasets[“train”])) print(“Colunas Common Voice:”, example_cv_batch.keys())

    Suponhamos que queremos apenas as colunas ‘path’ e ‘sentence’ do Common Voice

    Renomear as colunas para corresponder ao esquema necessário

    def preprocess_common_voice(batch): # Escolha e/ou renomeie as colunas necessárias aqui. Por exemplo: # batch[“audio_path”] = batch[“path”] # batch[“transcription”] = batch[“sentence”] # Retornamos somente o necessário para o fine-tuning return {“file”: batch[“path”], “text”: batch[“sentence”]}

    Pré-processar Common Voice para alinhar as colunas com o conjunto de dados personalizado

    cv_train_dataset = raw_datasets[“train”].map(preprocess_common_voice) cv_test_dataset = raw_datasets[“test”].map(preprocess_common_voice)

    Como Common Voice é um conjunto de dados ‘streaming’,

    provavelmente precisaremos convertê-lo para um formato estándar antes de concatenar

    cv_train_dataset = cv_train_dataset.with_format(“pandas”).to_pandas() cv_test_dataset = cv_test_dataset.with_format(“pandas”).to_pandas()

    Converter de volta para datasets Hugging Face

    cv_train_dataset = Dataset.from_pandas(cv_train_dataset) cv_test_dataset = Dataset.from_pandas(cv_test_dataset)

    Agora que as colunas foram alinhadas, podemos concatenar os dois conjuntos de dados

    combined_train_dataset = concatenate_datasets([custom_dataset, cv_train_dataset]) combined_test_dataset = concatenate_datasets([custom_dataset, cv_test_dataset])

    Verifique se todos os datasets combinados têm o mesmo esquema

    print(“Esquema do dataset combinado:”, combined_train_dataset.column_names)

    Este exemplo mostra como processar e alinhar os esquemas dos conjuntos de dados antes de concatená-los. A função preprocess_common_voice dentro de map é utilizada para alinhar as colunas do Common Voice com as do conjunto de dados personalizado. Lembre-se de ajustar os nomes das colunas e a lógica da função preprocess_common_voice conforme necessário para o seu caso específico.

    Dependendo do tamanho do dataset e das especificações da sua máquina, você pode precisar de bastante memória RAM para realizar todas estas operações, especialmente ao converter os datasets para o formato Pandas. Se você encontra limitações de memória, pode considerar trabalhar com subconjuntos dos dados ou aumentar o recurso computacional disponível. escolheste bem, as colunas ‘path’ e ‘sentence’ esqueci de dizer que queria command voice só de portugues de preferencia português de portugal e se possível a minha contribuição no dataset, lembro-me de ver lá audio transcriçoes que fiz como contribuição Excelente, parece que estamos no caminho certo para combinar seu conjunto de dados personalizado com o conjunto de dados Common Voice Português de Portugal. Vamos ajustar o código para filtrar apenas as entradas em Português de Portugal e para tentar localizar suas próprias contribuições baseado em algum identificador que você possa ter (como um nome de usuário ou ID de contribuição, se disponível).

    Para filtrar por língua e possivelmente por contribuições específicas, você faria algo assim:

    Após carregar o conjunto de dados streaming Common Voice

    def preprocess_common_voice(batch): # Adapte a função para retornar apenas as colunas desejadas return {“file”: batch[“path”], “text”: batch[“sentence”]}

    Função para filtrar por língua e, opcionalmente, pelo contribuidor

    def filter_by_language_and_user(batch, lang_code=“pt-PT”, user_name=None): # Verifica se o idioma corresponde a Português de Portugal if batch[“locale”] == lang_code: # Se um nome de usuário foi fornecido, aplique um filtro adicional if user_name is not None: # Verifique se o nome do usuário corresponde ao informado, # isso pode depender do campo preciso no dataset. # No dataset Common Voice algumas vezes a informação do contribuidor não é fornecida, # então essa parte do código pode não ser tão direta. return user_name in batch[“client_id”] else: return True else: return False

    Modifique a linha de carregamento da Common Voice para selecionar apenas Português de Portugal

    common_voice_dataset = load_dataset( “mozilla-foundation/common_voice_13_0”, “pt”, split=“train+validation+other”, streaming=True, use_auth_token=True )

    Filtrar pelo idioma e se necessário pelo usuário específico

    filtered_common_voice_dataset = common_voice_dataset.filter( filter_by_language_and_user, fn_kwargs={“lang_code”: “pt-PT”, “user_name”: “seu_nome_de_usuario”} # substitua pelo seu identificador )

    Pré-processar o conjunto de dados filtrado da Common Voice para alinhar as colunas

    preprocessed_common_voice_dataset = filtered_common_voice_dataset.map(preprocess_common_voice)

    … (resto do código para converter para pandas, criar dataset huggingface e concatenar)

    adapta para que o dataset da commom voice tenha sido descarregada par o pc, e vá ser então carregado do pc junto com os dados do utilizador(trancrições, .wav)

  2. Assistant

    Se você já baixou o conjunto de dados Common Voice Português de Portugal e deseja carregá-lo do seu computador localmente, juntamente com seus dados de usuário, você precisa ajustar o processo de carregamento para acessar os arquivos locais em vez de transmiti-los da Hugging Face. Vou assumir que você possui os arquivos em formato CSV e os arquivos de áudio em uma pasta. Também vamos processar os dados para ter certeza de que apenas os dados de Português de Portugal (pt-PT) serão incluídos e tentar localizar suas contribuições.

    Aqui está uma versão adaptada do código para carregar os dados locais e combiná-los:

    from datasets import load_dataset, Dataset, concatenate_datasets, Audio
    import pandas as pd
    
    # Altere os caminhos de acordo com onde os dados estão localizados no seu computador
    csv_file_path_common_voice = 'C:\caminho_para_o_dataset_common_voice\pt\cv-corpus-13-0-2023-03-23\pt-PT\train.tsv'  # Exemplo do caminho para o arquivo tsv do Common Voice
    audio_folder_path_common_voice = 'C:\caminho_para_o_dataset_common_voice\pt\cv-corpus-13-0-2023-03-23\pt-PT\clips\'  # Exemplo do caminho para os clipes de áudio
    csv_file_path_custom_dataset = 'C:\caminho_para_o_seu_dataset\meta.csv'  # Caminho para os metadados do seu conjunto de dados
    audio_folder_path_custom_dataset = 'C:\caminho_para_o_seu_dataset\'  # Caminho para os arquivos de áudio do seu conjunto de dados
    
    # Função para carregar o conjunto de dados do Common Voice a partir dos arquivos locais
    def load_common_voice_local(csv_file_path, audio_folder_path):
        df = pd.read_csv(csv_file_path, sep='\t')
        df['file'] = df['path'].apply(lambda x: audio_folder_path + x)
        # Filtro por idioma pode ser aplicado aqui se o arquivo incluir múltiplos idiomas
        # df = df[df['locale'] == 'pt-PT']
        df = df.rename(columns={'sentence': 'text'})  # Renomeando para padronizar
        return Dataset.from_pandas(df)
    
    # Função para carregar seus dados personalizados
    def load_custom_dataset(csv_path, audio_folder_path):
        df = pd.read_csv(csv_path)
        df['file'] = df['file'].apply(lambda x: f'{audio_folder_path}{x}')
        return Dataset.from_pandas(df)
    
    # Carregar os datasets
    common_voice_dataset = load_common_voice_local(csv_file_path_common_voice, audio_folder_path_common_voice)
    custom_dataset = load_custom_dataset(csv_file_path_custom_dataset, audio_folder_path_custom_dataset)
    
    # Agora que ambos datasets estão carregados, você pode filtrar com base na suas contribuições pelo 'client_id', 'up_votes', ou outras métricas disponíveis
    # Isso assume que você sabe seu client_id ou outra informação que identifica suas contribuições
    # meu_client_id = 'seu_client_id'
    # common_voice_dataset = common_voice_dataset.filter(lambda x: x['client_id'] == meu_client_id)
    
    # Concatenar datasets
    combined_train_dataset = concatenate_datasets([custom_dataset, common_voice_dataset])
    
    # Verifique se todos os datasets combinados têm o mesmo esquema
    print("Esquema do dataset combinado:", combined_train_dataset.column_names)
    

    Neste exemplo, altere caminho_para_o_dataset_common_voice e caminho_para_o_seu_dataset para os caminhos reais em seu sistema de arquivos onde os dados estão armazenados.

    Tenha em mente que:

    • O Common Voice pode estar em formato TSV (\t como separador). Certifique-se de usar pd.read_csv com sep='\t' se for o caso.
    • Seu CSV personalizado e o arquivo TSV do Common Voice podem ter nomes diferentes para as colunas que você deseja combinar. Certifique-se de renomeá-los para que correspondam antes de tentar concatenar os conjuntos de dados.
    • Se você precisar filtrar pelo client_id específico das suas contribuições, aplique um filtro ao common_voice_dataset antes da concatenação.

    Esteja ciente de que ler todo o conjunto de dados Common Voice para a memória pode exigir uma grande quantidade de RAM. Se você encontrar problemas de memória, considere filtrar apenas as linhas necessárias ou carregar os dados por partes.

  3. User

    Esteja ciente de que ler todo o conjunto de dados Common Voice para a memória pode exigir uma grande quantidade de RAM. Se você encontrar problemas de memória, considere filtrar apenas as linhas necessárias ou carregar os dados por partes, como fazer isso?

  4. Assistant

    Para lidar com conjuntos de dados de grande escala e evitar problemas de memória, você pode processar e filtrar os dados em partes menores (também conhecido como processamento em lote ou chunking). Aqui está um exemplo de como você pode modificar a função load_common_voice_local para ler o conjunto de dados em partes usando o parâmetro chunksize do Pandas:

    def load_common_voice_local(csv_file_path, audio_folder_path, chunksize=10000):
        # Inicialização de uma lista para armazenar pedaços do DataFrame
        dataset_chunks = []
        
        # Iterar através de pedaços do DataFrame
        for chunk in pd.read_csv(csv_file_path, sep='\t', chunksize=chunksize):
            # Processa o pedaço especificado antes de adicionar à lista
            chunk = chunk[chunk['locale'] == 'pt-PT']  # Filtra por idioma
            chunk['file'] = chunk['path'].apply(lambda x: audio_folder_path + x)
            chunk = chunk.rename(columns={'sentence': 'text'})  # Renomeia colunas
            dataset_chunk = Dataset.from_pandas(chunk)
            dataset_chunks.append(dataset_chunk)
        
        # Combina todos os pedaços em um único DataSet
        return concatenate_datasets(dataset_chunks)
    

    Ao usar este método, o arquivo CSV do Common Voice será lido em parte por parte. Cada DataFrame parcial será processado e convertido em um objeto Dataset. No final, todos esses pequenos conjuntos de dados serão concatenados em um único Dataset.

    Observe que você vai precisar fazer algo semelhante ao carregar o seu próprio conjunto de dados personalizado se ele também for muito grande. Ademais, é importante verificar se a quantidade estabelecida para o chunksize é apropriada para sua RAM disponível.

    Ao filtrar as entradas pelo client_id, você precisará aplicar o filtro a cada pedaço, pois você não terá todas as entradas carregadas na memória de uma vez. Por segurança, verifique se o client_id ou qualquer outro campo de interesse está devidamente incluso em cada pedaço que você está processando.

    Se você estiver trabalhando com os dados de áudio em conjunto com o CSV, poderá precisar armazenar o caminho para o arquivo de áudio de cada pedaço conforme você vai filtrando e processando-os. Certifique-se de que a estrutura de diretórios e os caminhos dos arquivos estejam corretos quando concatenar os caminhos do arquivo de áudio.

    Outra abordagem seria filtrar o conjunto de dados Common Voice completo primeiro, exportá-lo em um formato intermediário (como um novo CSV) que apenas contém as entradas de interesse, e depois trabalhar com esse conjunto de dados filtrado para realizar operações adicionais - como concatenar com o seu conjunto de dados personalizado. Isso evitaria a necessidade de realizar o processamento pesado mais de uma vez.

    Por fim, se as operações continuarem consumindo muita memória e você não puder processá-las eficientemente em sua máquina local, poderia considerar a utilização de serviços em nuvem que oferecem maior capacidade de memória e poder computacional.

  5. User

    como é que faço para considerar só determinadas linhas do dataset

  6. Assistant

    Para considerar apenas determinadas linhas de um conjunto de dados, você precisa filtrá-las com base em critérios específicos. Com pandas, você pode usar máscaras booleanas para filtrar DataFrames. Aqui está um exemplo de como carregar e filtrar linhas específicas de um DataFrame com base em valores de colunas:

    import pandas as pd
    
    # Caminho do arquivo
    csv_file_path = 'caminho_para_o_arquivo.csv'
    
    # Ler o arquivo CSV
    df = pd.read_csv(csv_file_path)
    
    # Defina seu critério de filtro aqui:
    # Suponha que você deseje filtrar linhas onde a coluna 'locale' tem o valor 'pt-PT'
    df_filtered = df[df['locale'] == 'pt-PT']
    
    # Se você quer combinar múltiplos critérios, você pode usar o operador & para "e"
    # ou | para "ou". Suponha que você também quer filtrar pelo client_id 'meu_client_id'
    meu_client_id = 'seu_client_id'
    df_filtered = df[(df['locale'] == 'pt-PT') & (df['client_id'] == meu_client_id)]
    
    # Agora df_filtered contém apenas as linhas que você está interessado
    

    Se você estiver trabalhando com um conjunto de dados grande e quiser evitar carregar tudo na memória, você pode iterar sobre o arquivo em partes usando o parâmetro chunksize, como mencionado anteriormente:

    chunksize = 10000  # Número de linhas por pedaço
    
    chunks = []  # Lista para armazenar os chunks filtrados
    for chunk in pd.read_csv(csv_file_path, chunksize=chunksize):
        filtered_chunk = chunk[(chunk['locale'] == 'pt-PT')]
        chunks.append(filtered_chunk)
    
    # Concatenar os chunks filtrados para formar o DataFrame final
    df_filtered = pd.concat(chunks)
    

    Se você estiver trabalhando com o datasets da Hugging Face e quer filtrar linhas específicas, você pode usar o método .filter após carregar o conjunto de dados:

    from datasets import load_dataset
    
    # Supondo que você esteja lendo um conjunto de dados da Hugging Face
    dataset = load_dataset('nome_do_dataset', split='train')
    
    # Filtrar usando o método .filter
    def filter_criteria(example):
        return example['locale'] == 'pt-PT' and example['client_id'] == meu_client_id
    
    filtered_dataset = dataset.filter(filter_criteria)
    

    Note que no contexto do datasets, a filtragem é feita elemento a elemento e dependendo do tamanho do seu conjunto de dados, pode ser uma operação demorada.

    Garanta sempre que o filtro esteja correto e que você considerou condições como valores nulos, tipos de dados e que a filtragem não exclua linhas que você queira manter para o seu projeto ou análise.

  7. User

    e para um determinado nº de linhas, por ex da 501 à 1100

  8. Assistant

    Se você deseja considerar apenas um intervalo específico de linhas, como da linha 501 à 1100, você pode fazer isso facilmente com pandas usando o método .iloc, que permite indexar por posição:

    import pandas as pd
    
    # Caminho do arquivo
    csv_file_path = 'caminho_para_o_arquivo.csv'
    
    # Ler o arquivo CSV
    df = pd.read_csv(csv_file_path)
    
    # Selecionar um intervalo específico de linhas, note que o intervalo é exclusivo do último número
    df_subset = df.iloc[500:1100]  # Python utiliza indexação baseada em zero, então linha 501 é o índice 500
    

    Este método é direto e eficiente, especialmente quando você já sabe os números das linhas que está interessado.

    No entanto, se você estiver trabalhando com um conjunto de dados muito grande e usar a função de leitura em pedaços (chunksize) para evitar a leitura do arquivo inteiro em memória, você precisará de um pouco mais de controle em seu loop para identificar e extrair o intervalo de linhas desejado:

    chunksize = 1000  # Defina o tamanho do pedaço
    start_row = 500
    end_row = 1100
    current_row = 0
    rows_to_extract = []
    
    for chunk in pd.read_csv(csv_file_path, chunksize=chunksize):
        next_row = current_row + chunk.shape[0]
        
        # Se o pedaço incluir o início do intervalo que procuramos
        if start_row >= current_row and start_row < next_row:
            rows_to_extract.extend(chunk.iloc[start_row - current_row : end_row - current_row].index.tolist())
        
        # Atualize a contagem de linhas processadas
        current_row = next_row
        
        # Parar o ciclo se tivermos passado a linha final de interesse
        if current_row > end_row:
            break
    
    # Seu subconjunto de dados está agora nas 'rows_to_extract'
    df_subset = pd.concat([chunk.loc[rows] for chunk, rows in zip(pd.read_csv(csv_file_path, chunksize=chunksize), rows_to_extract)])
    

    Se você estiver usando o datasets da Hugging Face, pode selecionar um intervalo específico de linhas após carregar o conjunto de dados usando o método .select:

    from datasets import load_dataset
    
    # Suponha que você está carregando um conjunto de dados da Hugging Face
    dataset = load_dataset('nome_do_dataset', split='train')
    
    # Selecione um intervalo específico de linhas
    indices = range(500, 1100)  # Python usa zero-indexing e range é não-inclusivo no limite superior
    subset_dataset = dataset.select(indices)
    

    Lembre-se de que a indexação em Python começa em 0, então a linha 501 é o índice 500. A função range também é não-inclusiva no final, então para pegar até a linha 1100, você inclui 1100 como segundo argumento.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.