![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\"){kind=icon}
"
29 | ]
30 | },
31 | {
32 | "cell_type": "markdown",
33 | "source": [
34 | "# 4-bit LLM Quantization with GPTQ\n",
35 | "> 🗣️ [Large Language Model Course](https://github.com/mlabonne/llm-course)\n",
36 | "\n",
37 | "❤️ Created by [@maximelabonne](https://twitter.com/maximelabonne).\n",
38 | "\n",
39 | "Companion notebook to execute the code from the following article: https://mlabonne.github.io/blog/4bit_quantization/"
40 | ],
41 | "metadata": {
42 | "id": "yezrHxYvg_wR"
43 | }
44 | },
45 | {
46 | "cell_type": "code",
47 | "execution_count": null,
48 | "metadata": {
49 | "id": "BhufqqQAaz6e"
50 | },
51 | "outputs": [],
52 | "source": [
53 | "!BUILD_CUDA_EXT=0 pip install -q auto-gptq transformers"
54 | ]
55 | },
56 | {
57 | "cell_type": "code",
58 | "source": [
59 | "import random\n",
60 | "\n",
61 | "from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig\n",
62 | "from datasets import load_dataset\n",
63 | "import torch\n",
64 | "from transformers import AutoTokenizer\n",
65 | "\n",
66 | "\n",
67 | "# Define base model and output directory\n",
68 | "model_id = \"gpt2\"\n",
69 | "out_dir = model_id + \"-GPTQ\""
70 | ],
71 | "metadata": {
72 | "id": "dg8NyBL0ZNyw"
73 | },
74 | "execution_count": null,
75 | "outputs": []
76 | },
77 | {
78 | "cell_type": "code",
79 | "source": [
80 | "# Load quantize config, model and tokenizer\n",
81 | "quantize_config = BaseQuantizeConfig(\n",
82 | " bits=4,\n",
83 | " group_size=128,\n",
84 | " damp_percent=0.01,\n",
85 | " desc_act=False,\n",
86 | ")\n",
87 | "model = AutoGPTQForCausalLM.from_pretrained(model_id, quantize_config)\n",
88 | "tokenizer = AutoTokenizer.from_pretrained(model_id)"
89 | ],
90 | "metadata": {
91 | "id": "C9352jN0ZP6I"
92 | },
93 | "execution_count": null,
94 | "outputs": []
95 | },
96 | {
97 | "cell_type": "code",
98 | "source": [
99 | "# Load data and tokenize examples\n",
100 | "n_samples = 1024\n",
101 | "data = load_dataset(\"allenai/c4\", data_files=\"en/c4-train.00001-of-01024.json.gz\", split=f\"train[:{n_samples*5}]\")\n",
102 | "tokenized_data = tokenizer(\"\\n\\n\".join(data['text']), return_tensors='pt')\n",
103 | "\n",
104 | "# Format tokenized examples\n",
105 | "examples_ids = []\n",
106 | "for _ in range(n_samples):\n",
107 | " i = random.randint(0, tokenized_data.input_ids.shape[1] - tokenizer.model_max_length - 1)\n",
108 | " j = i + tokenizer.model_max_length\n",
109 | " input_ids = tokenized_data.input_ids[:, i:j]\n",
110 | " attention_mask = torch.ones_like(input_ids)\n",
111 | " examples_ids.append({'input_ids': input_ids, 'attention_mask': attention_mask})"
112 | ],
113 | "metadata": {
114 | "id": "6wuBLe6aZSe-",
115 | "colab": {
116 | "base_uri": "https://localhost:8080/"
117 | },
118 | "outputId": "e4ebd71a-2854-4347-cebe-08cf040d1eb6"
119 | },
120 | "execution_count": null,
121 | "outputs": [
122 | {
123 | "output_type": "stream",
124 | "name": "stderr",
125 | "text": [
126 | "WARNING:datasets.builder:Found cached dataset json (/root/.cache/huggingface/datasets/allenai___json/allenai--c4-6e494e9c0ee1404e/0.0.0/8bb11242116d547c741b2e8a1f18598ffdd40a1d4f2a2872c7a28b697434bc96)\n",
127 | "Token indices sequence length is longer than the specified maximum sequence length for this model (2441065 > 1024). Running this sequence through the model will result in indexing errors\n"
128 | ]
129 | }
130 | ]
131 | },
132 | {
133 | "cell_type": "code",
134 | "source": [
135 | "%%time\n",
136 | "\n",
137 | "# Quantize with GPTQ\n",
138 | "model.quantize(\n",
139 | " examples_ids,\n",
140 | " batch_size=1,\n",
141 | " use_triton=True,\n",
142 | ")\n",
143 | "\n",
144 | "# Save model and tokenizer\n",
145 | "model.save_quantized(out_dir, use_safetensors=True)\n",
146 | "tokenizer.save_pretrained(out_dir)"
147 | ],
148 | "metadata": {
149 | "id": "ETsG2iYrXaUg",
150 | "colab": {
151 | "base_uri": "https://localhost:8080/"
152 | },
153 | "outputId": "e48b825e-0ebc-4a73-dbfd-b5571cafd24e"
154 | },
155 | "execution_count": null,
156 | "outputs": [
157 | {
158 | "output_type": "stream",
159 | "name": "stdout",
160 | "text": [
161 | "CPU times: user 4min 35s, sys: 3.49 s, total: 4min 39s\n",
162 | "Wall time: 5min 8s\n"
163 | ]
164 | },
165 | {
166 | "output_type": "execute_result",
167 | "data": {
168 | "text/plain": [
169 | "('gpt2-GPTQ/tokenizer_config.json',\n",
170 | " 'gpt2-GPTQ/special_tokens_map.json',\n",
171 | " 'gpt2-GPTQ/vocab.json',\n",
172 | " 'gpt2-GPTQ/merges.txt',\n",
173 | " 'gpt2-GPTQ/added_tokens.json',\n",
174 | " 'gpt2-GPTQ/tokenizer.json')"
175 | ]
176 | },
177 | "metadata": {},
178 | "execution_count": 5
179 | }
180 | ]
181 | },
182 | {
183 | "cell_type": "code",
184 | "source": [
185 | "device = \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n",
186 | "\n",
187 | "# Reload model and tokenizer\n",
188 | "model = AutoGPTQForCausalLM.from_quantized(\n",
189 | " out_dir,\n",
190 | " device=device,\n",
191 | " use_triton=True,\n",
192 | " use_safetensors=True,\n",
193 | ")\n",
194 | "tokenizer = AutoTokenizer.from_pretrained(out_dir)"
195 | ],
196 | "metadata": {
197 | "id": "nktu1FsdZ9sd",
198 | "colab": {
199 | "base_uri": "https://localhost:8080/"
200 | },
201 | "outputId": "9943c829-1b58-474a-f245-6aefa09d81dc"
202 | },
203 | "execution_count": null,
204 | "outputs": [
205 | {
206 | "output_type": "stream",
207 | "name": "stderr",
208 | "text": [
209 | "WARNING:accelerate.utils.modeling:The safetensors archive passed at gpt2-GPTQ/gptq_model-4bit-128g.safetensors does not contain metadata. Make sure to save your model with the `save_pretrained` method. Defaulting to 'pt' metadata.\n",
210 | "WARNING:auto_gptq.modeling._base:GPT2GPTQForCausalLM hasn't fused attention module yet, will skip inject fused attention.\n",
211 | "WARNING:auto_gptq.modeling._base:GPT2GPTQForCausalLM hasn't fused mlp module yet, will skip inject fused mlp.\n"
212 | ]
213 | }
214 | ]
215 | },
216 | {
217 | "cell_type": "code",
218 | "source": [
219 | "from transformers import pipeline\n",
220 | "\n",
221 | "generator = pipeline('text-generation', model=model, tokenizer=tokenizer)\n",
222 | "result = generator(\"I have a dream\", do_sample=True, max_length=50)[0]['generated_text']\n",
223 | "print(result)"
224 | ],
225 | "metadata": {
226 | "colab": {
227 | "base_uri": "https://localhost:8080/"
228 | },
229 | "id": "cRhIGrXdiFdt",
230 | "outputId": "6dca2078-6f01-44da-9895-3a03bdfb4b5b"
231 | },
232 | "execution_count": null,
233 | "outputs": [
234 | {
235 | "output_type": "stream",
236 | "name": "stderr",
237 | "text": [
238 | "The model 'GPT2GPTQForCausalLM' is not supported for text-generation. Supported models are ['BartForCausalLM', 'BertLMHeadModel', 'BertGenerationDecoder', 'BigBirdForCausalLM', 'BigBirdPegasusForCausalLM', 'BioGptForCausalLM', 'BlenderbotForCausalLM', 'BlenderbotSmallForCausalLM', 'BloomForCausalLM', 'CamembertForCausalLM', 'CodeGenForCausalLM', 'CpmAntForCausalLM', 'CTRLLMHeadModel', 'Data2VecTextForCausalLM', 'ElectraForCausalLM', 'ErnieForCausalLM', 'FalconForCausalLM', 'GitForCausalLM', 'GPT2LMHeadModel', 'GPT2LMHeadModel', 'GPTBigCodeForCausalLM', 'GPTNeoForCausalLM', 'GPTNeoXForCausalLM', 'GPTNeoXJapaneseForCausalLM', 'GPTJForCausalLM', 'LlamaForCausalLM', 'MarianForCausalLM', 'MBartForCausalLM', 'MegaForCausalLM', 'MegatronBertForCausalLM', 'MusicgenForCausalLM', 'MvpForCausalLM', 'OpenLlamaForCausalLM', 'OpenAIGPTLMHeadModel', 'OPTForCausalLM', 'PegasusForCausalLM', 'PLBartForCausalLM', 'ProphetNetForCausalLM', 'QDQBertLMHeadModel', 'ReformerModelWithLMHead', 'RemBertForCausalLM', 'RobertaForCausalLM', 'RobertaPreLayerNormForCausalLM', 'RoCBertForCausalLM', 'RoFormerForCausalLM', 'RwkvForCausalLM', 'Speech2Text2ForCausalLM', 'TransfoXLLMHeadModel', 'TrOCRForCausalLM', 'XGLMForCausalLM', 'XLMWithLMHeadModel', 'XLMProphetNetForCausalLM', 'XLMRobertaForCausalLM', 'XLMRobertaXLForCausalLM', 'XLNetLMHeadModel', 'XmodForCausalLM'].\n",
239 | "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
240 | ]
241 | },
242 | {
243 | "output_type": "stream",
244 | "name": "stdout",
245 | "text": [
246 | "I have a dream,\" she told CNN last week. \"I have this dream of helping my mother find her own. But, to tell that for the first time, now that I'm seeing my mother now, just knowing how wonderful it is that\n"
247 | ]
248 | }
249 | ]
250 | }
251 | ]
252 | }
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "[]"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright [yyyy] [name of copyright owner]
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
--------------------------------------------------------------------------------
/notebooks/Fine_tune_a_Mistral_7b_model_with_DPO.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "nbformat": 4,
3 | "nbformat_minor": 0,
4 | "metadata": {
5 | "colab": {
6 | "provenance": [],
7 | "machine_shape": "hm",
8 | "gpuType": "A100",
9 | "authorship_tag": "ABX9TyOJJCuqxZQnS1q+Fvz5+URG",
10 | "include_colab_link": true
11 | },
12 | "kernelspec": {
13 | "name": "python3",
14 | "display_name": "Python 3"
15 | },
16 | "language_info": {
17 | "name": "python"
18 | },
19 | "widgets": {
20 | "application/vnd.jupyter.widget-state+json": {
21 | "22773c721a7c4221a9c14cd388461d4c": {
22 | "model_module": "@jupyter-widgets/controls",
23 | "model_name": "HBoxModel",
24 | "model_module_version": "1.5.0",
25 | "state": {
26 | "_dom_classes": [],
27 | "_model_module": "@jupyter-widgets/controls",
28 | "_model_module_version": "1.5.0",
29 | "_model_name": "HBoxModel",
30 | "_view_count": null,
31 | "_view_module": "@jupyter-widgets/controls",
32 | "_view_module_version": "1.5.0",
33 | "_view_name": "HBoxView",
34 | "box_style": "",
35 | "children": [
36 | "IPY_MODEL_6b54841f5de1482694c360095dae3039",
37 | "IPY_MODEL_448ccbc85e624ec3b3e71931a7ee4ff6",
38 | "IPY_MODEL_173769f6f465485f8848a11bf269850b"
39 | ],
40 | "layout": "IPY_MODEL_60978b9b4e8348f0a71ce3e35c73bcff"
41 | }
42 | },
43 | "6b54841f5de1482694c360095dae3039": {
44 | "model_module": "@jupyter-widgets/controls",
45 | "model_name": "HTMLModel",
46 | "model_module_version": "1.5.0",
47 | "state": {
48 | "_dom_classes": [],
49 | "_model_module": "@jupyter-widgets/controls",
50 | "_model_module_version": "1.5.0",
51 | "_model_name": "HTMLModel",
52 | "_view_count": null,
53 | "_view_module": "@jupyter-widgets/controls",
54 | "_view_module_version": "1.5.0",
55 | "_view_name": "HTMLView",
56 | "description": "",
57 | "description_tooltip": null,
58 | "layout": "IPY_MODEL_6a38dcbaf4674b448329ac0a16587d2a",
59 | "placeholder": "",
60 | "style": "IPY_MODEL_7eaeada2158e493189449af91f643553",
61 | "value": "Loading checkpoint shards: 100%"
62 | }
63 | },
64 | "448ccbc85e624ec3b3e71931a7ee4ff6": {
65 | "model_module": "@jupyter-widgets/controls",
66 | "model_name": "FloatProgressModel",
67 | "model_module_version": "1.5.0",
68 | "state": {
69 | "_dom_classes": [],
70 | "_model_module": "@jupyter-widgets/controls",
71 | "_model_module_version": "1.5.0",
72 | "_model_name": "FloatProgressModel",
73 | "_view_count": null,
74 | "_view_module": "@jupyter-widgets/controls",
75 | "_view_module_version": "1.5.0",
76 | "_view_name": "ProgressView",
77 | "bar_style": "success",
78 | "description": "",
79 | "description_tooltip": null,
80 | "layout": "IPY_MODEL_6e32854952b340008edca0139d3471d6",
81 | "max": 3,
82 | "min": 0,
83 | "orientation": "horizontal",
84 | "style": "IPY_MODEL_db6d7cfcdade4b4baa213a5d0abc07d7",
85 | "value": 3
86 | }
87 | },
88 | "173769f6f465485f8848a11bf269850b": {
89 | "model_module": "@jupyter-widgets/controls",
90 | "model_name": "HTMLModel",
91 | "model_module_version": "1.5.0",
92 | "state": {
93 | "_dom_classes": [],
94 | "_model_module": "@jupyter-widgets/controls",
95 | "_model_module_version": "1.5.0",
96 | "_model_name": "HTMLModel",
97 | "_view_count": null,
98 | "_view_module": "@jupyter-widgets/controls",
99 | "_view_module_version": "1.5.0",
100 | "_view_name": "HTMLView",
101 | "description": "",
102 | "description_tooltip": null,
103 | "layout": "IPY_MODEL_9083029642744c43b7705532cbe0cf79",
104 | "placeholder": "",
105 | "style": "IPY_MODEL_d028a98caa13425b907ceb513119006e",
106 | "value": " 3/3 [00:11<00:00, 2.89s/it]"
107 | }
108 | },
109 | "60978b9b4e8348f0a71ce3e35c73bcff": {
110 | "model_module": "@jupyter-widgets/base",
111 | "model_name": "LayoutModel",
112 | "model_module_version": "1.2.0",
113 | "state": {
114 | "_model_module": "@jupyter-widgets/base",
115 | "_model_module_version": "1.2.0",
116 | "_model_name": "LayoutModel",
117 | "_view_count": null,
118 | "_view_module": "@jupyter-widgets/base",
119 | "_view_module_version": "1.2.0",
120 | "_view_name": "LayoutView",
121 | "align_content": null,
122 | "align_items": null,
123 | "align_self": null,
124 | "border": null,
125 | "bottom": null,
126 | "display": null,
127 | "flex": null,
128 | "flex_flow": null,
129 | "grid_area": null,
130 | "grid_auto_columns": null,
131 | "grid_auto_flow": null,
132 | "grid_auto_rows": null,
133 | "grid_column": null,
134 | "grid_gap": null,
135 | "grid_row": null,
136 | "grid_template_areas": null,
137 | "grid_template_columns": null,
138 | "grid_template_rows": null,
139 | "height": null,
140 | "justify_content": null,
141 | "justify_items": null,
142 | "left": null,
143 | "margin": null,
144 | "max_height": null,
145 | "max_width": null,
146 | "min_height": null,
147 | "min_width": null,
148 | "object_fit": null,
149 | "object_position": null,
150 | "order": null,
151 | "overflow": null,
152 | "overflow_x": null,
153 | "overflow_y": null,
154 | "padding": null,
155 | "right": null,
156 | "top": null,
157 | "visibility": null,
158 | "width": null
159 | }
160 | },
161 | "6a38dcbaf4674b448329ac0a16587d2a": {
162 | "model_module": "@jupyter-widgets/base",
163 | "model_name": "LayoutModel",
164 | "model_module_version": "1.2.0",
165 | "state": {
166 | "_model_module": "@jupyter-widgets/base",
167 | "_model_module_version": "1.2.0",
168 | "_model_name": "LayoutModel",
169 | "_view_count": null,
170 | "_view_module": "@jupyter-widgets/base",
171 | "_view_module_version": "1.2.0",
172 | "_view_name": "LayoutView",
173 | "align_content": null,
174 | "align_items": null,
175 | "align_self": null,
176 | "border": null,
177 | "bottom": null,
178 | "display": null,
179 | "flex": null,
180 | "flex_flow": null,
181 | "grid_area": null,
182 | "grid_auto_columns": null,
183 | "grid_auto_flow": null,
184 | "grid_auto_rows": null,
185 | "grid_column": null,
186 | "grid_gap": null,
187 | "grid_row": null,
188 | "grid_template_areas": null,
189 | "grid_template_columns": null,
190 | "grid_template_rows": null,
191 | "height": null,
192 | "justify_content": null,
193 | "justify_items": null,
194 | "left": null,
195 | "margin": null,
196 | "max_height": null,
197 | "max_width": null,
198 | "min_height": null,
199 | "min_width": null,
200 | "object_fit": null,
201 | "object_position": null,
202 | "order": null,
203 | "overflow": null,
204 | "overflow_x": null,
205 | "overflow_y": null,
206 | "padding": null,
207 | "right": null,
208 | "top": null,
209 | "visibility": null,
210 | "width": null
211 | }
212 | },
213 | "7eaeada2158e493189449af91f643553": {
214 | "model_module": "@jupyter-widgets/controls",
215 | "model_name": "DescriptionStyleModel",
216 | "model_module_version": "1.5.0",
217 | "state": {
218 | "_model_module": "@jupyter-widgets/controls",
219 | "_model_module_version": "1.5.0",
220 | "_model_name": "DescriptionStyleModel",
221 | "_view_count": null,
222 | "_view_module": "@jupyter-widgets/base",
223 | "_view_module_version": "1.2.0",
224 | "_view_name": "StyleView",
225 | "description_width": ""
226 | }
227 | },
228 | "6e32854952b340008edca0139d3471d6": {
229 | "model_module": "@jupyter-widgets/base",
230 | "model_name": "LayoutModel",
231 | "model_module_version": "1.2.0",
232 | "state": {
233 | "_model_module": "@jupyter-widgets/base",
234 | "_model_module_version": "1.2.0",
235 | "_model_name": "LayoutModel",
236 | "_view_count": null,
237 | "_view_module": "@jupyter-widgets/base",
238 | "_view_module_version": "1.2.0",
239 | "_view_name": "LayoutView",
240 | "align_content": null,
241 | "align_items": null,
242 | "align_self": null,
243 | "border": null,
244 | "bottom": null,
245 | "display": null,
246 | "flex": null,
247 | "flex_flow": null,
248 | "grid_area": null,
249 | "grid_auto_columns": null,
250 | "grid_auto_flow": null,
251 | "grid_auto_rows": null,
252 | "grid_column": null,
253 | "grid_gap": null,
254 | "grid_row": null,
255 | "grid_template_areas": null,
256 | "grid_template_columns": null,
257 | "grid_template_rows": null,
258 | "height": null,
259 | "justify_content": null,
260 | "justify_items": null,
261 | "left": null,
262 | "margin": null,
263 | "max_height": null,
264 | "max_width": null,
265 | "min_height": null,
266 | "min_width": null,
267 | "object_fit": null,
268 | "object_position": null,
269 | "order": null,
270 | "overflow": null,
271 | "overflow_x": null,
272 | "overflow_y": null,
273 | "padding": null,
274 | "right": null,
275 | "top": null,
276 | "visibility": null,
277 | "width": null
278 | }
279 | },
280 | "db6d7cfcdade4b4baa213a5d0abc07d7": {
281 | "model_module": "@jupyter-widgets/controls",
282 | "model_name": "ProgressStyleModel",
283 | "model_module_version": "1.5.0",
284 | "state": {
285 | "_model_module": "@jupyter-widgets/controls",
286 | "_model_module_version": "1.5.0",
287 | "_model_name": "ProgressStyleModel",
288 | "_view_count": null,
289 | "_view_module": "@jupyter-widgets/base",
290 | "_view_module_version": "1.2.0",
291 | "_view_name": "StyleView",
292 | "bar_color": null,
293 | "description_width": ""
294 | }
295 | },
296 | "9083029642744c43b7705532cbe0cf79": {
297 | "model_module": "@jupyter-widgets/base",
298 | "model_name": "LayoutModel",
299 | "model_module_version": "1.2.0",
300 | "state": {
301 | "_model_module": "@jupyter-widgets/base",
302 | "_model_module_version": "1.2.0",
303 | "_model_name": "LayoutModel",
304 | "_view_count": null,
305 | "_view_module": "@jupyter-widgets/base",
306 | "_view_module_version": "1.2.0",
307 | "_view_name": "LayoutView",
308 | "align_content": null,
309 | "align_items": null,
310 | "align_self": null,
311 | "border": null,
312 | "bottom": null,
313 | "display": null,
314 | "flex": null,
315 | "flex_flow": null,
316 | "grid_area": null,
317 | "grid_auto_columns": null,
318 | "grid_auto_flow": null,
319 | "grid_auto_rows": null,
320 | "grid_column": null,
321 | "grid_gap": null,
322 | "grid_row": null,
323 | "grid_template_areas": null,
324 | "grid_template_columns": null,
325 | "grid_template_rows": null,
326 | "height": null,
327 | "justify_content": null,
328 | "justify_items": null,
329 | "left": null,
330 | "margin": null,
331 | "max_height": null,
332 | "max_width": null,
333 | "min_height": null,
334 | "min_width": null,
335 | "object_fit": null,
336 | "object_position": null,
337 | "order": null,
338 | "overflow": null,
339 | "overflow_x": null,
340 | "overflow_y": null,
341 | "padding": null,
342 | "right": null,
343 | "top": null,
344 | "visibility": null,
345 | "width": null
346 | }
347 | },
348 | "d028a98caa13425b907ceb513119006e": {
349 | "model_module": "@jupyter-widgets/controls",
350 | "model_name": "DescriptionStyleModel",
351 | "model_module_version": "1.5.0",
352 | "state": {
353 | "_model_module": "@jupyter-widgets/controls",
354 | "_model_module_version": "1.5.0",
355 | "_model_name": "DescriptionStyleModel",
356 | "_view_count": null,
357 | "_view_module": "@jupyter-widgets/base",
358 | "_view_module_version": "1.2.0",
359 | "_view_name": "StyleView",
360 | "description_width": ""
361 | }
362 | }
363 | }
364 | },
365 | "accelerator": "GPU"
366 | },
367 | "cells": [
368 | {
369 | "cell_type": "markdown",
370 | "metadata": {
371 | "id": "view-in-github",
372 | "colab_type": "text"
373 | },
374 | "source": [
375 | ""
376 | ]
377 | },
378 | {
379 | "cell_type": "markdown",
380 | "source": [
381 | "# Fine-tune a Mistral-7b model with DPO\n",
382 | "\n",
383 | "❤️ Created by [@maximelabonne](https://twitter.com/maximelabonne)."
384 | ],
385 | "metadata": {
386 | "id": "Pa8905-YsHAn"
387 | }
388 | },
389 | {
390 | "cell_type": "code",
391 | "execution_count": null,
392 | "metadata": {
393 | "id": "_zIBL8IssExG"
394 | },
395 | "outputs": [],
396 | "source": [
397 | "!pip install -q datasets trl peft bitsandbytes sentencepiece wandb"
398 | ]
399 | },
400 | {
401 | "cell_type": "code",
402 | "source": [
403 | "import os\n",
404 | "import gc\n",
405 | "import torch\n",
406 | "\n",
407 | "import transformers\n",
408 | "from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, BitsAndBytesConfig\n",
409 | "from datasets import load_dataset\n",
410 | "from peft import LoraConfig, PeftModel, get_peft_model, prepare_model_for_kbit_training\n",
411 | "from trl import DPOTrainer\n",
412 | "import bitsandbytes as bnb\n",
413 | "from google.colab import userdata\n",
414 | "import wandb\n",
415 | "\n",
416 | "# Defined in the secrets tab in Google Colab\n",
417 | "hf_token = userdata.get('huggingface')\n",
418 | "wb_token = userdata.get('wandb')\n",
419 | "wandb.login(key=wb_token)\n",
420 | "\n",
421 | "model_name = \"teknium/OpenHermes-2.5-Mistral-7B\"\n",
422 | "new_model = \"NeuralHermes-2.5-Mistral-7B\""
423 | ],
424 | "metadata": {
425 | "colab": {
426 | "base_uri": "https://localhost:8080/"
427 | },
428 | "id": "YpdkZsMNylvp",
429 | "outputId": "6c2df234-1ce7-4cd2-a7e3-567e7536319f"
430 | },
431 | "execution_count": null,
432 | "outputs": [
433 | {
434 | "output_type": "stream",
435 | "name": "stderr",
436 | "text": [
437 | "/usr/local/lib/python3.10/dist-packages/trl/trainer/ppo_config.py:141: UserWarning: The `optimize_cuda_cache` arguement will be deprecated soon, please use `optimize_device_cache` instead.\n",
438 | " warnings.warn(\n",
439 | "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mmlabonne\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n",
440 | "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m If you're specifying your api key in code, ensure this code is not shared publicly.\n",
441 | "\u001b[34m\u001b[1mwandb\u001b[0m: \u001b[33mWARNING\u001b[0m Consider setting the WANDB_API_KEY environment variable, or running `wandb login` from the command line.\n",
442 | "\u001b[34m\u001b[1mwandb\u001b[0m: Appending key for api.wandb.ai to your netrc file: /root/.netrc\n"
443 | ]
444 | }
445 | ]
446 | },
447 | {
448 | "cell_type": "markdown",
449 | "source": [
450 | "## Format dataset"
451 | ],
452 | "metadata": {
453 | "id": "d8CvUgROUDw-"
454 | }
455 | },
456 | {
457 | "cell_type": "code",
458 | "source": [
459 | "def chatml_format(example):\n",
460 | " # Format system\n",
461 | " if len(example['system']) > 0:\n",
462 | " message = {\"role\": \"system\", \"content\": example['system']}\n",
463 | " system = tokenizer.apply_chat_template([message], tokenize=False)\n",
464 | " else:\n",
465 | " system = \"\"\n",
466 | "\n",
467 | " # Format instruction\n",
468 | " message = {\"role\": \"user\", \"content\": example['question']}\n",
469 | " prompt = tokenizer.apply_chat_template([message], tokenize=False, add_generation_prompt=True)\n",
470 | "\n",
471 | " # Format chosen answer\n",
472 | " chosen = example['chatgpt'] + \"<|im_end|>\\n\"\n",
473 | "\n",
474 | " # Format rejected answer\n",
475 | " rejected = example['llama2-13b-chat'] + \"<|im_end|>\\n\"\n",
476 | "\n",
477 | " return {\n",
478 | " \"prompt\": system + prompt,\n",
479 | " \"chosen\": chosen,\n",
480 | " \"rejected\": rejected,\n",
481 | " }\n",
482 | "\n",
483 | "# Load dataset\n",
484 | "dataset = load_dataset(\"Intel/orca_dpo_pairs\")['train']\n",
485 | "\n",
486 | "# Save columns\n",
487 | "original_columns = dataset.column_names\n",
488 | "\n",
489 | "# Tokenizer\n",
490 | "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
491 | "tokenizer.pad_token = tokenizer.eos_token\n",
492 | "tokenizer.padding_side = \"left\"\n",
493 | "\n",
494 | "# Format dataset\n",
495 | "dataset = dataset.map(\n",
496 | " chatml_format,\n",
497 | " remove_columns=original_columns\n",
498 | ")\n",
499 | "\n",
500 | "# Print sample\n",
501 | "dataset[1]"
502 | ],
503 | "metadata": {
504 | "colab": {
505 | "base_uri": "https://localhost:8080/"
506 | },
507 | "id": "MCD77GZ60DOT",
508 | "outputId": "c7c6773c-5545-4fee-bfa3-6fa6d69c0f3f"
509 | },
510 | "execution_count": null,
511 | "outputs": [
512 | {
513 | "output_type": "stream",
514 | "name": "stderr",
515 | "text": [
516 | "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n",
517 | "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
518 | ]
519 | },
520 | {
521 | "output_type": "execute_result",
522 | "data": {
523 | "text/plain": [
524 | "{'prompt': '<|im_start|>system\\nYou are an AI assistant. You will be given a task. You must generate a detailed and long answer.<|im_end|>\\n<|im_start|>user\\nGenerate an approximately fifteen-word sentence that describes all this data: Midsummer House eatType restaurant; Midsummer House food Chinese; Midsummer House priceRange moderate; Midsummer House customer rating 3 out of 5; Midsummer House near All Bar One<|im_end|>\\n<|im_start|>assistant\\n',\n",
525 | " 'chosen': 'Midsummer House is a moderately priced Chinese restaurant with a 3/5 customer rating, located near All Bar One.<|im_end|>\\n',\n",
526 | " 'rejected': ' Sure! Here\\'s a sentence that describes all the data you provided:\\n\\n\"Midsummer House is a moderately priced Chinese restaurant with a customer rating of 3 out of 5, located near All Bar One, offering a variety of delicious dishes.\"<|im_end|>\\n'}"
527 | ]
528 | },
529 | "metadata": {},
530 | "execution_count": 3
531 | }
532 | ]
533 | },
534 | {
535 | "cell_type": "markdown",
536 | "source": [
537 | "## Train model with DPO"
538 | ],
539 | "metadata": {
540 | "id": "DeT5eUK_UJgK"
541 | }
542 | },
543 | {
544 | "cell_type": "code",
545 | "source": [
546 | "# LoRA configuration\n",
547 | "peft_config = LoraConfig(\n",
548 | " r=16,\n",
549 | " lora_alpha=16,\n",
550 | " lora_dropout=0.05,\n",
551 | " bias=\"none\",\n",
552 | " task_type=\"CAUSAL_LM\",\n",
553 | " target_modules=['k_proj', 'gate_proj', 'v_proj', 'up_proj', 'q_proj', 'o_proj', 'down_proj']\n",
554 | ")\n",
555 | "\n",
556 | "# Model to fine-tune\n",
557 | "model = AutoModelForCausalLM.from_pretrained(\n",
558 | " model_name,\n",
559 | " torch_dtype=torch.float16,\n",
560 | " load_in_4bit=True\n",
561 | ")\n",
562 | "model.config.use_cache = False\n",
563 | "\n",
564 | "# Reference model\n",
565 | "ref_model = AutoModelForCausalLM.from_pretrained(\n",
566 | " model_name,\n",
567 | " torch_dtype=torch.float16,\n",
568 | " load_in_4bit=True\n",
569 | ")\n",
570 | "\n",
571 | "# Training arguments\n",
572 | "training_args = TrainingArguments(\n",
573 | " per_device_train_batch_size=4,\n",
574 | " gradient_accumulation_steps=4,\n",
575 | " gradient_checkpointing=True,\n",
576 | " learning_rate=5e-5,\n",
577 | " lr_scheduler_type=\"cosine\",\n",
578 | " max_steps=200,\n",
579 | " save_strategy=\"no\",\n",
580 | " logging_steps=1,\n",
581 | " output_dir=new_model,\n",
582 | " optim=\"paged_adamw_32bit\",\n",
583 | " warmup_steps=100,\n",
584 | " bf16=True,\n",
585 | " report_to=\"wandb\",\n",
586 | ")\n",
587 | "\n",
588 | "# Create DPO trainer\n",
589 | "dpo_trainer = DPOTrainer(\n",
590 | " model,\n",
591 | " ref_model,\n",
592 | " args=training_args,\n",
593 | " train_dataset=dataset,\n",
594 | " tokenizer=tokenizer,\n",
595 | " peft_config=peft_config,\n",
596 | " beta=0.1,\n",
597 | " max_prompt_length=1024,\n",
598 | " max_length=1536,\n",
599 | ")\n",
600 | "\n",
601 | "# Fine-tune model with DPO\n",
602 | "dpo_trainer.train()"
603 | ],
604 | "metadata": {
605 | "id": "rKPILNOLR-aK"
606 | },
607 | "execution_count": null,
608 | "outputs": []
609 | },
610 | {
611 | "cell_type": "markdown",
612 | "source": [
613 | "## Upload model"
614 | ],
615 | "metadata": {
616 | "id": "3LdhPpcrUM3H"
617 | }
618 | },
619 | {
620 | "cell_type": "code",
621 | "source": [
622 | "# Save artifacts\n",
623 | "dpo_trainer.model.save_pretrained(\"final_checkpoint\")\n",
624 | "tokenizer.save_pretrained(\"final_checkpoint\")\n",
625 | "\n",
626 | "# Flush memory\n",
627 | "del dpo_trainer, model, ref_model\n",
628 | "gc.collect()\n",
629 | "torch.cuda.empty_cache()\n",
630 | "\n",
631 | "# Reload model in FP16 (instead of NF4)\n",
632 | "base_model = AutoModelForCausalLM.from_pretrained(\n",
633 | " model_name,\n",
634 | " return_dict=True,\n",
635 | " torch_dtype=torch.float16,\n",
636 | ")\n",
637 | "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
638 | "\n",
639 | "# Merge base model with the adapter\n",
640 | "model = PeftModel.from_pretrained(base_model, \"final_checkpoint\")\n",
641 | "model = model.merge_and_unload()\n",
642 | "\n",
643 | "# Save model and tokenizer\n",
644 | "model.save_pretrained(new_model)\n",
645 | "tokenizer.save_pretrained(new_model)\n",
646 | "\n",
647 | "# Push them to the HF Hub\n",
648 | "model.push_to_hub(new_model, use_temp_dir=False, token=hf_token)\n",
649 | "tokenizer.push_to_hub(new_model, use_temp_dir=False, token=hf_token)"
650 | ],
651 | "metadata": {
652 | "id": "h7cIvxcTfBC4"
653 | },
654 | "execution_count": null,
655 | "outputs": []
656 | },
657 | {
658 | "cell_type": "markdown",
659 | "source": [
660 | "## Inference"
661 | ],
662 | "metadata": {
663 | "id": "G6EFsmS4UOgV"
664 | }
665 | },
666 | {
667 | "cell_type": "code",
668 | "source": [
669 | "# Format prompt\n",
670 | "message = [\n",
671 | " {\"role\": \"system\", \"content\": \"You are a helpful assistant chatbot.\"},\n",
672 | " {\"role\": \"user\", \"content\": \"What is a Large Language Model?\"}\n",
673 | "]\n",
674 | "tokenizer = AutoTokenizer.from_pretrained(new_model)\n",
675 | "prompt = tokenizer.apply_chat_template(message, add_generation_prompt=True, tokenize=False)\n",
676 | "\n",
677 | "# Create pipeline\n",
678 | "pipeline = transformers.pipeline(\n",
679 | " \"text-generation\",\n",
680 | " model=new_model,\n",
681 | " tokenizer=tokenizer\n",
682 | ")\n",
683 | "\n",
684 | "# Generate text\n",
685 | "sequences = pipeline(\n",
686 | " prompt,\n",
687 | " do_sample=True,\n",
688 | " temperature=0.7,\n",
689 | " top_p=0.9,\n",
690 | " num_return_sequences=1,\n",
691 | " max_length=200,\n",
692 | ")\n",
693 | "print(sequences[0]['generated_text'])"
694 | ],
695 | "metadata": {
696 | "colab": {
697 | "base_uri": "https://localhost:8080/",
698 | "height": 251,
699 | "referenced_widgets": [
700 | "22773c721a7c4221a9c14cd388461d4c",
701 | "6b54841f5de1482694c360095dae3039",
702 | "448ccbc85e624ec3b3e71931a7ee4ff6",
703 | "173769f6f465485f8848a11bf269850b",
704 | "60978b9b4e8348f0a71ce3e35c73bcff",
705 | "6a38dcbaf4674b448329ac0a16587d2a",
706 | "7eaeada2158e493189449af91f643553",
707 | "6e32854952b340008edca0139d3471d6",
708 | "db6d7cfcdade4b4baa213a5d0abc07d7",
709 | "9083029642744c43b7705532cbe0cf79",
710 | "d028a98caa13425b907ceb513119006e"
711 | ]
712 | },
713 | "id": "LAEUZFjvlJOv",
714 | "outputId": "9b5720c7-49ef-45c7-e5a7-f38d64899b1e"
715 | },
716 | "execution_count": null,
717 | "outputs": [
718 | {
719 | "output_type": "stream",
720 | "name": "stderr",
721 | "text": [
722 | "Special tokens have been added in the vocabulary, make sure the associated word embeddings are fine-tuned or trained.\n"
723 | ]
724 | },
725 | {
726 | "output_type": "display_data",
727 | "data": {
728 | "text/plain": [
729 | "Loading checkpoint shards: 0%| | 0/3 [00:00system\n",
753 | "You are a helpful assistant chatbot.<|im_end|>\n",
754 | "<|im_start|>user\n",
755 | "What is a Large Language Model?<|im_end|>\n",
756 | "<|im_start|>assistant\n",
757 | "A large language model is a type of artificial intelligence (AI) system that has been trained on vast amounts of text data. These models are designed to understand and generate human language, allowing them to perform various natural language processing tasks, such as text generation, language translation, and question answering. Large language models typically use deep learning techniques, like recurrent neural networks (RNNs) or transformers, to learn patterns and relationships in the data, enabling them to generate coherent and contextually relevant responses. The size of these models, in terms of the number of parameters and the volume of data they are trained on, plays a significant role in their ability to comprehend and produce complex language structures.\n"
758 | ]
759 | }
760 | ]
761 | }
762 | ]
763 | }
--------------------------------------------------------------------------------
/.ipynb_checkpoints/README-checkpoint.md:
--------------------------------------------------------------------------------
1 | 4 | 🐦 seguime en X • 5 | 💻 machinelearnear • 6 | 📹 youtube • 7 | 💻 repo original de @mlabonne 8 |
9 |
|
30 | | 🥱 LazyMergekit | Fusiona modelos fácilmente usando mergekit en un clic. | |
31 | | ⚡ AutoGGUF | Cuantiza LLMs en formato GGUF en un clic. | |
32 | | 🌳 Árbol Genealógico de Modelos | Visualiza el árbol genealógico de modelos fusionados. | |
33 |
34 | ### Afinamiento
35 |
36 | | Cuaderno | Descripción | Artículo | Cuaderno |
37 | |---------------------------------------|-------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
38 | | Afinar Llama 2 en Google Colab | Guía paso a paso para afinar tu primer modelo Llama 2. | [Artículo](https://mlabonne.github.io/blog/posts/Fine_Tune_Your_Own_Llama_2_Model_in_a_Colab_Notebook.html) | |
39 | | Afinar LLMs con Axolotl | Guía de principio a fin para la herramienta de vanguardia para afinamiento. | [Artículo](https://mlabonne.github.io/blog/posts/A_Beginners_Guide_to_LLM_Finetuning.html) | |
40 | | Afinar Mistral-7b con DPO | Mejora el rendimiento de modelos afinados supervisados con DPO. | [Artículo](https://medium.com/towards-data-science/fine-tune-a-mistral-7b-model-with-direct-preference-optimization-708042745aac) | |
41 |
42 | ### Cuantización
43 |
44 | | Cuaderno | Descripción | Artículo | Cuaderno |
45 | |---------------------------------------|-------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
46 | | 1. Introducción a la Cuantización | Optimización de modelo de lenguaje grande usando cuantización de 8 bits. | [Artículo](https://mlabonne.github.io/blog/posts/Introduction_to_Weight_Quantization.html) | |
47 | | 2. Cuantización de 4 bits usando GPTQ | Cuantiza tus propios LLMs de código abierto para correrlos en hardware de consumidor. | [Artículo](https://mlabonne.github.io/blog/4bit_quantization/) | |
48 | | 3. Cuantización con GGUF y llama.cpp | Cuantiza modelos Llama 2 con llama.cpp y sube versiones GGUF al HF Hub. | [Artículo](https://mlabonne.github.io/blog/posts/Quantize_Llama_2_models_using_ggml.html) | |
49 | | 4. ExLlamaV2: La Biblioteca Más Rápida para Correr LLMs | Cuantiza y corre modelos EXL2 y súbelos al HF Hub. | [Artículo](https://mlabonne.github.io/blog/posts/ExLlamaV2_The_Fastest_Library_to_Run%C2%A0LLMs.html) | |
50 |
51 | ### Otros
52 |
53 | | Cuaderno | Descripción | Artículo | Cuaderno |
54 | |---------------------------------------|-------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------|
55 | | Estrategias de Decodificación en Modelos de Lenguaje Grandes | Una guía para la generación de texto desde la búsqueda por haz hasta el muestreo de núcleo | [Artículo](https://mlabonne.github.io/blog/posts/2022-06-07-Decoding_strategies.html) | |
56 | | Visualizando el Paisaje de Pérdida de GPT-2 | Gráfico 3D del paisaje de pérdida basado en perturbaciones de peso. | [Tweet](https://twitter.com/maximelabonne/status/1667618081844219904) | |
57 | | Mejorar ChatGPT con Grafos de Conocimiento | Amplía las respuestas de ChatGPT con grafos de conocimiento. | [Artículo](https://mlabonne.github.io/blog/posts/Article_Improve_ChatGPT_with_Knowledge_Graphs.html) | |
58 | | Fusionar LLMs con mergekit | Crea tus propios modelos fácilmente, ¡no se necesita GPU! | [Artículo](https://towardsdatascience.com/merge-large-language-models-with-mergekit-2118fb392b54) | |
59 |
60 | ## 🧩 Fundamentos de LLM
61 |
62 | ### 1. Matemáticas para Aprendizaje Automático
63 |
64 | Antes de dominar el aprendizaje automático, es importante entender los conceptos matemáticos fundamentales que impulsan estos algoritmos.
65 |
66 | - **Álgebra Lineal**: Esto es crucial para entender muchos algoritmos, especialmente aquellos usados en aprendizaje profundo. Conceptos clave incluyen vectores, matrices, determinantes, valores y vectores propios, espacios vectoriales y transformaciones lineales.
67 | - **Cálculo**: Muchos algoritmos de aprendizaje automático involucran la optimización de funciones continuas, lo que requiere un entendimiento de derivadas, integrales, límites y series. El cálculo multivariable y el concepto de gradientes también son importantes.
68 | - **Probabilidad y Estadística**: Estos son cruciales para entender cómo los modelos aprenden de datos y hacen predicciones. Conceptos clave incluyen teoría de probabilidad, variables aleatorias, distribuciones de probabilidad, expectativas, varianza, covarianza, correlación, pruebas de hipótesis, intervalos de confianza, estimación de máxima verosimilitud e inferencia Bayesiana.
69 |
70 | 📚 Recursos:
71 |
72 | - [3Blue1Brown - La Esencia del Álgebra Lineal](https://www.youtube.com/watch?v=fNk_zzaMoSs&list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab): Serie de videos que proporcionan una intuición geométrica de estos conceptos.
73 | - [StatQuest con Josh Starmer - Fundamentos de Estadística](https://www.youtube.com/watch?v=qBigTkBLU6g&list=PLblh5JKOoLUK0FLuzwntyYI10UQFUhsY9): Ofrece explicaciones simples y claras para muchos conceptos estadísticos.
74 | - [Intuición AP de Estadísticas por Ms Aerin](https://automata88.medium.com/list/cacc224d5e7d): Lista de artículos en Medium que proporcionan la intuición detrás de cada distribución de probabilidad.
75 | - [Álgebra Lineal Inmersiva](https://immersivemath.com/ila/learnmore.html): Otra interpretación visual del álgebra lineal.
76 | - [Khan Academy - Álgebra Lineal](https://www.khanacademy.org/math/linear-algebra): Genial para principiantes ya que explica los conceptos de manera muy intuitiva.
77 | - [Khan Academy - Cálculo](https://www.khanacademy.org/math/calculus-1): Un curso interactivo que cubre todos los fundamentos del cálculo.
78 | - [Khan Academy - Probabilidad y Estadística](https://www.khanacademy.org/math/statistics-probability): Presenta el material de forma fácil de entender.
79 |
80 | ---
81 |
82 | ### 2. Python para Aprendizaje Automático
83 |
84 | Python es un lenguaje de programación poderoso y flexible que es particularmente bueno para el aprendizaje automático, gracias a su legibilidad, consistencia y el robusto ecosistema de bibliotecas de ciencia de datos.
85 |
86 | - **Fundamentos de Python**: Programar en Python requiere un buen entendimiento de la sintaxis básica, tipos de datos, manejo de errores y programación orientada a objetos.
87 | - **Bibliotecas de Ciencia de Datos**: Incluye familiaridad con NumPy para operaciones numéricas, Pandas para manipulación y análisis de datos, Matplotlib y Seaborn para visualización de datos.
88 | - **Preprocesamiento de Datos**: Esto involucra escalado y normalización de características, manejo de datos faltantes, detección de valores atípicos, codificación de datos categóricos y división de datos en conjuntos de entrenamiento, validación y prueba.
89 | - **Bibliotecas de Aprendizaje Automático**: Proficiencia con Scikit-learn, una biblioteca que proporciona una amplia selección de algoritmos de aprendizaje supervisado y no supervisado, es vital. Entender cómo implementar algoritmos como regresión lineal, regresión logística, árboles de decisión, bosques aleatorios, vecinos más cercanos (K-NN) y agrupamiento por K-medias es importante. Técnicas de reducción de dimensionalidad como PCA y t-SNE también son útiles para visualizar datos de alta dimensión.
90 |
91 | 📚 Recursos:
92 |
93 | - [Real Python](https://realpython.com/): Un recurso comprensivo con artículos y tutoriales tanto para conceptos de Python principiantes como avanzados.
94 | - [freeCodeCamp - Aprende Python](https://www.youtube.com/watch?v=rfscVS0vtbw): Video largo que proporciona una introducción completa a todos los conceptos fundamentales en Python.
95 | - [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/): Libro digital gratuito que es un gran recurso para aprender pandas, NumPy, Matplotlib y Seaborn.
96 | - [freeCodeCamp - Aprendizaje Automático para Todos](https://youtu.be/i_LwzRVP7bg): Introducción práctica a diferentes algoritmos de aprendizaje automático para principiantes.
97 | - [Udacity - Introducción al Aprendizaje Automático](https://www.udacity.com/course/intro-to-machine-learning--ud120): Curso gratuito que cubre PCA y varios otros conceptos de aprendizaje automático.
98 |
99 | ---
100 |
101 | ### 3. Redes Neuronales
102 |
103 | Las redes neuronales son una parte fundamental de muchos modelos de aprendizaje automático, particularmente en el ámbito del aprendizaje profundo. Para utilizarlas efectivamente, es esencial tener un entendimiento comprensivo de su diseño y mecánicas.
104 |
105 | - **Fundamentos**: Esto incluye entender la estructura de una red neuronal como capas, pesos, sesgos y funciones de activación (sigmoide, tanh, ReLU, etc.)
106 | - **Entrenamiento y Optimización**: Familiarízate con la retropropagación y diferentes tipos de funciones de pérdida, como Error Cuadrático Medio (MSE) y Entropía Cruzada. Entiende varios algoritmos de optimización como Descenso de Gradiente, Descenso de Gradiente Estocástico, RMSprop y Adam.
107 | - **Sobreajuste**: Entender el concepto de sobreajuste (donde un modelo rinde bien en datos de entrenamiento pero pobremente en datos no vistos) y aprender varias técnicas de regularización (abandono, regularización L1/L2, detención temprana, aumento de datos) para prevenirlo.
108 | - **Implementar un Perceptrón Multicapa (MLP)**: Construye un MLP, también conocido como una red completamente conectada, usando PyTorch.
109 |
110 | 📚 Recursos:
111 |
112 | - [3Blue1Brown - Pero, ¿qué es una red neuronal?](https://www.youtube.com/watch?v=aircAruvnKk): Este video ofrece una explicación intuitiva de las redes neuronales y su funcionamiento interno.
113 | - [freeCodeCamp - Curso Acelerado de Aprendizaje Profundo](https://www.youtube.com/watch?v=VyWAvY2CF9c): Este video introduce de manera eficiente todos los conceptos más importantes en aprendizaje profundo.
114 | - [Fast.ai - Aprendizaje Profundo Práctico](https://course.fast.ai/): Curso gratuito diseñado para personas con experiencia en programación que quieran aprender sobre aprendizaje profundo.
115 | - [Patrick Loeber - Tutoriales de PyTorch](https://www.youtube.com/playlist?list=PLqnslRFeH2UrcDBWF5mfPGpqQDSta6VK4): Serie de videos para principiantes completos para aprender sobre PyTorch.
116 |
117 | ---
118 |
119 | ### 4. Procesamiento de Lenguaje Natural (NLP)
120 |
121 | NLP es una rama fascinante de la inteligencia artificial que cierra la brecha entre el lenguaje humano y la comprensión de las máquinas. Desde el procesamiento de texto simple hasta la comprensión de matices lingüísticos, NLP juega un papel crucial en muchas aplicaciones como traducción, análisis de sentimientos, chatbots y mucho más.
122 |
123 | - **Preprocesamiento de Texto**: Aprende varios pasos de preprocesamiento de texto como tokenización (dividir texto en palabras o frases), stemming (reducir palabras a su forma raíz), lematización (similar al stemming pero considera el contexto), eliminación de palabras vacías, etc.
124 | - **Técnicas de Extracción de Características**: Familiarízate con técnicas para convertir datos de texto en un formato que pueda ser entendido por algoritmos de aprendizaje automático. Los métodos clave incluyen Bolsa de palabras (BoW), Frecuencia de Término - Inversa de Frecuencia de Documentos (TF-IDF) y n-gramas.
125 | - **Embeddings de Palabras**: Los embeddings de palabras son un tipo de representación de palabras que permite que palabras con significados similares tengan representaciones similares. Los métodos clave incluyen Word2Vec, GloVe y FastText.
126 | - **Redes Neuronales Recurrentes (RNNs)**: Entiende el funcionamiento de RNNs, un tipo de red neuronal diseñada para trabajar con datos secuenciales. Explora LSTMs y GRUs, dos variantes de RNN que son capaces de aprender dependencias a largo plazo.
127 |
128 | 📚 Recursos:
129 |
130 | - [RealPython - NLP con spaCy en Python](https://realpython.com/natural-language-processing-spacy-python/): Guía exhaustiva sobre la biblioteca spaCy para tareas de NLP en Python.
131 | - [Kaggle - Guía de NLP](https://www.kaggle.com/learn-guide/natural-language-processing): Unos cuadernos y recursos para una explicación práctica de NLP en Python.
132 | - [Jay Alammar - La Ilustración Word2Vec](https://jalammar.github.io/illustrated-word2vec/): Una buena referencia para entender la famosa arquitectura Word2Vec.
133 | - [Jake Tae - PyTorch RNN desde Cero](https://jaketae.github.io/study/pytorch-rnn/): Implementación práctica y simple de modelos RNN, LSTM y GRU en PyTorch.
134 | - [Blog de Colah - Entendiendo las Redes LSTM](https://colah.github.io/posts/2015-08-Understanding-LSTMs/): Un artículo más teórico sobre la red LSTM.
135 |
136 | ## 🧑🔬 El Científico de LLM
137 |
138 | Esta sección del curso se enfoca en aprender cómo construir los mejores LLMs posibles usando las técnicas más recientes.
139 |
140 | ### 1. La arquitectura LLM
141 |
142 | Aunque no es necesario un conocimiento profundo sobre la arquitectura Transformer, es importante tener un buen entendimiento de sus entradas (tokens) y salidas (logits). El mecanismo de atención básico es otro componente crucial para dominar, ya que se introducen versiones mejoradas más adelante.
143 |
144 | * **Vista de alto nivel**: Revisar la arquitectura Transformer de codificador-decodificador, y más específicamente la arquitectura GPT solo de decodificador, que se usa en todos los LLMs modernos.
145 | * **Tokenización**: Entender cómo convertir datos de texto crudo en un formato que el modelo pueda entender, lo que involucra dividir el texto en tokens (generalmente palabras o subpalabras).
146 | * **Mecanismos de atención**: Comprender la teoría detrás de los mecanismos de atención, incluyendo la autoatención y la atención de producto punto escalado, que permite al modelo enfocarse en diferentes partes de la entrada al producir una salida.
147 | * **Generación de texto**: Aprender sobre las diferentes maneras en que el modelo puede generar secuencias de salida. Las estrategias comunes incluyen la decodificación ávida, búsqueda por haz, muestreo top-k y muestreo de núcleo.
148 |
149 | 📚 **Referencias**:
150 | - [El Transformer Ilustrado](https://jalammar.github.io/illustrated-transformer/) por Jay Alammar: Una explicación visual e intuitiva del modelo Transformer.
151 | - [El GPT-2 Ilustrado](https://jalammar.github.io/illustrated-gpt2/) por Jay Alammar: Más importante que el artículo anterior, se centra en la arquitectura GPT, muy similar a la de Llama.
152 | - [Visualización LLM](https://bbycroft.net/llm) por Brendan Bycroft: Increíble visualización 3D de lo que sucede dentro de un LLM.
153 | * [nanoGPT](https://www.youtube.com/watch?v=kCc8FmEb1nY) por Andrej Karpathy: Video de 2 horas en YouTube para reimplementar GPT desde cero (para programadores).
154 | * [¿Atención? ¡Atención!](https://lilianweng.github.io/posts/2018-06-24-attention/) por Lilian Weng: Introduce la necesidad de atención de una manera más formal.
155 | * [Estrategias de Decodificación en LLMs](https://mlabonne.github.io/blog/posts/2023-06-07-Decoding_strategies.html): Proporciona código y una introducción visual a las diferentes estrategias de decodificación para generar texto.
156 |
157 | ---
158 | ### 2. Construyendo un conjunto de datos de instrucciones
159 |
160 | Aunque es fácil encontrar datos crudos de Wikipedia y otros sitios web, es difícil recolectar pares de instrucciones y respuestas en la naturaleza. Como en el aprendizaje automático tradicional, la calidad del conjunto de datos influirá directamente en la calidad del modelo, lo que significa que podría ser el componente más importante en el proceso de afinamiento.
161 |
162 | * **Conjunto de datos tipo [Alpaca](https://crfm.stanford.edu/2023/03/13/alpaca.html)**: Generar datos sintéticos desde cero con la API de OpenAI (GPT). Puedes especificar semillas y prompts del sistema para crear un conjunto de datos diverso.
163 | * **Técnicas avanzadas**: Aprender cómo mejorar conjuntos de datos existentes con [Evol-Instruct](https://arxiv.org/abs/2304.12244), cómo generar datos sintéticos de alta calidad como en los papeles [Orca](https://arxiv.org/abs/2306.02707) y [phi-1](https://arxiv.org/abs/2306.11644).
164 | * **Filtrado de datos**: Técnicas tradicionales que involucran regex, eliminación de duplicados cercanos, enfocándose en respuestas con un alto número de tokens, etc.
165 | * **Plantillas de prompts**: No existe una manera estándar verdadera de formatear instrucciones y respuestas, por lo que es importante saber sobre las diferentes plantillas de chat, como [ChatML](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/chatgpt?
166 |
167 | tabs=python&pivots=programming-language-chat-ml), [Alpaca](https://crfm.stanford.edu/2023/03/13/alpaca.html), etc.
168 |
169 | 📚 **Referencias**:
170 | * [Preparando un Conjunto de Datos para Ajuste de Instrucciones](https://wandb.ai/capecape/alpaca_ft/reports/How-to-Fine-Tune-an-LLM-Part-1-Preparing-a-Dataset-for-Instruction-Tuning--Vmlldzo1NTcxNzE2) por Thomas Capelle: Exploración de los conjuntos de datos Alpaca y Alpaca-GPT4 y cómo formatearlos.
171 | * [Generando un Conjunto de Datos de Instrucción Clínica](https://medium.com/mlearning-ai/generating-a-clinical-instruction-dataset-in-portuguese-with-langchain-and-gpt-4-6ee9abfa41ae) por Solano Todeschini: Tutorial sobre cómo crear un conjunto de datos de instrucción sintético usando GPT-4.
172 | * [GPT 3.5 para clasificación de noticias](https://medium.com/@kshitiz.sahay26/how-i-created-an-instruction-dataset-using-gpt-3-5-to-fine-tune-llama-2-for-news-classification-ed02fe41c81f) por Kshitiz Sahay: Uso de GPT 3.5 para crear un conjunto de datos de instrucción para afinar Llama 2 para clasificación de noticias.
173 | * [Creación de conjunto de datos para afinamiento de LLM](https://colab.research.google.com/drive/1GH8PW9-zAe4cXEZyOIE-T9uHXblIldAg?usp=sharing): Cuaderno que contiene algunas técnicas para filtrar un conjunto de datos y subir el resultado.
174 | * [Plantilla de Chat](https://huggingface.co/blog/chat-templates) por Matthew Carrigan: Página de Hugging Face sobre plantillas de prompts.
175 |
176 | ---
177 | ### 3. Preentrenamiento de modelos
178 |
179 | El preentrenamiento es un proceso muy largo y costoso, por lo que no es el foco de este curso. Es bueno tener algún nivel de entendimiento sobre lo que sucede durante el preentrenamiento, pero la experiencia práctica no es requerida.
180 |
181 | * **Pipeline de datos**: El preentrenamiento requiere enormes conjuntos de datos (por ejemplo, [Llama 2](https://arxiv.org/abs/2307.09288) fue entrenado en 2 billones de tokens) que necesitan ser filtrados, tokenizados y agrupados con un vocabulario predefinido.
182 | * **Modelado de lenguaje causal**: Aprender la diferencia entre modelado de lenguaje causal y modelado de lenguaje enmascarado, así como la función de pérdida utilizada en este caso. Para un preentrenamiento eficiente, aprender más sobre [Megatron-LM](https://github.com/NVIDIA/Megatron-LM) o [gpt-neox](https://github.com/EleutherAI/gpt-neox).
183 | * **Leyes de escalamiento**: Las [leyes de escalamiento](https://arxiv.org/pdf/2001.08361.pdf) describen el rendimiento esperado del modelo basado en el tamaño del modelo, tamaño del conjunto de datos y la cantidad de cómputo usado para el entrenamiento.
184 | * **Computación de Alto Rendimiento**: Fuera del alcance aquí, pero más conocimiento sobre HPC es fundamental si estás planeando crear tu propio LLM desde cero (hardware, carga de trabajo distribuida, etc.).
185 |
186 | 📚 **Referencias**:
187 | * [LLMDataHub](https://github.com/Zjh-819/LLMDataHub) por Junhao Zhao: Lista curada de conjuntos de datos para preentrenamiento, afinamiento y RLHF.
188 | * [Entrenando un modelo de lenguaje causal desde cero](https://huggingface.co/learn/nlp-course/chapter7/6?fw=pt) por Hugging Face: Preentrena un modelo GPT-2 desde cero usando la biblioteca transformers.
189 | * [TinyLlama](https://github.com/jzhang38/TinyLlama) por Zhang et al.: Consulta este proyecto para obtener un buen entendimiento de cómo se entrena un modelo Llama desde cero.
190 | * [Modelado de lenguaje causal](https://huggingface.co/docs/transformers/tasks/language_modeling) por Hugging Face: Explica la diferencia entre modelado de lenguaje causal y enmascarado y cómo afinar rápidamente un modelo Distil
191 |
192 | GPT-2.
193 | * [Las salvajes implicaciones de Chinchilla](https://www.lesswrong.com/posts/6Fpvch8RR29qLEWNH/chinchilla-s-wild-implications) por nostalgebraist: Discute las leyes de escalamiento y explica lo que significan para los LLMs en general.
194 | * [BLOOM](https://bigscience.notion.site/BLOOM-BigScience-176B-Model-ad073ca07cdf479398d5f95d88e218c4) por BigScience: Página de Notion que describe cómo se construyó el modelo BLOOM, con mucha información útil sobre la parte de ingeniería y los problemas que se encontraron.
195 | * [Libreta de bitácora OPT-175](https://github.com/facebookresearch/metaseq/blob/main/projects/OPT/chronicles/OPT175B_Logbook.pdf) por Meta: Registros de investigación que muestran lo que salió mal y lo que salió bien. Útil si planeas preentrenar un modelo de lenguaje grande (en este caso, 175B parámetros).
196 | * [LLM 360](https://www.llm360.ai/): Un marco para LLMs de código abierto con código de entrenamiento y preparación de datos, datos, métricas y modelos.
197 |
198 | ---
199 | ### 4. Afinamiento Supervisado
200 |
201 | Los modelos preentrenados solo están entrenados en una tarea de predicción del siguiente token, por lo que no son asistentes útiles. SFT te permite ajustarlos para responder a instrucciones. Además, te permite afinar tu modelo en cualquier dato (privado, no visto por GPT-4, etc.) y usarlo sin tener que pagar por una API como la de OpenAI.
202 |
203 | * **Afinamiento completo**: El afinamiento completo se refiere a entrenar todos los parámetros en el modelo. No es una técnica eficiente, pero produce resultados ligeramente mejores.
204 | * [**LoRA**](https://arxiv.org/abs/2106.09685): Una técnica de afinamiento eficiente en parámetros (PEFT) basada en adaptadores de rango bajo. En lugar de entrenar todos los parámetros, solo entrenamos estos adaptadores.
205 | * [**QLoRA**](https://arxiv.org/abs/2305.14314): Otra PEFT basada en LoRA, que también cuantiza los pesos del modelo en 4 bits e introduce optimizadores paginados para manejar picos de memoria. Combínalo con [Unsloth](https://github.com/unslothai/unsloth) para correrlo eficientemente en un cuaderno Colab gratuito.
206 | * **[Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl)**: Una herramienta de afinamiento poderosa y fácil de usar que se utiliza en muchos modelos de código abierto de vanguardia.
207 | * [**DeepSpeed**](https://www.deepspeed.ai/): Preentrenamiento y afinamiento eficientes de LLMs para configuraciones multi-GPU y multi-nodo (implementado en Axolotl).
208 |
209 | 📚 **Referencias**:
210 | * [La Guía de Entrenamiento de LLM para Novatos](https://rentry.org/llm-training) por Alpin: Visión general de los principales conceptos y parámetros a considerar al afinar LLMs.
211 | * [Perspectivas de LoRA](https://lightning.ai/pages/community/lora-insights/) por Sebastian Raschka: Perspectivas prácticas sobre LoRA y cómo seleccionar los mejores parámetros.
212 | * [Afine Tu Propio Modelo Llama 2](https://mlabonne.github.io/blog/posts/Fine_Tune_Your_Own_Llama_2_Model_in_a_Colab_Notebook.html): Tutorial práctico sobre cómo afinar un modelo Llama 2 usando bibliotecas de Hugging Face.
213 | * [Rellenando Modelos de Lenguaje Grandes](https://towardsdatascience.com/padding-large-language-models-examples-with-llama-2-199fb10df8ff) por Benjamin Marie: Mejores prácticas para rellenar ejemplos de entrenamiento para LLMs causales
214 | * [Una Guía para Principiantes en Afinamiento de LLM](https://mlabonne.github.io/blog/posts/A_Beginners_Guide_to_LLM_Finetuning.html): Tutorial sobre cómo afinar un modelo CodeLlama usando Axolotl.
215 |
216 | ---
217 | ### 5. Aprendizaje por Refuerzo a partir de Retroalimentación Humana
218 |
219 | Después del afinamiento supervisado, el ARRH es un paso usado para alinear las respuestas del LLM con las expectativas humanas. La idea es aprender preferencias a partir de retroalimentación humana (o artificial), que se puede usar para reducir sesgos, censurar modelos, o hacerlos actuar de una manera más útil. Es más complejo que el SFT y a menudo se ve como opcional.
220 |
221 | * **Conjuntos de datos de preferencia**: Estos conjuntos típicamente contienen varias respuestas con algún tipo de clasificación, lo que los hace más difíciles de producir que los conjuntos de instrucciones.
222 | * [**Optimización de Política Proximal**](https://arxiv.org/abs/1707.06347): Este algoritmo aprovecha un modelo de recompensa que predice si un texto dado está altamente clasificado por humanos. Esta predicción se usa luego para optimizar el modelo SFT con una penalización basada en divergencia KL.
223 | * **[Optimización de Preferencia Directa](https://arxiv.org/abs/2305.18290)**: DPO simplifica el proceso al reformularlo como un problema de clasificación. Usa un modelo de referencia en lugar de un modelo de recompensa (no necesita entrenamiento) y solo requiere un hiperparámetro, lo que lo hace más estable y eficiente.
224 |
225 | 📚 **Referencias**:
226 | * [Una Introducción al Entrenamiento de LLMs usando ARRH](https://wandb.ai/ayush-thakur/Intro-RLAIF/reports/An-Introduction-to-Training-LLMs-Using-Reinforcement-Learning-From-Human-Feedback-RLHF---VmlldzozMzYyNjcy) por Ayush Thakur: Explica por qué el ARRH es deseable para reducir el sesgo y aumentar el rendimiento en LLMs.
227 | * [Ilustración ARRH](https://huggingface.co/blog/rlhf) por Hugging Face: Introducción al ARRH con entrenamiento de modelo de recompensa y afinamiento con aprendizaje por refuerzo.
228 | * [StackLLaMA](https://huggingface.co/blog/stackllama) por Hugging Face: Tutorial para alinear eficientemente un modelo LLaMA con ARRH usando la biblioteca de transformers.
229 | * [Entrenamiento de LLM: ARRH y Sus Alternativas](https://substack.com/profile/27393275-sebastian-raschka-phd) por Sebastian Rashcka: Visión general del proceso de ARRH y alternativas como RLAIF.
230 | * [Afinar Mistral-7b con DPO](https://huggingface.co/blog/dpo-trl): Tutorial para afinar un modelo Mistral-7b con DPO y reproducir [NeuralHermes-2.5](https://huggingface.co/mlabonne/NeuralHermes-2.5-Mistral-7B).
231 |
232 | ---
233 | ### 6. Evaluación
234 |
235 | Evaluar LLMs es una parte subestimada del pipeline, que consume tiempo y es moderadamente confiable. Tu tarea específica debería dictar qué quieres evaluar, pero siempre recuerda la ley de Goodhart: "Cuando una medida se convierte en un objetivo, deja de ser una buena medida."
236 |
237 | * **Métricas tradicionales**: Métricas como la perplejidad y el puntaje BLEU no son tan populares como lo eran porque están defectuosas en la mayoría de los contextos. Aún es importante entenderlas y cuándo pueden ser aplicadas.
238 | * **Benchmarks generales**: Basados en el [Language Model Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness), el [Open LLM Leaderboard](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard) es el principal benchmark para LLMs de propósito general (como ChatGPT). Hay otros benchmarks populares como [BigBench](https://github.com/google/BIG-bench), [MT-Bench](https://arxiv.org/abs/2306.05685), etc.
239 | * **Benchmarks específicos de tareas**: Tareas como la summarización, traducción y respuesta a preguntas tienen benchmarks dedicados, métricas e incluso subdominios (médico, financiero, etc.), como [PubMedQA](https://pubmedqa.github.io/) para respuesta a preguntas biomédicas.
240 | * **Evaluación humana**: La evaluación más confiable es la tasa de aceptación por parte de los usuarios o comparaciones hechas por humanos. Si quieres saber si un modelo rinde bien, la forma más simple pero segura es usarlo tú mismo.
241 |
242 | 📚 **Referencias**:
243 | * [Perplejidad de modelos de longitud fija](https://huggingface.co/docs/transformers/perplexity) por Hugging Face: Visión general de la perplejidad con código para implementarlo con la biblioteca de transformers.
244 | * [BLEU a tu propio riesgo](https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213) por Rachael Tatman: Visión general del puntaje BLEU y sus muchos problemas con ejemplos.
245 | * [Una Encuesta sobre la Evaluación de LLMs](https://arxiv.org/abs/2307.03109) por Chang et al.: Documento comprensivo sobre qué evaluar, dónde evaluar y cómo evaluar.
246 | * [Chatbot Arena Leaderboard](https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard) por lmsys: Clasificación Elo de LLMs de propósito general, basada en comparaciones hechas por humanos.
247 |
248 | ---
249 | ### 7. Cuantización
250 |
251 | La cuantización es el proceso de convertir los pesos (y activaciones) de un modelo usando una precisión menor. Por ejemplo, los pesos almacenados usando 16 bits pueden ser convertidos en una representación de 4 bits. Esta técnica se ha vuelto cada vez más importante para reducir los costos computacionales y de memoria asociados con los LLMs.
252 |
253 | * **Técnicas base**: Aprende los diferentes niveles de precisión (FP32, FP16, INT8, etc.) y cómo realizar cuantización naíf con técnicas de absmax y punto cero.
254 | * **GGUF y llama.cpp**: Originalmente diseñado para correr en CPUs, [llama.cpp](https://github.com/ggerganov/llama.cpp) y el formato GGUF se han vuelto las herramientas más populares para correr LLMs en hardware de grado consumidor.
255 | * **GPTQ y EXL2**: [GPTQ](https://arxiv.org/abs/2210.17323) y, más específicamente, el formato [EXL2](https://github.com/turboderp/exllamav2) ofrecen una velocidad increíble pero solo pueden correr en GPUs. Los modelos también toman un largo tiempo en ser cuantizados.
256 | * **AWQ**: Este nuevo formato es más preciso que GPTQ (menor perplejidad) pero usa mucho más VRAM y no necesariamente es más rápido.
257 |
258 | 📚 **Referencias**:
259 | * [Introducción a la cuantización](https://mlabonne.github.io/blog/posts/Introduction_to_Weight_Quantization.html): Visión general de la cuantización, cuantización absmax y punto cero, y LLM.int8() con código.
260 | * [Cuantiza modelos Llama con llama.cpp](https://mlabonne.github.io/blog/posts/Quantize_Llama_2_models_using_ggml.html): Tutorial sobre cómo cuantizar un modelo Llama 2 usando llama.cpp y el formato GGUF.
261 | * [Cuantización de LLM de 4 bits con GPTQ](https://mlabonne.github.io/blog/posts/Introduction_to_Weight_Quantization.html): Tutorial sobre cómo cuantizar un LLM usando el algoritmo GPTQ con AutoGPTQ.
262 | * [ExLlamaV2: La Biblioteca Más Rápida para Correr LLMs](https://mlabonne.github.io/blog/posts/ExLlamaV2_The_Fastest_Library_to_Run%C2%A0LLMs.html): Guía sobre cómo cuantizar un modelo Mistral usando el formato EXL2 y correrlo con la biblioteca ExLlamaV2.
263 | * [Entendiendo la Cuantización de Pesos Consciente de Activación](https://medium.com/friendliai/understanding-activation-aware-weight-quantization-awq-boosting-inference-serving-efficiency-in-10bb0faf63a8) por FriendliAI: Visión general de la técnica AWQ y sus beneficios.
264 |
265 | ---
266 | ### 8. Nuevas Tendencias
267 |
268 | * **Codificaciones posicionales**: Aprende cómo los LLMs codifican posiciones, especialmente esquemas de codificación posicional relativa como [RoPE](https://arxiv.org/abs/2104.09864). Implementa [YaRN](https://arxiv.org/abs/2309.00071) (multiplica la matriz de atención por un factor de temperatura) o [ALiBi](https://arxiv.org/abs/2108.12409) (penalización de atención basada en la distancia de tokens) para extender la longitud del contexto.
269 | * **Fusión de modelos**: Fusionar modelos entrenados se ha vuelto una manera popular de crear modelos performantes sin ningún afinamiento. La popular biblioteca [mergekit](https://github.com/cg123/mergekit) implementa los métodos de fusión más populares, como SLERP, [DARE](https://arxiv.org/abs/2311.03099), y [TIES](https://arxiv.org/abs/2311.03099).
270 | * **Mezcla de Expertos**: [Mixtral](https://arxiv.org/abs/2401.04088) repopularizó la arquitectura MoE gracias a su excelente rendimiento. Paralelamente, un tipo de frankenMoE emergió en la comunidad OSS fusionando modelos como [Phixtral](https://huggingface.co/mlabonne/phixtral-2x2_8), que es una opción más económica y performante.
271 | * **Modelos multimodales**: Estos modelos (como [CLIP](https://openai.com/research/clip), [Stable Diffusion](https://stability.ai/stable-image), o [LLaVA](https://llava-vl.github.io/)) procesan múltiples tipos de entradas (texto, imágenes, audio, etc.) con un espacio de incrustación unificado, lo que desbloquea aplicaciones poderosas como texto-a-imagen.
272 |
273 | 📚 **Referencias**:
274 | * [Extendiendo el RoPE](https://blog.eleuther.ai/yarn/) por EleutherAI: Artículo que resume las diferentes técnicas de codificación de posición.
275 | * [Entendiendo YaRN](https://medium.com/@rcrajatchawla/understanding-yarn-extending-context-window-of-llms-3f21e3522465) por Rajat Chawla: Introducción a YaRN.
276 | * [Fusionar LLMs con mergekit](https://mlabonne.github.io/blog/posts/2024-01-08_Merge_LLMs_with_mergekit.html): Tutorial sobre fusión de modelos usando mergekit.
277 | * [Mezcla de Expertos Explicada](https://huggingface.co/blog/moe) por Hugging Face: Guía exhaustiva sobre MoEs y cómo funcionan.
278 | * [Modelos Multimodales Grandes](https://huyenchip.com/2023/10/10/multimodal.html) por Chip Huyen: Visión general de sistemas multimodales y la historia reciente de este campo.
279 |
280 | ## 👷 El Ingeniero de LLM
281 |
282 | Esta sección del curso se enfoca en aprender cómo construir aplicaciones potenciadas por LLM que puedan usarse en producción, con un enfoque en aumentar modelos y desplegarlos.
283 |
284 | 
285 |
286 | ### 1. Ejecutando LLMs
287 |
288 | Ejecutar LLMs puede ser difícil debido a los altos requisitos de hardware. Dependiendo de tu caso de uso, podrías querer simplemente consumir un modelo a través de una API (como GPT-4) o ejecutarlo localmente. En cualquier caso, técnicas adicionales de prompting y guía pueden mejorar y restringir la salida para tus aplicaciones.
289 |
290 | * **APIs de LLM**: Las APIs son una manera conveniente de desplegar LLMs. Este espacio está dividido entre LLMs privados ([OpenAI](https://platform.openai.com/), [Google](https://cloud.google.com/vertex-ai/docs/generative-ai/learn/overview), [Anthropic](https://docs.anthropic.com/claude/reference/getting-started-with-the-api), [Cohere](https://docs.cohere.com/docs), etc.) y LLMs de código abierto ([OpenRouter](https://openrouter.ai/), [Hugging Face](https://huggingface.co/inference-api), [Together AI](https://www.together.ai/), etc.).
291 | * **LLMs de código abierto**: El [Hugging Face Hub](https://huggingface.co/models) es un excelente lugar para encontrar LLMs. Puedes ejecutar algunos de ellos directamente en [Hugging Face Spaces](https://huggingface.co/spaces), o descargarlos y ejecutarlos localmente en aplicaciones como [LM Studio](https://lmstudio.ai/) o a través de la CLI con [llama.cpp](https://github.com/ggerganov/llama.cpp) o [Ollama](https://ollama.ai/).
292 | * **Ingeniería de prompts**: Técnicas comunes incluyen prompting de cero disparos, prompting de pocos disparos, cadena de pensamiento y ReAct. Funcionan mejor con modelos más grandes, pero pueden adaptarse a modelos más pequeños.
293 | * **Estructurando salidas**: Muchas tareas requieren una salida estructurada, como una plantilla estricta o un formato JSON. Bibliotecas como [LMQL](https://lmql.ai/), [Outlines](https://github.com/outlines-dev/outlines), [Guidance](https://github.com/guidance-ai/guidance), etc. pueden usarse para guiar la generación y respetar una estructura dada.
294 |
295 | 📚 **Referencias**:
296 | * [Ejecuta un LLM localmente con LM Studio](https://www.kdnuggets.com/run-an-llm-locally-with-lm-studio) por Nisha Arya: Guía corta sobre cómo usar LM Studio.
297 | * [Guía de ingeniería de prompts](https://www.promptingguide.ai/) por DAIR.AI: Lista exhaustiva de técnicas de prompts con ejemplos.
298 | * [Outlines - Inicio rápido](https://outlines-dev.github.io/outlines/quickstart/): Lista de técnicas de generación guiada habilitadas por Outlines.
299 | * [LMQL - Visión general](https://lmql.ai/docs/language/overview.html): Introducción al lenguaje LMQL.
300 |
301 | ---
302 | ### 2. Construyendo un Almacenamiento de Vectores
303 |
304 | Crear un almacenamiento de vectores es el primer paso para construir una tubería de Generación Aumentada por Recuperación (RAG). Los documentos se cargan, se dividen y los fragmentos relevantes se usan para producir representaciones vectoriales (incrustaciones) que se almacenan para su uso futuro durante la inferencia.
305 |
306 | * **Ingesta de documentos**: Los cargadores de documentos son envoltorios convenientes que pueden manejar muchos formatos: PDF, JSON, HTML, Markdown, etc. También pueden recuperar datos directamente de algunas bases de datos y APIs (GitHub, Reddit, Google Drive, etc.).
307 | * **División de documentos**: Los divisores de texto descomponen los documentos en fragmentos más pequeños, semánticamente significativos. En lugar de dividir el texto después de *n* caracteres, a menudo es mejor dividir por encabezado o recursivamente, con algunos metadatos adicionales.
308 | * **Modelos de incrustación**: Los modelos de incrustación convierten el texto en representaciones vectoriales. Permite una comprensión más profunda y matizada del lenguaje, esencial para realizar búsquedas semánticas.
309 | * **Bases de datos vectoriales**: Las bases de datos vectoriales (como [Chroma](https://www.trychroma.com/), [Pinecone](https://www.pinecone.io/), [Milvus
310 |
311 | 📚 **Referencias**:
312 | * [LangChain - Divisores de texto](https://python.langchain.com/docs/modules/data_connection/document_transformers/): Lista de diferentes divisores de texto implementados en LangChain.
313 | * [Biblioteca de Transformadores de Oraciones](https://www.sbert.net/): Biblioteca popular para modelos de incrustación.
314 | * [Tablero de Líderes MTEB](https://huggingface.co/spaces/mteb/leaderboard): Tablero de líderes para modelos de incrustación.
315 | * [Las 5 Mejores Bases de Datos Vectoriales](https://www.datacamp.com/blog/the-top-5-vector-databases) por Moez Ali: Una comparación de las mejores y más populares bases de datos vectoriales.
316 |
317 | ---
318 | ### 3. Generación Aumentada por Recuperación (RAG)
319 |
320 | Con RAG, los LLMs recuperan documentos contextuales de una base de datos para mejorar la precisión de sus respuestas. RAG es una forma popular de aumentar el conocimiento del modelo sin necesidad de afinamiento adicional.
321 |
322 | * **Orquestadores**: Los orquestadores (como [LangChain](https://python.langchain.com/docs/get_started/introduction), [LlamaIndex](https://docs.llamaindex.ai/en/stable/), [FastRAG](https://github.com/IntelLabs/fastRAG), etc.) son marcos populares para conectar tus LLMs con herramientas, bases de datos, memorias, etc., y aumentar sus habilidades.
323 | * **Recuperadores**: Las instrucciones de los usuarios no están optimizadas para la recuperación. Diferentes técnicas (por ejemplo, recuperador de múltiples consultas, [HyDE](https://arxiv.org/abs/2212.10496), etc.) pueden aplicarse para reformular/ampliarlas y mejorar el rendimiento.
324 | * **Memoria**: Para recordar instrucciones y respuestas anteriores, LLMs y chatbots como ChatGPT agregan este historial a su ventana de contexto. Este búfer puede mejorarse con resúmenes (por ejemplo, usando un LLM más pequeño), una tienda vectorial + RAG, etc.
325 | * **Evaluación**: Necesitamos evaluar tanto la recuperación de documentos (precisión y recall del contexto) como las etapas de generación (fidelidad y relevancia de la respuesta). Se puede simplificar con herramientas como [Ragas](https://github.com/explodinggradients/ragas/tree/main) y [DeepEval](https://github.com/confident-ai/deepeval).
326 |
327 | 📚 **Referencias**:
328 | * [Llamaindex - Conceptos de alto nivel](https://docs.llamaindex.ai/en/stable/getting_started/concepts.html): Conceptos principales a conocer al construir tuberías RAG.
329 | * [Pinecone - Augmentación de Recuperación](https://www.pinecone.io/learn/series/langchain/langchain-retrieval-augmentation/): Visión general del proceso de augmentación de recuperación.
330 | * [LangChain - Q&A con RAG](https://python.langchain.com/docs/use_cases/question_answering/quickstart): Tutorial paso a paso para construir una típica tubería RAG.
331 | * [LangChain - Tipos de memoria](https://python.langchain.com/docs/modules/memory/types/): Lista de diferentes tipos de memorias con usos relevantes.
332 | * [Pipeline RAG - Métricas](https://docs.ragas.io/en/stable/concepts/metrics/index.html): Visión general de las principales métricas utilizadas para evaluar tuberías RAG.
333 |
334 | ---
335 | ### 4. RAG Avanzado
336 |
337 | Las aplicaciones de la vida real pueden requerir tuberías complejas, incluyendo bases de datos SQL o de grafos, así como la selección automática de herramientas y APIs relevantes. Estas técnicas avanzadas pueden mejorar una solución base y proporcionar características adicionales.
338 |
339 | * **Construcción de consultas**: Los datos estructurados almacenados en bases de datos tradicionales requieren un lenguaje de consulta específico como SQL, Cypher, metadatos, etc. Podemos traducir directamente la instrucción del usuario en una consulta para acceder a los datos con la construcción de consultas.
340 | * **Agentes y herramientas**: Los agentes aumentan los LLMs seleccionando automáticamente las herramientas más relevantes para proporcionar una respuesta. Estas herramientas pueden ser tan simples como usar Google o Wikipedia, o más complejas como un intérprete de Python o Jira.
341 | * **Post-procesamiento**: Paso final que procesa las entradas que se alimentan al LLM. Mejora la relevancia y diversidad de los documentos recuperados con reordenamiento, [RAG-fusión](https://github.com/Raudaschl/rag-fusion), y clasificación.
342 |
343 | 📚 **Referencias**:
344 | * [LangChain - Construcción de Consultas](https://blog.langchain.dev/query-construction/): Publicación de blog sobre diferentes tipos de construcción de consultas.
345 | * [LangChain - SQL](https://python.langchain.com/docs/use_cases/qa_structured/sql): Tutorial sobre cómo interactuar con bases de datos SQL con LLMs, involucrando Texto-a-SQL y un agente SQL opcional.
346 | * [Pinecone - Agentes LLM](https://www.pinecone.io/learn/series/langchain/langchain-agents/): Introducción a agentes y herramientas con diferentes tipos.
347 | * [Agentes Autónomos Potenciados por LLM](https://lilianweng.github.io/posts/2023-06-23-agent/) por Lilian Weng: Artículo más teórico sobre agentes LLM.
348 | * [LangChain - RAG de OpenAI](https://blog.langchain.dev/applying-openai-rag/): Visión general de las estrategias RAG empleadas por OpenAI, incluyendo post-procesamiento.
349 |
350 | ---
351 | ### 5. Optimización de la Inferencia
352 |
353 | La generación de texto es un proceso costoso que requiere hardware caro. Además de la cuantización, se han propuesto varias técnicas para maximizar el rendimiento y reducir los costos de inferencia.
354 |
355 | * **Atención Flash**: Optimización del mecanismo de atención para transformar su complejidad de cuadrática a lineal, acelerando tanto el entrenamiento como la inferencia.
356 | * **Caché de clave-valor**: Entiende el caché de clave-valor y las mejoras introducidas en la [Atención de Múltiples Consultas](https://arxiv.org/abs/1911.02150) (MQA) y la [Atención de Consultas Agrupadas](https://arxiv.org/abs/2305.13245) (GQA).
357 | * **Decodificación especulativa**: Usa un modelo pequeño para producir borradores que luego son revisados por un modelo más grande para acelerar la generación de texto.
358 |
359 | 📚 **Referencias**:
360 | * [Inferencia en GPU](https://huggingface.co/docs/transformers/main/en/perf_infer_gpu_one) por Hugging Face: Explica cómo optimizar la inferencia en GPUs.
361 | * [Inferencia de LLM](https://www.databricks.com/blog/llm-inference-performance-engineering-best-practices) por Databricks: Mejores prácticas sobre cómo optimizar la inferencia de LLM en producción.
362 | * [Optimizando LLMs para Velocidad y Memoria](https://huggingface.co/docs/transformers/main/en/llm_tutorial_optimization) por Hugging Face: Explica tres técnicas principales para optimizar velocidad y memoria, a saber, cuantización, Atención Flash e innovaciones arquitectónicas.
363 | * [Generación Asistida](https://huggingface.co/blog/assisted-generation) por Hugging Face: Versión de Hugging Face de la decodificación especulativa, es un post interesante sobre cómo funciona con código para implementarlo.
364 |
365 | ---
366 | ### 6. Desplegando LLMs
367 |
368 | Desplegar LLMs a escala es una hazaña de ingeniería que puede requerir múltiples clústeres de GPUs. En otros escenarios, demos y aplicaciones locales pueden lograrse con mucha menor complejidad.
369 |
370 | * **Despliegue local**: La privacidad es una ventaja importante que los LLMs de código abierto tienen sobre los privados. Servidores LLM locales ([LM Studio](https://lmstudio.ai/), [Ollama](https://ollama.ai/), [oobabooga](https://github.com/oobabooga/text-generation-webui), [kobold.cpp](https://github.com/LostRuins/koboldcpp), etc.) capitalizan esta ventaja para potenciar aplicaciones locales.
371 | * **Despliegue de demostraciones**: Marcos como [Gradio](https://www.gradio.app/) y [Streamlit](https://docs.streamlit.io/) son útiles para prototipar aplicaciones y compartir demos. También puedes alojarlos fácilmente en línea, por ejemplo, usando [Hugging Face Spaces](https://huggingface.co/spaces).
372 | * **Despliegue de servidores**: Desplegar LLMs a escala requiere infraestructura en la nube (ver también [SkyPilot](https://skypilot.readthedocs.io/en/latest/)) o local y a menudo aprovecha marcos de generación de texto optimizados como [TGI](https://github.com/huggingface/text-generation-inference), [vLLM](https://github.com/vllm-project/vllm/tree/main), etc.
373 | * **Despliegue en el borde**: En entornos restringidos, marcos de alto rendimiento como [MLC LLM](https://github.com/mlc-ai/mlc-llm) y [mnn-llm](https://github.com/wangzhaode/mnn-llm/blob/master/README_en.md) pueden desplegar LLMs en navegadores web, Android e iOS.
374 |
375 | 📚 **Referencias**:
376 | * [Streamlit - Construye una aplicación LLM básica](https://docs.streamlit.io/knowledge-base/tutorials/build-conversational-apps): Tutorial para hacer una app básica tipo ChatGPT usando Streamlit.
377 | * [Contenedor de Inferencia LLM de HF](https://huggingface.co/blog/sagemaker-huggingface-llm): Despliega LLMs en Amazon SageMaker usando el contenedor de inferencia de Hugging Face.
378 | * [Blog de Philschmid](https://www.philschmid.de/) por Philipp Schmid: Colección de artículos de alta calidad sobre despliegue de LLMs usando Amazon SageMaker.
379 | * [Optimizando la latencia](https://hamel.dev/notes/llm/inference/03_inference.html) por Hamel Husain: Comparación de TGI, vLLM, CTranslate2 y mlc en términos de rendimiento y latencia.
380 |
381 | ---
382 | ### 7. Asegurando LLMs
383 |
384 | Además de los problemas de seguridad tradicionales asociados con el software, los LLMs tienen debilidades únicas debido a la forma en que son entrenados y solicitados.
385 |
386 | * **Hackeo de prompts**: Diferentes técnicas relacionadas con la ingeniería de prompts, incluyendo inyección de prompts (instrucción adicional para secuestrar la respuesta del modelo), filtración de datos/prompts (recuperar sus datos/prompts originales), y jailbreaking (crear prompts para eludir características de seguridad).
387 | * **Puertas traseras**: Los vectores de ataque pueden apuntar al propio conjunto de datos de entrenamiento, envenenando los datos de entrenamiento (por ejemplo, con información falsa) o creando puertas traseras (disparadores secretos para cambiar el comportamiento del modelo durante la inferencia).
388 | * **Medidas defensivas**: La mejor manera de proteger tus aplicaciones LLM es probarlas contra estas vulnerabilidades (por ejemplo, usando equipos rojos y controles como [garak](https://github.com/leondz/garak/)) y observarlas en producción (con un marco como [langfuse](https://github.com/langfuse/langfuse)).
389 |
390 | 📚 **Referencias**:
391 | * [OWASP Top 10 para aplicaciones de LLM](https://owasp.org/www-project-top-10-for-large-language-model-applications/) por HEGO Wiki: Lista de las 10 vulnerabilidades críticas más vistas en aplicaciones LLM.
392 | * [Primer sobre Inyección de Prompts](https://github.com/jthack/PIPE) por Joseph Thacker: Guía corta dedicada a la inyección de prompts para ingenieros.
393 | * [Seguridad LLM](https://llmsecurity.net/) por [@llm_sec](https://twitter.com/llm_sec): Lista extensiva de recursos relacionados con la seguridad LLM.
394 | * [Equipos rojos en LLMs](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/red-teaming) por Microsoft: Guía sobre cómo realizar equipos rojos con LLMs.
395 |
396 | ---
397 | ## Acknowledgements
398 |
399 | This roadmap was inspired by the excellent [DevOps Roadmap](https://github.com/milanm/DevOps-Roadmap) from Milan Milanović and Romano Roth.
400 |
401 | Special thanks to:
402 |
403 | * Thomas Thelen for motivating me to create a roadmap
404 | * André Frade for his input and review of the first draft
405 | * Dino Dunn for providing resources about LLM security
406 |
407 | *Disclaimer: I am not affiliated with any sources listed here.*
408 |
409 | ---
410 |
411 |
412 |
413 |
414 |
4 | 🐦 twitter • 5 | 💻 web • 6 | 📹 youtube • 7 | 💻 repo original de @mlabonne 8 |
9 |
532 |
533 |
534 |
535 |