model_sharing.md 11.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
<!--Copyright 2022 The HuggingFace Team. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
11
12
13
14

鈿狅笍 Note that this file is in Markdown but contain specific syntax for our doc-builder (similar to MDX) that may not be
rendered properly in your Markdown viewer.

15
16
17
18
-->

# Compartir un modelo

Omar U. Espejel's avatar
Omar U. Espejel committed
19
Los 煤ltimos dos tutoriales mostraron c贸mo puedes realizar fine-tunning a un modelo con PyTorch, Keras y 馃 Accelerate para configuraciones distribuidas. 隆El siguiente paso es compartir tu modelo con la comunidad! En Hugging Face creemos en compartir abiertamente a todos el conocimiento y los recursos para democratizar la inteligencia artificial. En este sentido, te animamos a considerar compartir tu modelo con la comunidad, de esta forma ayudas a otros ahorrando tiempo y recursos.
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

En este tutorial aprender谩s dos m茅todos para compartir un modelo trained o fine-tuned en el [Model Hub](https://huggingface.co/models):

- Mediante C贸digo, enviando (push) tus archivos al Hub.
- Con la interfaz Web, con Drag-and-drop de tus archivos al Hub.

<iframe width="560" height="315" src="https://www.youtube.com/embed/XvSGPZFEjDY" title="YouTube video player"
frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope;
picture-in-picture" allowfullscreen></iframe>

<Tip>

Para compartir un modelo con la comunidad necesitas una cuenta en [huggingface.co](https://huggingface.co/join). Tambi茅n puedes unirte a una organizaci贸n existente o crear una nueva.

</Tip>

## Caracter铆sticas de los repositorios

Cada repositorio en el Model Hub se comporta como cualquier otro repositorio en GitHub. Nuestros repositorios ofrecen versioning, commit history, y la habilidad para visualizar diferencias.

El versioning desarrollado dentro del Model Hub es basado en git y [git-lfs](https://git-lfs.github.com/). En otras palabras, puedes tratar un modelo como un repositorio, brindando un mejor control de acceso y escalabilidad. Version control permite *revisions*, un m茅todo para apuntar a una versi贸n espec铆fica de un modelo utilizando un commit hash, tag o branch.

Como resultado, puedes cargar una versi贸n espec铆fica del modelo con el par谩metro `revision`:

```py
>>> model = AutoModel.from_pretrained(
...     "julien-c/EsperBERTo-small", revision="v2.0.1"  # tag name, or branch name, or commit hash
... )
```

Omar U. Espejel's avatar
Omar U. Espejel committed
50
Los archivos son editados f谩cilmente dentro de un repositorio. Incluso puedes observar el commit history y las diferencias:
51
52
53
54
55

![vis_diff](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/vis_diff.png)

## Configuraci贸n inicial

56
Antes de compartir un modelo al Hub necesitar谩s tus credenciales de Hugging Face. Si tienes acceso a una terminal ejecuta el siguiente comando en el entorno virtual donde 馃 Transformers est茅 instalado. Esto guardar谩 tu token de acceso dentro de tu carpeta cache de Hugging Face (~/.cache/ by default):
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

```bash
huggingface-cli login
```

Si usas un notebook como Jupyter o Colaboratory, aseg煤rate de tener instalada la biblioteca [`huggingface_hub`](https://huggingface.co/docs/hub/adding-a-library). Esta biblioteca te permitir谩 interactuar por c贸digo con el Hub.

```bash
pip install huggingface_hub
```

Luego usa `notebook_login` para iniciar sesi贸n al Hub, y sigue el link [aqu铆](https://huggingface.co/settings/token) para generar un token con el que iniciaremos sesi贸n:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Convertir un modelo para todos los Frameworks

Omar U. Espejel's avatar
Omar U. Espejel committed
78
Para asegurarnos que tu modelo pueda ser usado por alguien que est茅 trabajando con un framework diferente, te recomendamos convertir y subir tu modelo con checkpoints de pytorch y tensorflow. Aunque los usuarios a煤n son capaces de cargar su modelo desde un framework diferente, si se omite este paso ser谩 m谩s lento debido a que 馃 Transformers necesitar谩 convertir el checkpoint sobre-la-marcha.
79
80
81

Convertir un checkpoint para otro framework es f谩cil. Aseg煤rate tener Pytorch y TensorFlow instalado (V茅ase [aqu铆](installation) para instrucciones de instalaci贸n), y luego encuentra el modelo espec铆fico para tu tarea en el otro Framework. 

Omar U. Espejel's avatar
Omar U. Espejel committed
82
Por ejemplo, supongamos que has entrenado DistilBert para clasificaci贸n de secuencias en PyTorch y quieres convertirlo a su equivalente en TensorFlow. Cargas el equivalente en TensorFlow de tu modelo para tu tarea y especificas `from_pt=True` as铆 馃 Transformers convertir谩 el Pytorch checkpoint a un TensorFlow Checkpoint:
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

```py
>>> tf_model = TFDistilBertForSequenceClassification.from_pretrained("path/to/awesome-name-you-picked", from_pt=True)
```

Luego guardas tu nuevo modelo TensorFlow con su nuevo checkpoint:

```py
>>> tf_model.save_pretrained("path/to/awesome-name-you-picked")
```

De manera similar, especificas `from_tf=True` para convertir un checkpoint de TensorFlow a Pytorch:

```py
>>> pt_model = DistilBertForSequenceClassification.from_pretrained("path/to/awesome-name-you-picked", from_tf=True)
>>> pt_model.save_pretrained("path/to/awesome-name-you-picked")
```

Si alg煤n modelo est谩 disponible en Flax, tambi茅n puedes convertir un checkpoint de Pytorch a Flax:

```py
>>> flax_model = FlaxDistilBertForSequenceClassification.from_pretrained(
...     "path/to/awesome-name-you-picked", from_pt=True
... )
```

## Compartir un modelo con `Trainer`

<Youtube id="Z1-XMy-GNLQ"/>

Compartir un modelo al Hub es tan simple como a帽adir un par谩metro extra o un callback. Si recuerdas del tutorial de [fine-tuning tutorial](training), la clase [`TrainingArguments`] es donde especificas los Hiperpar谩metros y opciones de entrenamiento adicionales. Una de estas opciones incluye la habilidad de compartir un modelo directamente al Hub. Para ello configuras `push_to_hub=True` dentro de [`TrainingArguments`]:

```py
>>> training_args = TrainingArguments(output_dir="my-awesome-model", push_to_hub=True)
```

Omar U. Espejel's avatar
Omar U. Espejel committed
119
A continuaci贸n, como usualmente, pasa tus argumentos de entrenamiento a [`Trainer`]:
120
121
122
123
124
125
126
127
128
129
130

```py
>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     train_dataset=small_train_dataset,
...     eval_dataset=small_eval_dataset,
...     compute_metrics=compute_metrics,
... )
```

Omar U. Espejel's avatar
Omar U. Espejel committed
131
Luego que realizas fine-tune a tu modelo, llamas [`~transformers.Trainer.push_to_hub`] en [`Trainer`] para enviar el modelo al Hub!馃 Transformers incluso a帽adir谩 autom谩ticamente los Hiperpar谩metros de entrenamiento, resultados de entrenamiento y versiones del Framework a tu model card!
132
133
134
135
136
137
138
139
140
141

```py
>>> trainer.push_to_hub()
```

## Compartir un modelo con `PushToHubCallback`

Los usuarios de TensorFlow pueden activar la misma funcionalidad con [`PushToHubCallback`]. En la funcion [`PushToHubCallback`], agrega:

- Un directorio de salida para tu modelo.
Omar U. Espejel's avatar
Omar U. Espejel committed
142
- Un tokenizador.
143
144
145
- El `hub_model_id`, el cual es tu usuario Hub y el nombre del modelo.

```py
146
>>> from transformers import PushToHubCallback
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

>>> push_to_hub_callback = PushToHubCallback(
...     output_dir="./your_model_save_path", tokenizer=tokenizer, hub_model_id="your-username/my-awesome-model"
... )
```

Agregamos el callback a [`fit`](https://keras.io/api/models/model_training_apis/), y 馃 Transformers enviar谩 el modelo entrenado al Hub:

```py
>>> model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=3, callbacks=push_to_hub_callback)
```

## Usando la funci贸n `push_to_hub`

Puedes llamar la funci贸n `push_to_hub` directamente en tu modelo para subirlo al Hub.

Omar U. Espejel's avatar
Omar U. Espejel committed
163
Especifica el nombre del modelo en `push_to_hub`:
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

```py
>>> pt_model.push_to_hub("my-awesome-model")
```

Esto crear谩 un repositorio bajo tu usuario con el nombre del modelo `my-awesome-model`. Ahora los usuarios pueden cargar tu modelo con la funci贸n `from_pretrained`:

```py
>>> from transformers import AutoModel

>>> model = AutoModel.from_pretrained("your_username/my-awesome-model")
```

Si perteneces a una organizaci贸n y quieres compartir tu modelo bajo el nombre de la organizaci贸n, a帽ade el par谩metro `organization`:

```py
>>> pt_model.push_to_hub("my-awesome-model", organization="my-awesome-org")
```

Omar U. Espejel's avatar
Omar U. Espejel committed
183
La funci贸n `push_to_hub` tambi茅n puede ser usada para a帽adir archivos al repositorio del modelo. Por ejemplo, a帽ade un tokenizador al repositorio:
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

```py
>>> tokenizer.push_to_hub("my-awesome-model")
```

O quiz谩s te gustar铆a a帽adir la versi贸n de TensorFlow de tu modelo fine-tuned en Pytorch:

```py
>>> tf_model.push_to_hub("my-awesome-model")
```

Ahora, cuando navegues a tu perfil en Hugging Face, deber铆as observar el repositorio de tu modelo creado recientemente. Si das click en el tab **Files** observar谩s todos los archivos que has subido al repositorio.

Para m谩s detalles sobre c贸mo crear y subir archivos al repositorio, consulta la [documentaci贸n del Hub](https://huggingface.co/docs/hub/how-to-upstream).

## Compartir con la interfaz web

Los usuarios que prefieran un enfoque no-code tienen la opci贸n de cargar su modelo a trav茅s de la interfaz gr谩fica del Hub. Visita la p谩gina [huggingface.co/new](https://huggingface.co/new) para crear un nuevo repositorio:

![new_model_repo](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/new_model_repo.png)

Desde aqu铆, a帽ade informaci贸n acerca del modelo:

- Selecciona el **owner** (la persona propietaria) del repositorio. Puedes ser t煤 o cualquier organizaci贸n a la que pertenezcas.
- Escoge un nombre para tu modelo. Tambi茅n ser谩 el nombre del repositorio.
- Elige si tu modelo es p煤blico o privado.
Omar U. Espejel's avatar
Omar U. Espejel committed
210
- Especifica la licencia que usar谩 tu modelo.
211
212
213
214
215
216
217
218
219
220
221
222

Ahora puedes hacer click en el tab **Files** y luego en el bot贸n **Add file** para subir un nuevo archivo a tu repositorio. Luego arrastra y suelta un archivo a subir y le a帽ades un mensaje al commit.

![upload_file](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/upload_file.png)

## A帽adiendo una tarjeta de modelo

Para asegurarnos que los usuarios entiendan las capacidades de tu modelo, sus limitaciones, posibles sesgos y consideraciones 茅ticas, por favor a帽ade una tarjeta (como una tarjeta de presentaci贸n) al repositorio del modelo. La tarjeta de modelo es definida en el archivo `README.md`. Puedes agregar una de la siguiente manera:

* Elaborando y subiendo manualmente el archivo`README.md`.
* Dando click en el bot贸n **Edit model card** dentro del repositorio.

223
Toma un momento para ver la [tarjeta de modelo](https://huggingface.co/distilbert-base-uncased) de DistilBert para que tengas un buen ejemplo del tipo de informaci贸n que deber铆a incluir. Consulta [la documentaci贸n](https://huggingface.co/docs/hub/models-cards) para m谩s detalles acerca de otras opciones que puedes controlar dentro del archivo `README.md` como la huella de carbono del modelo o ejemplos de widgets. Consulta la documentaci贸n [aqu铆] (https://huggingface.co/docs/hub/models-cards).