Min erfaring med at uploade et datasæt på HuggingFace’s datasæt-hub | af Kartik Godawat

Tilføjelse af datasættet:

Der er to måder at tilføje et offentligt datasæt på:

• Fællesskab-forsynet: Datasættet hostes på datasættets hub. Det er ubekræftet og identificeret under et navneområde eller organisation, ligesom en GitHub-repo.
• Kanonisk: Datasæt tilføjes direkte til datasæt repo ved at åbne en PR (Pull Request) til repoen. Normalt er data ikke hostet, og man skal gennemgå PR-fusionsproces.

Da jeg ønskede at være vært for dataene sammen med forbehandlingsscriptet (benævnt “dataset loading script” af biblioteket), valgte jeg at uploade datasættet som en fællesskabsleveret datasæt.

Der er to primære krav til at konvertere et eksisterende datasæt af csv, json, xml eller et hvilket som helst andet format til et datasæt:

• Datasæt indlæsningsscript
• Datasæt metadata

Datasæt Loading Script:

Der er god dokumentation tilgængelig om oprettelse af et sådant script. Jeg foretrak dog at kopiere og indsætte ved at bruge scripts fra allerede eksisterende datasæt svarende til mine, som findes i datasætbiblioteket. f.eks.: Hvis mit datasæt er af csv-typen, starter jeg med et lignende csv-type script og ændrer det efter mine behov.

Scriptet har primært brug for tre komponenter for at blive defineret:

• Oplysninger om kolonne- og datatyper (omtalt som funktioner)
• URL’er til at downloade data fra (eller lokale filer) og specificering af tog/test/valideringsopdelinger
• Giv 1 række data ved at bruge split og funktioner

1. _info: Overskrifterne i csv-feltet skal defineres med deres datatype. Jeg endte med at bruge string , int32 og large_string. Beskrivelse af understøttede datatyper er tilgængelig i funktioner.

def _info(self):
return datasets.DatasetInfo(
description=_DESCRIPTION,
features=datasets.Features(
{
"modelId": datasets.Value("string"),
"lastModified": datasets.Value("string"),
"tags": datasets.features.Sequence(datasets.Value("string")),
"pipeline_tag": datasets.Value("string"),
"files": datasets.features.Sequence(datasets.Value("string")),
"publishedBy": datasets.Value("string"),
"downloads_last_month": datasets.Value("int32"),
"library": datasets.Value("string"),
"modelCard": datasets.Value("large_string"),
}
),
homepage=_HOMEPAGE,
license=_LICENSE,
citation=_CITATION,
)

Kolonnerne “tags” og “filer” er arrays, da de kan være flere, som understøttes af biblioteket af dataset.features.Sequence.

2. URL’er / lokale filer:

Næste trin er derefter at definere en URL, som i mit tilfælde er en lokal fil. Da data kun er undersøgende og ikke har nogen målmærker (ikke specifikt beregnet til at træne noget), var der ikke behov for testopdeling. Derfor er det kun opdeling af togdatasæt, der vil gøre det.

_URL = "huggingface-modelhub.csv"
...
def _split_generators(self, dl_manager):
"""Returns SplitGenerators."""
data_file = dl_manager.download_and_extract(_URL)
return [
datasets.SplitGenerator(
name=datasets.Split.TRAIN,
gen_kwargs={
"filepath": data_file,
},),]

3. Giv en række:

Det næste trin er at give en enkelt række data. Ved kørsel vil passende generator (defineret ovenfor) vælge datakilden fra URL eller lokal fil og bruge den til at generere en række. Her, siden dataformatet var csv kan vi bruge pythons indbyggede csv-modul og dets funktion csv.reader for at læse dataene fra filen.

def _generate_examples(self, filepath):
"""Yields examples."""
with open(filepath, encoding="utf-8") as f:
reader = csv.reader(f)
for id_, row in enumerate(reader):
if id_ == 0:
continue
yield id_, {
"modelId": row[0],
"lastModified": row[1],
"tags": ast.literal_eval(row[2]),
"pipeline_tag": row[3],
"files": ast.literal_eval(row[4]),
"publishedBy": row[5],
"downloads_last_month": float(row[6]) if row[6] else 0,
"library": row[7],
"modelCard": row[8]
}

ast.literal_eval er en praktisk funktion til at parse arrayet til stede i en streng til en faktisk array(liste).

Scriptet kunne testes sådan her:

>>> from datasets import load_dataset
>>> dataset = load_dataset('PATH/TO/MY/SCRIPT.py')
>>> dataset["train"] # To access train generator
>>> dataset["train"][0] #Access elements in dataset

Med scriptet på plads går vi videre til at tilføje datasættets metadata og gøre datasættet klar til publicering.

Datasæt metadata:

Dokumentationen forklarer detaljeret, hvordan man forbereder datasæt til deling. For at tilføje metadata er der en hjælpekommando tilgængelig gennem datasets-cli som bliver installeret, når vi installerer datasetsbibliotek.

datasets-cli test datasets/<your-dataset-folder> --save_infos --all_configs

Ved at køre ovenstående kommando genereres en fil dataset_infos.json som indeholder metadata som datasætstørrelse, kontrolsum osv.

Upload af datasættet:

Huggingface bruger git og git-lfs bag kulisserne til at administrere datasættet som et lager. For at starte skal vi oprette et nyt lager.

Når først repository er klar, gælder standard git-praksis. dvs. fra din projektmappe køre:

$ git init .
$ git remote add origin https://huggingface.co/datasets/<user>/<repo>
$ git pull origin main

Nu har vi synkroniseret vores lokale maskine med lageret. Næste trin er at tilføje følgende filer og forpligte:

• datasætfiler (csv): Selve dataene
• datasæt indlæsningsscript: Loader til data
• datasæt metadata: Metadata som størrelse, citater osv

Men der er en fangst! Konventionelle git-systemer er ikke egnede til at håndtere store filer. Det styres gennem git-lfs (Large File Storage). Vi behøver ikke gå dybere ind i, hvordan det fungerer, vi kan blot køre følgende kommandoer for at kunne skubbe store filer til repoen:

$ git lfs install
$ git lfs track huggingface-modelhub.csv
$ git add dataset_infos.json huggingface-modelhub.csv huggingface-modelhub.py
$ git commit -m "Commit message"
$ git push origin main

Dokumentationen dækker også lfs i detaljer. Da dette kun er en git-repo, kan alle andre filer som README også blive begået. Dataset-hub UI giver også en hurtig måde at opdatere README (kaldet datasætkort)

Og det er det. Datasættet skal uploades til dataset-hub. For at få adgang til det, kør:

>>> dataset = load_dataset("<user>/<repo>")

Push ændringer til et offentliggjort datasæt:

Da repoen af ​​datasættet kan kontrolleres ved hjælp af git, tror jeg, det kan være en god praksis først at forpligte sig til en dev gren, test den fuldstændigt og udfør derefter fletningen til main . Det vil hjælpe meget med “ved et uheld” at ødelægge et allerede eksisterende og et stabilt, fungerende datasæt. Dette er meget analogt med standard git-baseret softwareudgivelsesfilosofi.

En anden fordel er, at datasætversionen heller ikke nødvendigvis behøver at være seriel (1, 1.1, 1.2 osv.). Forskellige grene kunne indeholde forskellige versioner af datasættet.

>>> dataset = load_dataset("<user>/<repo>",
>>>   script_version="dev")  # tag name, branch name, or commit hash

Hvad skal man gøre, når man sidder fast:

HuggingFace-forum er meget aktivt vedligeholdt, og teamet+fællesskabet er meget hjælpsomme og støttende. Jeg syntes personligt, at det var mere aktivt og hurtigt reagerende end stackoverflow. Man kunne også åbne problemer direkte på github, men jeg foretrækker fora, da de er lidt uformelle.

Intet spørgsmål er et dumt spørgsmål! Vær aldrig bange for at spørge.