import{S as bp,i as $p,s as qp,e as l,t as n,k as m,w as E,c as i,a as u,h as a,d as t,m as f,x as y,g as p,G as s,y as w,q as g,o as b,B as x,b as A,l as Ml,M as kp,N as Tl,p as ya,v as jp,n as wa}from"../../chunks/vendor-hf-doc-builder.js";import{T as xa}from"../../chunks/Tip-hf-doc-builder.js";import{Y as Ci}from"../../chunks/Youtube-hf-doc-builder.js";import{I as $r}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{C as L}from"../../chunks/CodeBlock-hf-doc-builder.js";import{C as gp}from"../../chunks/CourseFloatingBanner-hf-doc-builder.js";import{F as Ep}from"../../chunks/FrameworkSwitchCourse-hf-doc-builder.js";function yp(O){let r,_;return r=new gp({props:{chapter:7,classNames:"absolute z-10 right-0 top-0",notebooks:[{label:"Google Colab",value:"https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/fr/chapter7/section6_tf.ipynb"},{label:"Aws Studio",value:"https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/fr/chapter7/section6_tf.ipynb"}]}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function wp(O){let r,_;return r=new gp({props:{chapter:7,classNames:"absolute z-10 right-0 top-0",notebooks:[{label:"Google Colab",value:"https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/fr/chapter7/section6_pt.ipynb"},{label:"Aws Studio",value:"https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/fr/chapter7/section6_pt.ipynb"}]}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function xp(O){let r,_;return{c(){r=l("p"),_=n("Le pr\xE9-entra\xEEnement du mod\xE8le de langue prendra un certain temps. Nous vous sugg\xE9rons donc d\u2019ex\xE9cuter d\u2019abord la boucle d\u2019entra\xEEnement sur un petit \xE9chantillon des donn\xE9es en d\xE9commentant les deux lignes dans le code ci-dessus. Assurez-vous alors que l\u2019entra\xEEnement se termine avec succ\xE8s et que les mod\xE8les sont stock\xE9s. Rien n\u2019est plus frustrant qu\u2019un entra\xEEnement qui \xE9choue \xE0 la derni\xE8re \xE9tape car vous avez oubli\xE9 de cr\xE9er un dossier ou parce qu\u2019il y a une faute de frappe \xE0 la fin de la boucle d\u2019entra\xEEnement !")},l(c){r=i(c,"P",{});var v=u(r);_=a(v,"Le pr\xE9-entra\xEEnement du mod\xE8le de langue prendra un certain temps. Nous vous sugg\xE9rons donc d\u2019ex\xE9cuter d\u2019abord la boucle d\u2019entra\xEEnement sur un petit \xE9chantillon des donn\xE9es en d\xE9commentant les deux lignes dans le code ci-dessus. Assurez-vous alors que l\u2019entra\xEEnement se termine avec succ\xE8s et que les mod\xE8les sont stock\xE9s. Rien n\u2019est plus frustrant qu\u2019un entra\xEEnement qui \xE9choue \xE0 la derni\xE8re \xE9tape car vous avez oubli\xE9 de cr\xE9er un dossier ou parce qu\u2019il y a une faute de frappe \xE0 la fin de la boucle d\u2019entra\xEEnement !"),v.forEach(t)},m(c,v){p(c,r,v),s(r,_)},d(c){c&&t(r)}}}function zp(O){let r,_,c,v,k,$,z,D,j,P,N,M,h,T,H,F,Y,R,ee,W,X,C,se;return{c(){r=l("p"),_=n("\u270F\uFE0F "),c=l("strong"),v=n("Essayez !"),k=n(" Se d\xE9barrasser de tous les morceaux qui sont plus petits que la taille du contexte n\u2019\xE9tait pas un gros probl\xE8me ici parce que nous utilisons de petites fen\xEAtres de contexte. Si vous augmentez la taille du contexte (ou si vous avez un corpus de documents courts), la fraction des morceaux qui sont jet\xE9s augmentera. Une fa\xE7on plus efficace de pr\xE9parer les donn\xE9es est de joindre tous les \xE9chantillons dans un batch avec un "),$=l("em"),z=n("token"),D=m(),j=l("code"),P=n("eos_token_id"),N=n(" entre les deux, puis d\u2019effectuer le d\xE9coupage sur les s\xE9quences concat\xE9n\xE9es. Comme exercice, modifiez la fonction "),M=l("code"),h=n("tokenize()"),T=n(" pour utiliser cette approche. Notez que vous devrez mettre "),H=l("code"),F=n("truncation=False"),Y=n(" et enlever les autres arguments du "),R=l("em"),ee=n("tokenizer"),W=n(" pour obtenir la s\xE9quence compl\xE8te des identifiants des "),X=l("em"),C=n("tokens"),se=n(".")},l(V){r=i(V,"P",{});var I=u(r);_=a(I,"\u270F\uFE0F "),c=i(I,"STRONG",{});var S=u(c);v=a(S,"Essayez !"),S.forEach(t),k=a(I," Se d\xE9barrasser de tous les morceaux qui sont plus petits que la taille du contexte n\u2019\xE9tait pas un gros probl\xE8me ici parce que nous utilisons de petites fen\xEAtres de contexte. Si vous augmentez la taille du contexte (ou si vous avez un corpus de documents courts), la fraction des morceaux qui sont jet\xE9s augmentera. Une fa\xE7on plus efficace de pr\xE9parer les donn\xE9es est de joindre tous les \xE9chantillons dans un batch avec un "),$=i(I,"EM",{});var U=u($);z=a(U,"token"),U.forEach(t),D=f(I),j=i(I,"CODE",{});var ae=u(j);P=a(ae,"eos_token_id"),ae.forEach(t),N=a(I," entre les deux, puis d\u2019effectuer le d\xE9coupage sur les s\xE9quences concat\xE9n\xE9es. Comme exercice, modifiez la fonction "),M=i(I,"CODE",{});var he=u(M);h=a(he,"tokenize()"),he.forEach(t),T=a(I," pour utiliser cette approche. Notez que vous devrez mettre "),H=i(I,"CODE",{});var J=u(H);F=a(J,"truncation=False"),J.forEach(t),Y=a(I," et enlever les autres arguments du "),R=i(I,"EM",{});var ue=u(R);ee=a(ue,"tokenizer"),ue.forEach(t),W=a(I," pour obtenir la s\xE9quence compl\xE8te des identifiants des "),X=i(I,"EM",{});var ve=u(X);C=a(ve,"tokens"),ve.forEach(t),se=a(I,"."),I.forEach(t)},m(V,I){p(V,r,I),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D),s(r,j),s(j,P),s(r,N),s(r,M),s(M,h),s(r,T),s(r,H),s(H,F),s(r,Y),s(r,R),s(R,ee),s(r,W),s(r,X),s(X,C),s(r,se)},d(V){V&&t(r)}}}function Pp(O){let r,_,c,v,k,$,z,D,j,P,N,M;return r=new L({props:{code:`from transformers import AutoTokenizer, TFGPT2LMHeadModel, AutoConfig

config = AutoConfig.from_pretrained(
    "gpt2",
    vocab_size=len(tokenizer),
    n_ctx=context_length,
    bos_token_id=tokenizer.bos_token_id,
    eos_token_id=tokenizer.eos_token_id,
)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, TFGPT2LMHeadModel, AutoConfig

config = AutoConfig.from_pretrained(
    <span class="hljs-string">&quot;gpt2&quot;</span>,
    vocab_size=<span class="hljs-built_in">len</span>(tokenizer),
    n_ctx=context_length,
    bos_token_id=tokenizer.bos_token_id,
    eos_token_id=tokenizer.eos_token_id,
)`}}),j=new L({props:{code:`model = TFGPT2LMHeadModel(config)
model(model.dummy_inputs)  # Construit le mod\xE8le
model.summary()`,highlighted:`model = TFGPT2LMHeadModel(config)
model(model.dummy_inputs)  <span class="hljs-comment"># Construit le mod\xE8le</span>
model.summary()`}}),N=new L({props:{code:`_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
transformer (TFGPT2MainLayer multiple                  124242432 
=================================================================
Total params: 124,242,432
Trainable params: 124,242,432
Non-trainable params: 0
_________________________________________________________________`,highlighted:`_________________________________________________________________
Layer (<span class="hljs-built_in">type</span>)                 Output Shape              Param <span class="hljs-comment">#   </span>
=================================================================
transformer (TFGPT2MainLayer multiple                  <span class="hljs-number">124242432</span> 
=================================================================
Total params: <span class="hljs-number">124</span>,<span class="hljs-number">242</span>,<span class="hljs-number">432</span>
Trainable params: <span class="hljs-number">124</span>,<span class="hljs-number">242</span>,<span class="hljs-number">432</span>
Non-trainable params: <span class="hljs-number">0</span>
_________________________________________________________________`}}),{c(){E(r.$$.fragment),_=m(),c=l("p"),v=n("Avec cette configuration, nous pouvons charger un nouveau mod\xE8le. Notez que c\u2019est la premi\xE8re fois que nous n\u2019utilisons pas la fonction "),k=l("code"),$=n("from_pretrained()"),z=n(" puisque nous initialisons nous-m\xEAmes un mod\xE8le :"),D=m(),E(j.$$.fragment),P=m(),E(N.$$.fragment)},l(h){y(r.$$.fragment,h),_=f(h),c=i(h,"P",{});var T=u(c);v=a(T,"Avec cette configuration, nous pouvons charger un nouveau mod\xE8le. Notez que c\u2019est la premi\xE8re fois que nous n\u2019utilisons pas la fonction "),k=i(T,"CODE",{});var H=u(k);$=a(H,"from_pretrained()"),H.forEach(t),z=a(T," puisque nous initialisons nous-m\xEAmes un mod\xE8le :"),T.forEach(t),D=f(h),y(j.$$.fragment,h),P=f(h),y(N.$$.fragment,h)},m(h,T){w(r,h,T),p(h,_,T),p(h,c,T),s(c,v),s(c,k),s(k,$),s(c,z),p(h,D,T),w(j,h,T),p(h,P,T),w(N,h,T),M=!0},i(h){M||(g(r.$$.fragment,h),g(j.$$.fragment,h),g(N.$$.fragment,h),M=!0)},o(h){b(r.$$.fragment,h),b(j.$$.fragment,h),b(N.$$.fragment,h),M=!1},d(h){x(r,h),h&&t(_),h&&t(c),h&&t(D),x(j,h),h&&t(P),x(N,h)}}}function Cp(O){let r,_,c,v,k,$,z,D,j,P,N,M;return r=new L({props:{code:`from transformers import AutoTokenizer, GPT2LMHeadModel, AutoConfig

config = AutoConfig.from_pretrained(
    "gpt2",
    vocab_size=len(tokenizer),
    n_ctx=context_length,
    bos_token_id=tokenizer.bos_token_id,
    eos_token_id=tokenizer.eos_token_id,
)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, GPT2LMHeadModel, AutoConfig

config = AutoConfig.from_pretrained(
    <span class="hljs-string">&quot;gpt2&quot;</span>,
    vocab_size=<span class="hljs-built_in">len</span>(tokenizer),
    n_ctx=context_length,
    bos_token_id=tokenizer.bos_token_id,
    eos_token_id=tokenizer.eos_token_id,
)`}}),j=new L({props:{code:`model = GPT2LMHeadModel(config)
model_size = sum(t.numel() for t in model.parameters())
print(f"GPT-2 size: {model_size/1000**2:.1f}M parameters")`,highlighted:`model = GPT2LMHeadModel(config)
model_size = <span class="hljs-built_in">sum</span>(t.numel() <span class="hljs-keyword">for</span> t <span class="hljs-keyword">in</span> model.parameters())
<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;GPT-2 size: <span class="hljs-subst">{model_size/<span class="hljs-number">1000</span>**<span class="hljs-number">2</span>:<span class="hljs-number">.1</span>f}</span>M parameters&quot;</span>)`}}),N=new L({props:{code:"GPT-2 size: 124.2M parameters",highlighted:'GPT-<span class="hljs-number">2</span> size: <span class="hljs-number">124.2</span>M parameters'}}),{c(){E(r.$$.fragment),_=m(),c=l("p"),v=n("Avec cette configuration, nous pouvons charger un nouveau mod\xE8le. Notez que c\u2019est la premi\xE8re fois que nous n\u2019utilisons pas la fonction "),k=l("code"),$=n("from_pretrained()"),z=n(" puisque nous initialisons nous-m\xEAmes un mod\xE8le :"),D=m(),E(j.$$.fragment),P=m(),E(N.$$.fragment)},l(h){y(r.$$.fragment,h),_=f(h),c=i(h,"P",{});var T=u(c);v=a(T,"Avec cette configuration, nous pouvons charger un nouveau mod\xE8le. Notez que c\u2019est la premi\xE8re fois que nous n\u2019utilisons pas la fonction "),k=i(T,"CODE",{});var H=u(k);$=a(H,"from_pretrained()"),H.forEach(t),z=a(T," puisque nous initialisons nous-m\xEAmes un mod\xE8le :"),T.forEach(t),D=f(h),y(j.$$.fragment,h),P=f(h),y(N.$$.fragment,h)},m(h,T){w(r,h,T),p(h,_,T),p(h,c,T),s(c,v),s(c,k),s(k,$),s(c,z),p(h,D,T),w(j,h,T),p(h,P,T),w(N,h,T),M=!0},i(h){M||(g(r.$$.fragment,h),g(j.$$.fragment,h),g(N.$$.fragment,h),M=!0)},o(h){b(r.$$.fragment,h),b(j.$$.fragment,h),b(N.$$.fragment,h),M=!1},d(h){x(r,h),h&&t(_),h&&t(c),h&&t(D),x(j,h),h&&t(P),x(N,h)}}}function Dp(O){let r,_;return r=new L({props:{code:`from transformers import DataCollatorForLanguageModeling

tokenizer.pad_token = tokenizer.eos_token
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False, return_tensors="tf")`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> DataCollatorForLanguageModeling

tokenizer.pad_token = tokenizer.eos_token
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=<span class="hljs-literal">False</span>, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>)`}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function Tp(O){let r,_;return r=new L({props:{code:`from transformers import DataCollatorForLanguageModeling

tokenizer.pad_token = tokenizer.eos_token
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> DataCollatorForLanguageModeling

tokenizer.pad_token = tokenizer.eos_token
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=<span class="hljs-literal">False</span>)`}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function Mp(O){let r,_;return r=new L({props:{code:`input_ids shape: (5, 128)
attention_mask shape: (5, 128)
labels shape: (5, 128)`,highlighted:`input_ids shape: (<span class="hljs-number">5</span>, <span class="hljs-number">128</span>)
attention_mask shape: (<span class="hljs-number">5</span>, <span class="hljs-number">128</span>)
labels shape: (<span class="hljs-number">5</span>, <span class="hljs-number">128</span>)`}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function Ap(O){let r,_;return r=new L({props:{code:`input_ids shape: torch.Size([5, 128])
attention_mask shape: torch.Size([5, 128])
labels shape: torch.Size([5, 128])`,highlighted:`input_ids shape: torch.Size([<span class="hljs-number">5</span>, <span class="hljs-number">128</span>])
attention_mask shape: torch.Size([<span class="hljs-number">5</span>, <span class="hljs-number">128</span>])
labels shape: torch.Size([<span class="hljs-number">5</span>, <span class="hljs-number">128</span>])`}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function hp(O){let r,_,c,v,k,$,z,D;return z=new L({props:{code:`tf_train_dataset = tokenized_dataset["train"].to_tf_dataset(
    columns=["input_ids", "attention_mask", "labels"],
    collate_fn=data_collator,
    shuffle=True,
    batch_size=32,
)
tf_eval_dataset = tokenized_dataset["valid"].to_tf_dataset(
    columns=["input_ids", "attention_mask", "labels"],
    collate_fn=data_collator,
    shuffle=False,
    batch_size=32,
)`,highlighted:`tf_train_dataset = tokenized_dataset[<span class="hljs-string">&quot;train&quot;</span>].to_tf_dataset(
    columns=[<span class="hljs-string">&quot;input_ids&quot;</span>, <span class="hljs-string">&quot;attention_mask&quot;</span>, <span class="hljs-string">&quot;labels&quot;</span>],
    collate_fn=data_collator,
    shuffle=<span class="hljs-literal">True</span>,
    batch_size=<span class="hljs-number">32</span>,
)
tf_eval_dataset = tokenized_dataset[<span class="hljs-string">&quot;valid&quot;</span>].to_tf_dataset(
    columns=[<span class="hljs-string">&quot;input_ids&quot;</span>, <span class="hljs-string">&quot;attention_mask&quot;</span>, <span class="hljs-string">&quot;labels&quot;</span>],
    collate_fn=data_collator,
    shuffle=<span class="hljs-literal">False</span>,
    batch_size=<span class="hljs-number">32</span>,
)`}}),{c(){r=l("p"),_=n("Maintenant nous pouvons utiliser la m\xE9thode "),c=l("code"),v=n("to_tf_dataset()"),k=n(" pour convertir nos jeux de donn\xE9es en jeux de donn\xE9es TensorFlow avec l\u2019assembleur de donn\xE9es que nous avons cr\xE9\xE9 ci-dessus :"),$=m(),E(z.$$.fragment)},l(j){r=i(j,"P",{});var P=u(r);_=a(P,"Maintenant nous pouvons utiliser la m\xE9thode "),c=i(P,"CODE",{});var N=u(c);v=a(N,"to_tf_dataset()"),N.forEach(t),k=a(P," pour convertir nos jeux de donn\xE9es en jeux de donn\xE9es TensorFlow avec l\u2019assembleur de donn\xE9es que nous avons cr\xE9\xE9 ci-dessus :"),P.forEach(t),$=f(j),y(z.$$.fragment,j)},m(j,P){p(j,r,P),s(r,_),s(r,c),s(c,v),s(r,k),p(j,$,P),w(z,j,P),D=!0},i(j){D||(g(z.$$.fragment,j),D=!0)},o(j){b(z.$$.fragment,j),D=!1},d(j){j&&t(r),j&&t($),x(z,j)}}}function Np(O){let r,_;return{c(){r=l("p"),_=n("\u26A0\uFE0F Le d\xE9placement des entr\xE9es et des \xE9tiquettes pour les aligner se fait \xE0 l\u2019int\xE9rieur du mod\xE8le, de sorte que l\u2019assembleur de donn\xE9es ne fait que copier les entr\xE9es pour cr\xE9er les \xE9tiquettes.")},l(c){r=i(c,"P",{});var v=u(r);_=a(v,"\u26A0\uFE0F Le d\xE9placement des entr\xE9es et des \xE9tiquettes pour les aligner se fait \xE0 l\u2019int\xE9rieur du mod\xE8le, de sorte que l\u2019assembleur de donn\xE9es ne fait que copier les entr\xE9es pour cr\xE9er les \xE9tiquettes."),v.forEach(t)},m(c,v){p(c,r,v),s(r,_)},d(c){c&&t(r)}}}function Lp(O){let r,_,c,v,k,$,z,D,j,P,N,M,h,T,H,F,Y,R,ee,W,X,C,se,V,I;return P=new L({props:{code:`from transformers import create_optimizer
import tensorflow as tf

num_train_steps = len(tf_train_dataset)
optimizer, schedule = create_optimizer(
    init_lr=5e-5,
    num_warmup_steps=1_000,
    num_train_steps=num_train_steps,
    weight_decay_rate=0.01,
)
model.compile(optimizer=optimizer)

# Entra\xEEner en mixed-precision float16
tf.keras.mixed_precision.set_global_policy("mixed_float16")`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> create_optimizer
<span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

num_train_steps = <span class="hljs-built_in">len</span>(tf_train_dataset)
optimizer, schedule = create_optimizer(
    init_lr=<span class="hljs-number">5e-5</span>,
    num_warmup_steps=<span class="hljs-number">1_000</span>,
    num_train_steps=num_train_steps,
    weight_decay_rate=<span class="hljs-number">0.01</span>,
)
model.<span class="hljs-built_in">compile</span>(optimizer=optimizer)

<span class="hljs-comment"># Entra\xEEner en mixed-precision float16</span>
tf.keras.mixed_precision.set_global_policy(<span class="hljs-string">&quot;mixed_float16&quot;</span>)`}}),V=new L({props:{code:`from transformers.keras_callbacks import PushToHubCallback

callback = PushToHubCallback(output_dir="codeparrot-ds", tokenizer=tokenizer)

model.fit(tf_train_dataset, validation_data=tf_eval_dataset, callbacks=[callback])`,highlighted:`<span class="hljs-keyword">from</span> transformers.keras_callbacks <span class="hljs-keyword">import</span> PushToHubCallback

callback = PushToHubCallback(output_dir=<span class="hljs-string">&quot;codeparrot-ds&quot;</span>, tokenizer=tokenizer)

model.fit(tf_train_dataset, validation_data=tf_eval_dataset, callbacks=[callback])`}}),{c(){r=l("p"),_=n("Tout ce qu\u2019il reste \xE0 faire est de configurer les hyperparam\xE8tres d\u2019entra\xEEnement et d\u2019appeler "),c=l("code"),v=n("compile()"),k=n(" et "),$=l("code"),z=n("fit()"),D=n(". Nous utiliserons un programme de taux d\u2019apprentissage avec un r\xE9chauffement pour am\xE9liorer la stabilit\xE9 de l\u2019entra\xEEnement :"),j=m(),E(P.$$.fragment),N=m(),M=l("p"),h=n("Maintenant, nous pouvons simplement appeler "),T=l("code"),H=n("model.fit()"),F=n(" et attendre que l\u2019entra\xEEnement se termine. Selon que vous l\u2019ex\xE9cutez sur la totalit\xE9 ou sur un sous-ensemble de l\u2019\xE9chantillon d\u2019entra\xEEnement, cela prendra respectivement 20 ou 2 heures. Alors prenez quelques caf\xE9s et un bon livre \xE0 lire ! Une fois l\u2019entra\xEEnement termin\xE9, nous pouvons pousser le mod\xE8le et le "),Y=l("em"),R=n("tokenizer"),ee=n(" vers le "),W=l("em"),X=n("Hub"),C=n(" :"),se=m(),E(V.$$.fragment)},l(S){r=i(S,"P",{});var U=u(r);_=a(U,"Tout ce qu\u2019il reste \xE0 faire est de configurer les hyperparam\xE8tres d\u2019entra\xEEnement et d\u2019appeler "),c=i(U,"CODE",{});var ae=u(c);v=a(ae,"compile()"),ae.forEach(t),k=a(U," et "),$=i(U,"CODE",{});var he=u($);z=a(he,"fit()"),he.forEach(t),D=a(U,". Nous utiliserons un programme de taux d\u2019apprentissage avec un r\xE9chauffement pour am\xE9liorer la stabilit\xE9 de l\u2019entra\xEEnement :"),U.forEach(t),j=f(S),y(P.$$.fragment,S),N=f(S),M=i(S,"P",{});var J=u(M);h=a(J,"Maintenant, nous pouvons simplement appeler "),T=i(J,"CODE",{});var ue=u(T);H=a(ue,"model.fit()"),ue.forEach(t),F=a(J," et attendre que l\u2019entra\xEEnement se termine. Selon que vous l\u2019ex\xE9cutez sur la totalit\xE9 ou sur un sous-ensemble de l\u2019\xE9chantillon d\u2019entra\xEEnement, cela prendra respectivement 20 ou 2 heures. Alors prenez quelques caf\xE9s et un bon livre \xE0 lire ! Une fois l\u2019entra\xEEnement termin\xE9, nous pouvons pousser le mod\xE8le et le "),Y=i(J,"EM",{});var ve=u(Y);R=a(ve,"tokenizer"),ve.forEach(t),ee=a(J," vers le "),W=i(J,"EM",{});var ge=u(W);X=a(ge,"Hub"),ge.forEach(t),C=a(J," :"),J.forEach(t),se=f(S),y(V.$$.fragment,S)},m(S,U){p(S,r,U),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D),p(S,j,U),w(P,S,U),p(S,N,U),p(S,M,U),s(M,h),s(M,T),s(T,H),s(M,F),s(M,Y),s(Y,R),s(M,ee),s(M,W),s(W,X),s(M,C),p(S,se,U),w(V,S,U),I=!0},i(S){I||(g(P.$$.fragment,S),g(V.$$.fragment,S),I=!0)},o(S){b(P.$$.fragment,S),b(V.$$.fragment,S),I=!1},d(S){S&&t(r),S&&t(j),x(P,S),S&&t(N),S&&t(M),S&&t(se),x(V,S)}}}function Op(O){let r,_,c,v,k,$,z,D,j,P,N,M,h,T,H,F,Y,R,ee,W,X,C,se,V,I,S,U,ae,he,J,ue,ve,ge,Q,ze,je;return F=new L({props:{code:`from transformers import Trainer, TrainingArguments

args = TrainingArguments(
    output_dir="codeparrot-ds",
    per_device_train_batch_size=32,
    per_device_eval_batch_size=32,
    evaluation_strategy="steps",
    eval_steps=5_000,
    logging_steps=5_000,
    gradient_accumulation_steps=8,
    num_train_epochs=1,
    weight_decay=0.1,
    warmup_steps=1_000,
    lr_scheduler_type="cosine",
    learning_rate=5e-4,
    save_steps=5_000,
    fp16=True,
    push_to_hub=True,
)

trainer = Trainer(
    model=model,
    tokenizer=tokenizer,
    args=args,
    data_collator=data_collator,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["valid"],
)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> Trainer, TrainingArguments

args = TrainingArguments(
    output_dir=<span class="hljs-string">&quot;codeparrot-ds&quot;</span>,
    per_device_train_batch_size=<span class="hljs-number">32</span>,
    per_device_eval_batch_size=<span class="hljs-number">32</span>,
    evaluation_strategy=<span class="hljs-string">&quot;steps&quot;</span>,
    eval_steps=<span class="hljs-number">5_000</span>,
    logging_steps=<span class="hljs-number">5_000</span>,
    gradient_accumulation_steps=<span class="hljs-number">8</span>,
    num_train_epochs=<span class="hljs-number">1</span>,
    weight_decay=<span class="hljs-number">0.1</span>,
    warmup_steps=<span class="hljs-number">1_000</span>,
    lr_scheduler_type=<span class="hljs-string">&quot;cosine&quot;</span>,
    learning_rate=<span class="hljs-number">5e-4</span>,
    save_steps=<span class="hljs-number">5_000</span>,
    fp16=<span class="hljs-literal">True</span>,
    push_to_hub=<span class="hljs-literal">True</span>,
)

trainer = Trainer(
    model=model,
    tokenizer=tokenizer,
    args=args,
    data_collator=data_collator,
    train_dataset=tokenized_datasets[<span class="hljs-string">&quot;train&quot;</span>],
    eval_dataset=tokenized_datasets[<span class="hljs-string">&quot;valid&quot;</span>],
)`}}),V=new L({props:{code:"trainer.train()",highlighted:"trainer.train()"}}),ze=new L({props:{code:"trainer.push_to_hub()",highlighted:"trainer.push_to_hub()"}}),{c(){r=l("p"),_=n("Tout ce qu\u2019il reste \xE0 faire est de configurer les arguments d\u2019entra\xEEnement et de lancer la fonction "),c=l("code"),v=n("Trainer"),k=n(". Nous utiliserons un programme de taux d\u2019apprentissage de type cosinus avec un r\xE9chauffement et une taille de batch de 256 ("),$=l("code"),z=n("per_device_train_batch_size"),D=n(" x "),j=l("code"),P=n("gradient_accumulation_steps"),N=n("). L\u2019accumulation du gradient est utilis\xE9e lorsqu\u2019un seul batch ne tient pas en m\xE9moire, et construit le gradient de mani\xE8re incr\xE9mentale \xE0 travers plusieurs passages en avant/en arri\xE8re. Nous verrons cela en action lorsque nous cr\xE9erons la boucle d\u2019entra\xEEnement avec \u{1F917} "),M=l("em"),h=n("Accelerate"),T=n("."),H=m(),E(F.$$.fragment),Y=m(),R=l("p"),ee=n("Maintenant, nous pouvons simplement lancer le "),W=l("code"),X=n("Trainer"),C=n(" et attendre que l\u2019entra\xEEnement se termine. Selon que vous l\u2019ex\xE9cutez sur la totalit\xE9 ou sur un sous-ensemble de l\u2019\xE9chantillon d\u2019entra\xEEnement, cela prendra respectivement 20 ou 2 heures. Alors prenez quelques caf\xE9s et un bon livre \xE0 lire !"),se=m(),E(V.$$.fragment),I=m(),S=l("p"),U=n("Une fois l\u2019entra\xEEnement termin\xE9, nous pouvons pousser le mod\xE8le et le "),ae=l("em"),he=n("tokenizer"),J=n(" vers le "),ue=l("em"),ve=n("Hub"),ge=n(" :"),Q=m(),E(ze.$$.fragment)},l(G){r=i(G,"P",{});var K=u(r);_=a(K,"Tout ce qu\u2019il reste \xE0 faire est de configurer les arguments d\u2019entra\xEEnement et de lancer la fonction "),c=i(K,"CODE",{});var Ae=u(c);v=a(Ae,"Trainer"),Ae.forEach(t),k=a(K,". Nous utiliserons un programme de taux d\u2019apprentissage de type cosinus avec un r\xE9chauffement et une taille de batch de 256 ("),$=i(K,"CODE",{});var nt=u($);z=a(nt,"per_device_train_batch_size"),nt.forEach(t),D=a(K," x "),j=i(K,"CODE",{});var at=u(j);P=a(at,"gradient_accumulation_steps"),at.forEach(t),N=a(K,"). L\u2019accumulation du gradient est utilis\xE9e lorsqu\u2019un seul batch ne tient pas en m\xE9moire, et construit le gradient de mani\xE8re incr\xE9mentale \xE0 travers plusieurs passages en avant/en arri\xE8re. Nous verrons cela en action lorsque nous cr\xE9erons la boucle d\u2019entra\xEEnement avec \u{1F917} "),M=i(K,"EM",{});var Ne=u(M);h=a(Ne,"Accelerate"),Ne.forEach(t),T=a(K,"."),K.forEach(t),H=f(G),y(F.$$.fragment,G),Y=f(G),R=i(G,"P",{});var ns=u(R);ee=a(ns,"Maintenant, nous pouvons simplement lancer le "),W=i(ns,"CODE",{});var ot=u(W);X=a(ot,"Trainer"),ot.forEach(t),C=a(ns," et attendre que l\u2019entra\xEEnement se termine. Selon que vous l\u2019ex\xE9cutez sur la totalit\xE9 ou sur un sous-ensemble de l\u2019\xE9chantillon d\u2019entra\xEEnement, cela prendra respectivement 20 ou 2 heures. Alors prenez quelques caf\xE9s et un bon livre \xE0 lire !"),ns.forEach(t),se=f(G),y(V.$$.fragment,G),I=f(G),S=i(G,"P",{});var me=u(S);U=a(me,"Une fois l\u2019entra\xEEnement termin\xE9, nous pouvons pousser le mod\xE8le et le "),ae=i(me,"EM",{});var rt=u(ae);he=a(rt,"tokenizer"),rt.forEach(t),J=a(me," vers le "),ue=i(me,"EM",{});var lt=u(ue);ve=a(lt,"Hub"),lt.forEach(t),ge=a(me," :"),me.forEach(t),Q=f(G),y(ze.$$.fragment,G)},m(G,K){p(G,r,K),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D),s(r,j),s(j,P),s(r,N),s(r,M),s(M,h),s(r,T),p(G,H,K),w(F,G,K),p(G,Y,K),p(G,R,K),s(R,ee),s(R,W),s(W,X),s(R,C),p(G,se,K),w(V,G,K),p(G,I,K),p(G,S,K),s(S,U),s(S,ae),s(ae,he),s(S,J),s(S,ue),s(ue,ve),s(S,ge),p(G,Q,K),w(ze,G,K),je=!0},i(G){je||(g(F.$$.fragment,G),g(V.$$.fragment,G),g(ze.$$.fragment,G),je=!0)},o(G){b(F.$$.fragment,G),b(V.$$.fragment,G),b(ze.$$.fragment,G),je=!1},d(G){G&&t(r),G&&t(H),x(F,G),G&&t(Y),G&&t(R),G&&t(se),x(V,G),G&&t(I),G&&t(S),G&&t(Q),x(ze,G)}}}function Sp(O){let r,_,c,v,k,$,z,D;return{c(){r=l("p"),_=n("\u270F\uFE0F "),c=l("strong"),v=n("Essayez !"),k=n(" Il ne nous a fallu qu\u2019une trentaine de lignes de code en plus des "),$=l("code"),z=n("TrainingArguments"),D=n(" pour passer des textes bruts \xE0 l\u2019entra\xEEnement du GPT-2. Essayez-le avec votre propre jeu de donn\xE9es et voyez si vous pouvez obtenir de bons r\xE9sultats !")},l(j){r=i(j,"P",{});var P=u(r);_=a(P,"\u270F\uFE0F "),c=i(P,"STRONG",{});var N=u(c);v=a(N,"Essayez !"),N.forEach(t),k=a(P," Il ne nous a fallu qu\u2019une trentaine de lignes de code en plus des "),$=i(P,"CODE",{});var M=u($);z=a(M,"TrainingArguments"),M.forEach(t),D=a(P," pour passer des textes bruts \xE0 l\u2019entra\xEEnement du GPT-2. Essayez-le avec votre propre jeu de donn\xE9es et voyez si vous pouvez obtenir de bons r\xE9sultats !"),P.forEach(t)},m(j,P){p(j,r,P),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D)},d(j){j&&t(r)}}}function Gp(O){let r,_,c,v,k,$,z,D,j,P,N,M,h,T,H,F,Y,R,ee,W;return{c(){r=l("p"),_=n("\u{1F4A1} Si vous avez acc\xE8s \xE0 une machine avec plusieurs GPUs, vous pouvez essayer d\u2019utiliser "),c=l("code"),v=n("MirroredStrategy"),k=n(" pour acc\xE9l\xE9rer consid\xE9rablement l\u2019entra\xEEnement. Vous devrez cr\xE9er un objet "),$=l("code"),z=n("tf.distribute.MirroredStrategy"),D=n(" et vous assurer que les commandes "),j=l("code"),P=n("to_tf_dataset"),N=n(" ainsi que la cr\xE9ation du mod\xE8le et l\u2019appel \xE0 "),M=l("code"),h=n("fit()"),T=n(" sont tous ex\xE9cut\xE9s dans "),H=l("code"),F=n("scope()"),Y=n(". Vous pouvez consulter la documentation \xE0 ce sujet "),R=l("a"),ee=n("ici"),W=n("."),this.h()},l(X){r=i(X,"P",{});var C=u(r);_=a(C,"\u{1F4A1} Si vous avez acc\xE8s \xE0 une machine avec plusieurs GPUs, vous pouvez essayer d\u2019utiliser "),c=i(C,"CODE",{});var se=u(c);v=a(se,"MirroredStrategy"),se.forEach(t),k=a(C," pour acc\xE9l\xE9rer consid\xE9rablement l\u2019entra\xEEnement. Vous devrez cr\xE9er un objet "),$=i(C,"CODE",{});var V=u($);z=a(V,"tf.distribute.MirroredStrategy"),V.forEach(t),D=a(C," et vous assurer que les commandes "),j=i(C,"CODE",{});var I=u(j);P=a(I,"to_tf_dataset"),I.forEach(t),N=a(C," ainsi que la cr\xE9ation du mod\xE8le et l\u2019appel \xE0 "),M=i(C,"CODE",{});var S=u(M);h=a(S,"fit()"),S.forEach(t),T=a(C," sont tous ex\xE9cut\xE9s dans "),H=i(C,"CODE",{});var U=u(H);F=a(U,"scope()"),U.forEach(t),Y=a(C,". Vous pouvez consulter la documentation \xE0 ce sujet "),R=i(C,"A",{href:!0,rel:!0});var ae=u(R);ee=a(ae,"ici"),ae.forEach(t),W=a(C,"."),C.forEach(t),this.h()},h(){A(R,"href","https://www.tensorflow.org/guide/distributed_training#use_tfdistributestrategy_with_keras_modelfit"),A(R,"rel","nofollow")},m(X,C){p(X,r,C),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D),s(r,j),s(j,P),s(r,N),s(r,M),s(M,h),s(r,T),s(r,H),s(H,F),s(r,Y),s(r,R),s(R,ee),s(r,W)},d(X){X&&t(r)}}}function Fp(O){let r,_,c,v,k;return{c(){r=l("p"),_=n("\u{1F4A1} Si vous avez acc\xE8s \xE0 une machine avec plusieurs GPUs, essayez d\u2019y ex\xE9cuter le code. "),c=l("code"),v=n("Trainer"),k=n(" g\xE8re automatiquement plusieurs machines ce qui peut acc\xE9l\xE9rer consid\xE9rablement l\u2019entra\xEEnement.")},l($){r=i($,"P",{});var z=u(r);_=a(z,"\u{1F4A1} Si vous avez acc\xE8s \xE0 une machine avec plusieurs GPUs, essayez d\u2019y ex\xE9cuter le code. "),c=i(z,"CODE",{});var D=u(c);v=a(D,"Trainer"),D.forEach(t),k=a(z," g\xE8re automatiquement plusieurs machines ce qui peut acc\xE9l\xE9rer consid\xE9rablement l\u2019entra\xEEnement."),z.forEach(t)},m($,z){p($,r,z),s(r,_),s(r,c),s(c,v),s(r,k)},d($){$&&t(r)}}}function Hp(O){let r;function _(k,$){return k[0]==="pt"?Fp:Gp}let c=_(O),v=c(O);return{c(){v.c(),r=Ml()},l(k){v.l(k),r=Ml()},m(k,$){v.m(k,$),p(k,r,$)},p(k,$){c!==(c=_(k))&&(v.d(1),v=c(k),v&&(v.c(),v.m(r.parentNode,r)))},d(k){v.d(k),k&&t(r)}}}function Ip(O){let r,_;return r=new L({props:{code:`from transformers import pipeline

course_model = TFGPT2LMHeadModel.from_pretrained("huggingface-course/codeparrot-ds")
course_tokenizer = AutoTokenizer.from_pretrained("huggingface-course/codeparrot-ds")
pipe = pipeline(
    "text-generation", model=course_model, tokenizer=course_tokenizer, device=0
)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> pipeline

course_model = TFGPT2LMHeadModel.from_pretrained(<span class="hljs-string">&quot;huggingface-course/codeparrot-ds&quot;</span>)
course_tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;huggingface-course/codeparrot-ds&quot;</span>)
pipe = pipeline(
    <span class="hljs-string">&quot;text-generation&quot;</span>, model=course_model, tokenizer=course_tokenizer, device=<span class="hljs-number">0</span>
)`}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function Rp(O){let r,_;return r=new L({props:{code:`import torch
from transformers import pipeline

device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
pipe = pipeline(
    "text-generation", model="huggingface-course/codeparrot-ds", device=device
)`,highlighted:`<span class="hljs-keyword">import</span> torch
<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> pipeline

device = torch.device(<span class="hljs-string">&quot;cuda&quot;</span>) <span class="hljs-keyword">if</span> torch.cuda.is_available() <span class="hljs-keyword">else</span> torch.device(<span class="hljs-string">&quot;cpu&quot;</span>)
pipe = pipeline(
    <span class="hljs-string">&quot;text-generation&quot;</span>, model=<span class="hljs-string">&quot;huggingface-course/codeparrot-ds&quot;</span>, device=device
)`}}),{c(){E(r.$$.fragment)},l(c){y(r.$$.fragment,c)},m(c,v){w(r,c,v),_=!0},i(c){_||(g(r.$$.fragment,c),_=!0)},o(c){b(r.$$.fragment,c),_=!1},d(c){x(r,c)}}}function Vp(O){let r,_,c,v,k,$,z,D;return{c(){r=l("p"),_=n("Au vu de ces quelques exemples, il semble que le mod\xE8le ait appris une partie de la syntaxe des biblioth\xE8ques Python de science des donn\xE9es. Bien s\xFBr, nous devrions \xE9valuer le mod\xE8le de mani\xE8re plus approfondie avant de le d\xE9ployer dans le monde r\xE9el, mais il s\u2019agit tout de m\xEAme d\u2019un prototype impressionnant. Parfois, il est n\xE9cessaire de personnaliser davantage l\u2019entra\xEEnement du mod\xE8le afin d\u2019obtenir les performances n\xE9cessaires pour un cas d\u2019utilisation donn\xE9. Par exemple, que se passe-t-il si l\u2019on souhaite mettre \xE0 jour dynamiquement la taille du batch ou si l\u2019on dispose d\u2019une boucle d\u2019entra\xEEnement conditionnelle qui ignore les mauvais exemples \xE0 la vol\xE9e ? Une option serait de sous-classer le "),c=l("code"),v=n("Trainer"),k=n(" et d\u2019ajouter les changements n\xE9cessaires, mais parfois il est plus simple d\u2019\xE9crire la boucle d\u2019entra\xEEnement \xE0 partir de z\xE9ro. C\u2019est l\xE0 qu\u2019intervient \u{1F917} "),$=l("em"),z=n("Accelerate"),D=n(".")},l(j){r=i(j,"P",{});var P=u(r);_=a(P,"Au vu de ces quelques exemples, il semble que le mod\xE8le ait appris une partie de la syntaxe des biblioth\xE8ques Python de science des donn\xE9es. Bien s\xFBr, nous devrions \xE9valuer le mod\xE8le de mani\xE8re plus approfondie avant de le d\xE9ployer dans le monde r\xE9el, mais il s\u2019agit tout de m\xEAme d\u2019un prototype impressionnant. Parfois, il est n\xE9cessaire de personnaliser davantage l\u2019entra\xEEnement du mod\xE8le afin d\u2019obtenir les performances n\xE9cessaires pour un cas d\u2019utilisation donn\xE9. Par exemple, que se passe-t-il si l\u2019on souhaite mettre \xE0 jour dynamiquement la taille du batch ou si l\u2019on dispose d\u2019une boucle d\u2019entra\xEEnement conditionnelle qui ignore les mauvais exemples \xE0 la vol\xE9e ? Une option serait de sous-classer le "),c=i(P,"CODE",{});var N=u(c);v=a(N,"Trainer"),N.forEach(t),k=a(P," et d\u2019ajouter les changements n\xE9cessaires, mais parfois il est plus simple d\u2019\xE9crire la boucle d\u2019entra\xEEnement \xE0 partir de z\xE9ro. C\u2019est l\xE0 qu\u2019intervient \u{1F917} "),$=i(P,"EM",{});var M=u($);z=a(M,"Accelerate"),M.forEach(t),D=a(P,"."),P.forEach(t)},m(j,P){p(j,r,P),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D)},d(j){j&&t(r)}}}function Up(O){let r,_;return{c(){r=l("p"),_=n("Au vu de ces quelques exemples, il semble que le mod\xE8le ait appris une partie de la syntaxe des biblioth\xE8ques Python de science des donn\xE9es. Bien s\xFBr, nous devrions \xE9valuer le mod\xE8le de mani\xE8re plus approfondie avant de le d\xE9ployer dans le monde r\xE9el, mais il s\u2019agit tout de m\xEAme d\u2019un prototype impressionnant.")},l(c){r=i(c,"P",{});var v=u(r);_=a(v,"Au vu de ces quelques exemples, il semble que le mod\xE8le ait appris une partie de la syntaxe des biblioth\xE8ques Python de science des donn\xE9es. Bien s\xFBr, nous devrions \xE9valuer le mod\xE8le de mani\xE8re plus approfondie avant de le d\xE9ployer dans le monde r\xE9el, mais il s\u2019agit tout de m\xEAme d\u2019un prototype impressionnant."),v.forEach(t)},m(c,v){p(c,r,v),s(r,_)},d(c){c&&t(r)}}}function vp(O){let r,_,c,v,k,$,z,D,j,P,N,M,h,T,H,F,Y,R,ee,W,X,C,se,V,I,S,U,ae,he,J,ue,ve,ge,Q,ze,je,G,K,Ae,nt,at,Ne,ns,ot,me,rt,lt,bs,za,Pa,it,$s,zn,oe,Ca,ut,Ot,Da,St,Gt,Ta,Ft,Ht,Ma,It,Rt,Aa,Vt,Pn,qs,Ut,re,Na,te,be,Cn,Dn,Le,Bt,Wt,La,Xt,ks,Oa,Kt,Tn,Xe,Oe,Jt,js,Yt,Zt,Sa,Qt,le,Mn,Pe,Ga,pt,Se,en,sn,Fa,tn,Es,nn,an,Ha,on,ne,Ia,ys,Ra,Va,ws,Ua,Ba,ct,xs,An,Ke,zs,dt,mt,Wa,rn,Ce,ln,Ee,Nn,Ge,Xa,un,Ln,Ps,pn,fe,On,as,Ka,Sn,Fe,Gn,Cs,cn,He,Fn,Ds,os,Hn,Je,In,ft,Rn,rs,ls,is,us,Ye,$e,_t,dn,Vn,Ts,ht,Ms,Un,Ie,Ja,mn,Bn,As,fn,Z,ps,Ns,Ls,Ya,Os,Za,Wn,Ze,Xn,cs,_n,hn,Qa,vn,Kn,ie,Jn,Qe,Yn,Ss,vt,gt,eo,Gs,Fs,Zn,ye,so,gn,bn,to,$n,Qn,es,ds,qn,no,ms,bt,kn,Re,ea,ss,Hs,$t,Is,sa,De,Rs,qt,kt,ao,jt,Vs,ta,fs,pe;return v=new $r({}),W=new Ci({props:{id:"Hm8_PgVTFuc"}}),qs=new L({props:{code:`keytoken_ids = []
for keyword in [
    "plt",
    "pd",
    "sk",
    "fit",
    "predict",
    " plt",
    " pd",
    " sk",
    " fit",
    " predict",
    "testtest",
]:
    ids = tokenizer([keyword]).input_ids[0]
    if len(ids) == 1:
        keytoken_ids.append(ids[0])
    else:
        print(f"Keyword has not single token: {keyword}")`,highlighted:`keytoken_ids = []
<span class="hljs-keyword">for</span> keyword <span class="hljs-keyword">in</span> [
    <span class="hljs-string">&quot;plt&quot;</span>,
    <span class="hljs-string">&quot;pd&quot;</span>,
    <span class="hljs-string">&quot;sk&quot;</span>,
    <span class="hljs-string">&quot;fit&quot;</span>,
    <span class="hljs-string">&quot;predict&quot;</span>,
    <span class="hljs-string">&quot; plt&quot;</span>,
    <span class="hljs-string">&quot; pd&quot;</span>,
    <span class="hljs-string">&quot; sk&quot;</span>,
    <span class="hljs-string">&quot; fit&quot;</span>,
    <span class="hljs-string">&quot; predict&quot;</span>,
    <span class="hljs-string">&quot;testtest&quot;</span>,
]:
    ids = tokenizer([keyword]).input_ids[<span class="hljs-number">0</span>]
    <span class="hljs-keyword">if</span> <span class="hljs-built_in">len</span>(ids) == <span class="hljs-number">1</span>:
        keytoken_ids.append(ids[<span class="hljs-number">0</span>])
    <span class="hljs-keyword">else</span>:
        <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Keyword has not single token: <span class="hljs-subst">{keyword}</span>&quot;</span>)`}}),re=new L({props:{code:"'Keyword has not single token: testtest'",highlighted:'<span class="hljs-string">&#x27;Keyword has not single token: testtest&#x27;</span>'}}),le=new L({props:{code:`from torch.nn import CrossEntropyLoss
import torch


def keytoken_weighted_loss(inputs, logits, keytoken_ids, alpha=1.0):
    # D\xE9calage pour que tokens < n pr\xE9disent n
    shift_labels = inputs[..., 1:].contiguous()
    shift_logits = logits[..., :-1, :].contiguous()
    # Calcul de la perte par token
    loss_fct = CrossEntropyLoss(reduce=False)
    loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
    # Redimensionnement et perte moyenne par \xE9chantillon
    loss_per_sample = loss.view(shift_logits.size(0), shift_logits.size(1)).mean(axis=1)
    # Calculer et \xE9chelonner la pond\xE9ration
    weights = torch.stack([(inputs == kt).float() for kt in keytoken_ids]).sum(
        axis=[0, 2]
    )
    weights = alpha * (1.0 + weights)
    # Calculer la moyenne pond\xE9r\xE9e
    weighted_loss = (loss_per_sample * weights).mean()
    return weighted_loss`,highlighted:`<span class="hljs-keyword">from</span> torch.nn <span class="hljs-keyword">import</span> CrossEntropyLoss
<span class="hljs-keyword">import</span> torch


<span class="hljs-keyword">def</span> <span class="hljs-title function_">keytoken_weighted_loss</span>(<span class="hljs-params">inputs, logits, keytoken_ids, alpha=<span class="hljs-number">1.0</span></span>):
    <span class="hljs-comment"># D\xE9calage pour que tokens &lt; n pr\xE9disent n</span>
    shift_labels = inputs[..., <span class="hljs-number">1</span>:].contiguous()
    shift_logits = logits[..., :-<span class="hljs-number">1</span>, :].contiguous()
    <span class="hljs-comment"># Calcul de la perte par token</span>
    loss_fct = CrossEntropyLoss(reduce=<span class="hljs-literal">False</span>)
    loss = loss_fct(shift_logits.view(-<span class="hljs-number">1</span>, shift_logits.size(-<span class="hljs-number">1</span>)), shift_labels.view(-<span class="hljs-number">1</span>))
    <span class="hljs-comment"># Redimensionnement et perte moyenne par \xE9chantillon</span>
    loss_per_sample = loss.view(shift_logits.size(<span class="hljs-number">0</span>), shift_logits.size(<span class="hljs-number">1</span>)).mean(axis=<span class="hljs-number">1</span>)
    <span class="hljs-comment"># Calculer et \xE9chelonner la pond\xE9ration</span>
    weights = torch.stack([(inputs == kt).<span class="hljs-built_in">float</span>() <span class="hljs-keyword">for</span> kt <span class="hljs-keyword">in</span> keytoken_ids]).<span class="hljs-built_in">sum</span>(
        axis=[<span class="hljs-number">0</span>, <span class="hljs-number">2</span>]
    )
    weights = alpha * (<span class="hljs-number">1.0</span> + weights)
    <span class="hljs-comment"># Calculer la moyenne pond\xE9r\xE9e</span>
    weighted_loss = (loss_per_sample * weights).mean()
    <span class="hljs-keyword">return</span> weighted_loss`}}),xs=new L({props:{code:`from torch.utils.data.dataloader import DataLoader

tokenized_dataset.set_format("torch")
train_dataloader = DataLoader(tokenized_dataset["train"], batch_size=32, shuffle=True)
eval_dataloader = DataLoader(tokenized_dataset["valid"], batch_size=32)`,highlighted:`<span class="hljs-keyword">from</span> torch.utils.data.dataloader <span class="hljs-keyword">import</span> DataLoader

tokenized_dataset.set_format(<span class="hljs-string">&quot;torch&quot;</span>)
train_dataloader = DataLoader(tokenized_dataset[<span class="hljs-string">&quot;train&quot;</span>], batch_size=<span class="hljs-number">32</span>, shuffle=<span class="hljs-literal">True</span>)
eval_dataloader = DataLoader(tokenized_dataset[<span class="hljs-string">&quot;valid&quot;</span>], batch_size=<span class="hljs-number">32</span>)`}}),Ce=new L({props:{code:`weight_decay = 0.1


def get_grouped_params(model, no_decay=["bias", "LayerNorm.weight"]):
    params_with_wd, params_without_wd = [], []
    for n, p in model.named_parameters():
        if any(nd in n for nd in no_decay):
            params_without_wd.append(p)
        else:
            params_with_wd.append(p)
    return [
        {"params": params_with_wd, "weight_decay": weight_decay},
        {"params": params_without_wd, "weight_decay": 0.0},
    ]`,highlighted:`weight_decay = <span class="hljs-number">0.1</span>


<span class="hljs-keyword">def</span> <span class="hljs-title function_">get_grouped_params</span>(<span class="hljs-params">model, no_decay=[<span class="hljs-string">&quot;bias&quot;</span>, <span class="hljs-string">&quot;LayerNorm.weight&quot;</span>]</span>):
    params_with_wd, params_without_wd = [], []
    <span class="hljs-keyword">for</span> n, p <span class="hljs-keyword">in</span> model.named_parameters():
        <span class="hljs-keyword">if</span> <span class="hljs-built_in">any</span>(nd <span class="hljs-keyword">in</span> n <span class="hljs-keyword">for</span> nd <span class="hljs-keyword">in</span> no_decay):
            params_without_wd.append(p)
        <span class="hljs-keyword">else</span>:
            params_with_wd.append(p)
    <span class="hljs-keyword">return</span> [
        {<span class="hljs-string">&quot;params&quot;</span>: params_with_wd, <span class="hljs-string">&quot;weight_decay&quot;</span>: weight_decay},
        {<span class="hljs-string">&quot;params&quot;</span>: params_without_wd, <span class="hljs-string">&quot;weight_decay&quot;</span>: <span class="hljs-number">0.0</span>},
    ]`}}),Ps=new L({props:{code:`def evaluate():
    model.eval()
    losses = []
    for step, batch in enumerate(eval_dataloader):
        with torch.no_grad():
            outputs = model(batch["input_ids"], labels=batch["input_ids"])

        losses.append(accelerator.gather(outputs.loss))
    loss = torch.mean(torch.cat(losses))
    try:
        perplexity = torch.exp(loss)
    except OverflowError:
        perplexity = float("inf")
    return loss.item(), perplexity.item()`,highlighted:`<span class="hljs-keyword">def</span> <span class="hljs-title function_">evaluate</span>():
    model.<span class="hljs-built_in">eval</span>()
    losses = []
    <span class="hljs-keyword">for</span> step, batch <span class="hljs-keyword">in</span> <span class="hljs-built_in">enumerate</span>(eval_dataloader):
        <span class="hljs-keyword">with</span> torch.no_grad():
            outputs = model(batch[<span class="hljs-string">&quot;input_ids&quot;</span>], labels=batch[<span class="hljs-string">&quot;input_ids&quot;</span>])

        losses.append(accelerator.gather(outputs.loss))
    loss = torch.mean(torch.cat(losses))
    <span class="hljs-keyword">try</span>:
        perplexity = torch.exp(loss)
    <span class="hljs-keyword">except</span> OverflowError:
        perplexity = <span class="hljs-built_in">float</span>(<span class="hljs-string">&quot;inf&quot;</span>)
    <span class="hljs-keyword">return</span> loss.item(), perplexity.item()`}}),He=new L({props:{code:"model = GPT2LMHeadModel(config)",highlighted:"model = GPT2LMHeadModel(config)"}}),Je=new L({props:{code:`from torch.optim import AdamW

optimizer = AdamW(get_grouped_params(model), lr=5e-4)`,highlighted:`<span class="hljs-keyword">from</span> torch.optim <span class="hljs-keyword">import</span> AdamW

optimizer = AdamW(get_grouped_params(model), lr=<span class="hljs-number">5e-4</span>)`}}),ls=new L({props:{code:`from accelerate import Accelerator

accelerator = Accelerator(fp16=True)

model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)`,highlighted:`<span class="hljs-keyword">from</span> accelerate <span class="hljs-keyword">import</span> Accelerator

accelerator = Accelerator(fp16=<span class="hljs-literal">True</span>)

model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
    model, optimizer, train_dataloader, eval_dataloader
)`}}),us=new xa({props:{$$slots:{default:[Bp]},$$scope:{ctx:O}}}),As=new L({props:{code:`num_train_epochs = 1
num_update_steps_per_epoch = len(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch

lr_scheduler = get_scheduler(
    name="linear",
    optimizer=optimizer,
    num_warmup_steps=1_000,
    num_training_steps=num_training_steps,
)`,highlighted:`num_train_epochs = <span class="hljs-number">1</span>
num_update_steps_per_epoch = <span class="hljs-built_in">len</span>(train_dataloader)
num_training_steps = num_train_epochs * num_update_steps_per_epoch

lr_scheduler = get_scheduler(
    name=<span class="hljs-string">&quot;linear&quot;</span>,
    optimizer=optimizer,
    num_warmup_steps=<span class="hljs-number">1_000</span>,
    num_training_steps=num_training_steps,
)`}}),Qe=new L({props:{code:`from huggingface_hub import Repository, get_full_repo_name

model_name = "codeparrot-ds-accelerate"
repo_name = get_full_repo_name(model_name)
repo_name`,highlighted:`<span class="hljs-keyword">from</span> huggingface_hub <span class="hljs-keyword">import</span> Repository, get_full_repo_name

model_name = <span class="hljs-string">&quot;codeparrot-ds-accelerate&quot;</span>
repo_name = get_full_repo_name(model_name)
repo_name`}}),Ss=new L({props:{code:"'sgugger/codeparrot-ds-accelerate'",highlighted:'<span class="hljs-string">&#x27;sgugger/codeparrot-ds-accelerate&#x27;</span>'}}),Fs=new L({props:{code:`output_dir = "codeparrot-ds-accelerate"
repo = Repository(output_dir, clone_from=repo_name)`,highlighted:`output_dir = <span class="hljs-string">&quot;codeparrot-ds-accelerate&quot;</span>
repo = Repository(output_dir, clone_from=repo_name)`}}),bt=new L({props:{code:"evaluate()",highlighted:"evaluate()"}}),Re=new L({props:{code:"(10.934126853942871, 56057.14453125)",highlighted:'(<span class="hljs-number">10.934126853942871</span>, <span class="hljs-number">56057.14453125</span>)'}}),Rs=new L({props:{code:`from tqdm.notebook import tqdm

gradient_accumulation_steps = 8
eval_steps = 5_000

model.train()
completed_steps = 0
for epoch in range(num_train_epochs):
    for step, batch in tqdm(
        enumerate(train_dataloader, start=1), total=len(train_dataloader)
    ):
        logits = model(batch["input_ids"]).logits
        loss = keytoken_weighted_loss(batch["input_ids"], logits, keytoken_ids)
        if step % 100 == 0:
            accelerator.print(
                {
                    "lr": get_lr(),
                    "samples": step * samples_per_step,
                    "steps": completed_steps,
                    "loss/train": loss.item() * gradient_accumulation_steps,
                }
            )
        loss = loss / gradient_accumulation_steps
        accelerator.backward(loss)
        if step % gradient_accumulation_steps == 0:
            accelerator.clip_grad_norm_(model.parameters(), 1.0)
            optimizer.step()
            lr_scheduler.step()
            optimizer.zero_grad()
            completed_steps += 1
        if (step % (eval_steps * gradient_accumulation_steps)) == 0:
            eval_loss, perplexity = evaluate()
            accelerator.print({"loss/eval": eval_loss, "perplexity": perplexity})
            model.train()
            accelerator.wait_for_everyone()
            unwrapped_model = accelerator.unwrap_model(model)
            unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
            if accelerator.is_main_process:
                tokenizer.save_pretrained(output_dir)
                repo.push_to_hub(
                    commit_message=f"Training in progress step {step}", blocking=False
                )`,highlighted:`<span class="hljs-keyword">from</span> tqdm.notebook <span class="hljs-keyword">import</span> tqdm

gradient_accumulation_steps = <span class="hljs-number">8</span>
eval_steps = <span class="hljs-number">5_000</span>

model.train()
completed_steps = <span class="hljs-number">0</span>
<span class="hljs-keyword">for</span> epoch <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(num_train_epochs):
    <span class="hljs-keyword">for</span> step, batch <span class="hljs-keyword">in</span> tqdm(
        <span class="hljs-built_in">enumerate</span>(train_dataloader, start=<span class="hljs-number">1</span>), total=<span class="hljs-built_in">len</span>(train_dataloader)
    ):
        logits = model(batch[<span class="hljs-string">&quot;input_ids&quot;</span>]).logits
        loss = keytoken_weighted_loss(batch[<span class="hljs-string">&quot;input_ids&quot;</span>], logits, keytoken_ids)
        <span class="hljs-keyword">if</span> step % <span class="hljs-number">100</span> == <span class="hljs-number">0</span>:
            accelerator.<span class="hljs-built_in">print</span>(
                {
                    <span class="hljs-string">&quot;lr&quot;</span>: get_lr(),
                    <span class="hljs-string">&quot;samples&quot;</span>: step * samples_per_step,
                    <span class="hljs-string">&quot;steps&quot;</span>: completed_steps,
                    <span class="hljs-string">&quot;loss/train&quot;</span>: loss.item() * gradient_accumulation_steps,
                }
            )
        loss = loss / gradient_accumulation_steps
        accelerator.backward(loss)
        <span class="hljs-keyword">if</span> step % gradient_accumulation_steps == <span class="hljs-number">0</span>:
            accelerator.clip_grad_norm_(model.parameters(), <span class="hljs-number">1.0</span>)
            optimizer.step()
            lr_scheduler.step()
            optimizer.zero_grad()
            completed_steps += <span class="hljs-number">1</span>
        <span class="hljs-keyword">if</span> (step % (eval_steps * gradient_accumulation_steps)) == <span class="hljs-number">0</span>:
            eval_loss, perplexity = evaluate()
            accelerator.<span class="hljs-built_in">print</span>({<span class="hljs-string">&quot;loss/eval&quot;</span>: eval_loss, <span class="hljs-string">&quot;perplexity&quot;</span>: perplexity})
            model.train()
            accelerator.wait_for_everyone()
            unwrapped_model = accelerator.unwrap_model(model)
            unwrapped_model.save_pretrained(output_dir, save_function=accelerator.save)
            <span class="hljs-keyword">if</span> accelerator.is_main_process:
                tokenizer.save_pretrained(output_dir)
                repo.push_to_hub(
                    commit_message=<span class="hljs-string">f&quot;Training in progress step <span class="hljs-subst">{step}</span>&quot;</span>, blocking=<span class="hljs-literal">False</span>
                )`}}),Vs=new xa({props:{$$slots:{default:[Wp]},$$scope:{ctx:O}}}),fs=new xa({props:{$$slots:{default:[Xp]},$$scope:{ctx:O}}}),{c(){r=l("h2"),_=l("a"),c=l("span"),E(v.$$.fragment),k=m(),$=l("span"),z=n("Entra\xEEner avec \u{1F917} "),D=l("i"),j=n("Accelerate"),P=m(),N=l("p"),M=n("Nous avons vu comment entra\xEEner un mod\xE8le avec le "),h=l("code"),T=n("Trainer"),H=n(", qui permet une certaine personnalisation. Cependant, parfois nous voulons un contr\xF4le total sur la boucle d\u2019entra\xEEnement ou nous souhaitons faire quelques changements exotiques. Dans ce cas, \u{1F917} "),F=l("em"),Y=n("Accelerate"),R=n(" est un excellent choix, et dans cette section, nous allons suivre les \xE9tapes pour l\u2019utiliser pour entra\xEEner notre mod\xE8le. Pour rendre les choses plus int\xE9ressantes, nous allons \xE9galement ajouter une touche \xE0 la boucle d\u2019entra\xEEnement."),ee=m(),E(W.$$.fragment),X=m(),C=l("p"),se=n("Puisque nous sommes principalement int\xE9ress\xE9s par l\u2019autocompl\xE9tion pour les biblioth\xE8ques de science des donn\xE9es, il est logique de donner plus de poids aux \xE9chantillons d\u2019entra\xEEnement qui utilisent davantage ces biblioth\xE8ques. Nous pouvons facilement identifier ces exemples gr\xE2ce \xE0 l\u2019utilisation de mots-cl\xE9s tels que "),V=l("code"),I=n("plt"),S=n(", "),U=l("code"),ae=n("pd"),he=n(", "),J=l("code"),ue=n("sk"),ve=n(", "),ge=l("code"),Q=n("fit"),ze=n(", et "),je=l("code"),G=n("predict"),K=n(", qui sont les noms d\u2019importation les plus fr\xE9quents pour "),Ae=l("code"),nt=n("matplotlib.pyplot"),at=n(", "),Ne=l("code"),ns=n("pandas"),ot=n(", et "),me=l("code"),rt=n("sklearn"),lt=n(" ainsi que les fonctions "),bs=l("code"),za=n("fit"),Pa=n(" et "),it=l("code"),$s=n("predict"),zn=n(" de cette derni\xE8re. Si chacun d\u2019entre eux est repr\xE9sent\xE9 par un seul "),oe=l("em"),Ca=n("token"),ut=n(", nous pouvons facilement v\xE9rifier s\u2019ils apparaissent dans la s\xE9quence d\u2019entr\xE9e. Les "),Ot=l("em"),Da=n("tokens"),St=n(" peuvent avoir un pr\xE9fixe d\u2019espacement, donc nous v\xE9rifierons aussi ces versions dans le vocabulaire du "),Gt=l("em"),Ta=n("tokenizer"),Ft=n(". Pour v\xE9rifier que cela fonctionne, nous ajouterons un "),Ht=l("em"),Ma=n("token"),It=n(" de test qui devrait \xEAtre divis\xE9 en plusieurs "),Rt=l("em"),Aa=n("tokens"),Vt=n(" :"),Pn=m(),E(qs.$$.fragment),Ut=m(),E(re.$$.fragment),Na=m(),te=l("p"),be=n("Super, \xE7a a l\u2019air de bien fonctionner ! Nous pouvons maintenant \xE9crire une fonction de perte personnalis\xE9e qui prend la s\xE9quence d\u2019entr\xE9e, les logits et les "),Cn=l("em"),Dn=n("tokens"),Le=n(" cl\xE9s que nous venons de s\xE9lectionner comme entr\xE9es. Tout d\u2019abord, nous devons aligner les logits et les entr\xE9es : la s\xE9quence d\u2019entr\xE9e d\xE9cal\xE9e d\u2019une unit\xE9 vers la droite forme les \xE9tiquettes, puisque le "),Bt=l("em"),Wt=n("token"),La=n(" suivant est l\u2019\xE9tiquette du "),Xt=l("em"),ks=n("token"),Oa=n(" actuel. Nous pouvons y parvenir en commen\xE7ant les \xE9tiquettes \xE0 partir du deuxi\xE8me "),Kt=l("em"),Tn=n("token"),Xe=n(" de la s\xE9quence d\u2019entr\xE9e, puisque le mod\xE8le ne fait pas de pr\xE9diction pour le premier "),Oe=l("em"),Jt=n("token"),js=n(" de toute fa\xE7on. Ensuite, nous coupons le dernier logit, car nous n\u2019avons pas d\u2019\xE9tiquette pour le "),Yt=l("em"),Zt=n("token"),Sa=n(" qui suit la s\xE9quence d\u2019entr\xE9e compl\xE8te. Avec cela, nous pouvons calculer la perte par \xE9chantillon et compter les occurrences de tous les mots-cl\xE9s dans chaque \xE9chantillon. Enfin, nous calculons la moyenne pond\xE9r\xE9e sur tous les \xE9chantillons en utilisant les occurrences comme poids. Comme nous ne voulons pas rejeter tous les \xE9chantillons qui ne contiennent pas de mots-cl\xE9s, nous ajoutons 1 aux poids :"),Qt=m(),E(le.$$.fragment),Mn=m(),Pe=l("p"),Ga=n("Avant de commencer \xE0 entra\xEEner avec cette nouvelle fonction de perte g\xE9niale, nous devons pr\xE9parer quelques \xE9l\xE9ments :"),pt=m(),Se=l("ul"),en=l("li"),sn=n("Nous avons besoin de chargeurs de donn\xE9es pour charger les donn\xE9es par batch."),Fa=m(),tn=l("li"),Es=n("Nous devons d\xE9finir les param\xE8tres de d\xE9croissance des poids."),nn=m(),an=l("li"),Ha=n("De temps en temps, nous voulons \xE9valuer, il est donc logique d\u2019envelopper le code d\u2019\xE9valuation dans une fonction."),on=m(),ne=l("p"),Ia=n("Commen\xE7ons par les chargeurs de donn\xE9es. Nous avons seulement besoin de d\xE9finir le format du jeu de donn\xE9es \xE0 "),ys=l("code"),Ra=n('"torch"'),Va=n(" et ensuite nous pouvons le passer \xE0 un PyTorch "),ws=l("code"),Ua=n("DataLoader"),Ba=n(" avec la taille de batch appropri\xE9e :"),ct=m(),E(xs.$$.fragment),An=m(),Ke=l("p"),zs=n("Ensuite, nous regroupons les param\xE8tres de fa\xE7on \xE0 ce que l\u2019optimiseur sache lesquels b\xE9n\xE9ficieront d\u2019une d\xE9croissance de poids suppl\xE9mentaire. Habituellement, tous les termes de biais et les poids de la "),dt=l("em"),mt=n("LayerNorm"),Wa=n(" en sont exempt\xE9s. Voici comment nous pouvons le faire :"),rn=m(),E(Ce.$$.fragment),ln=m(),Ee=l("p"),Nn=n("Puisque nous voulons \xE9valuer le mod\xE8le r\xE9guli\xE8rement sur l\u2019ensemble de validation pendant l\u2019entra\xEEnement, \xE9crivons une fonction pour cela aussi. Elle passe simplement par le "),Ge=l("em"),Xa=n("dataloader"),un=n(" d\u2019\xE9valuation et rassemble toutes les pertes \xE0 travers les processus :"),Ln=m(),E(Ps.$$.fragment),pn=m(),fe=l("p"),On=n("Avec la fonction "),as=l("code"),Ka=n("evaluate()"),Sn=n(" nous pouvons rapporter la perte et la "),Fe=l("a"),Gn=n("perplexit\xE9"),Cs=n(" \xE0 intervalles r\xE9guliers. Ensuite, nous red\xE9finissons notre mod\xE8le pour nous assurer que nous entra\xEEnons \xE0 nouveau \xE0 partir de z\xE9ro :"),cn=m(),E(He.$$.fragment),Fn=m(),Ds=l("p"),os=n("Nous pouvons ensuite d\xE9finir notre optimiseur, en utilisant la fonction pr\xE9c\xE9dente pour diviser les param\xE8tres de d\xE9croissance des poids :"),Hn=m(),E(Je.$$.fragment),In=m(),ft=l("p"),Rn=n("Pr\xE9parons maintenant le mod\xE8le, l\u2019optimiseur et les chargeurs de donn\xE9es pour pouvoir commencer l\u2019entra\xEEnement :"),rs=m(),E(ls.$$.fragment),is=m(),E(us.$$.fragment),Ye=m(),$e=l("p"),_t=n("Maintenant que nous avons envoy\xE9 notre "),dn=l("code"),Vn=n("train_dataloader"),Ts=n(" \xE0 "),ht=l("code"),Ms=n("accelerator.prepare()"),Un=n(", nous pouvons utiliser sa longueur pour calculer le nombre d\u2019\xE9tapes d\u2019entra\xEEnement. Rappelez-vous que nous devons toujours faire cela apr\xE8s avoir pr\xE9par\xE9 le "),Ie=l("em"),Ja=n("dataloader"),mn=n(" car cette m\xE9thode modifiera sa longueur. Nous utilisons un programme lin\xE9aire classique du taux d\u2019apprentissage \xE0 0 :"),Bn=m(),E(As.$$.fragment),fn=m(),Z=l("p"),ps=n("Enfin, pour pousser notre mod\xE8le vers le "),Ns=l("em"),Ls=n("Hub"),Ya=n(", nous aurons besoin de cr\xE9er un objet "),Os=l("code"),Za=n("Repository"),Wn=n(" dans un dossier de travail. Tout d\u2019abord, connectez-vous au "),Ze=l("em"),Xn=n("Hub"),cs=n(", si vous n\u2019\xEAtes pas d\xE9j\xE0 connect\xE9. Nous d\xE9terminerons le nom du d\xE9p\xF4t \xE0 partir de l\u2019identifiant du mod\xE8le que nous voulons donner \xE0 notre mod\xE8le (n\u2019h\xE9sitez pas \xE0 remplacer le "),_n=l("code"),hn=n("repo_name"),Qa=n(" par votre propre choix. Il doit juste contenir votre nom d\u2019utilisateur, ce que fait la fonction "),vn=l("code"),Kn=n("get_full_repo_name()"),ie=n(") :"),Jn=m(),E(Qe.$$.fragment),Yn=m(),E(Ss.$$.fragment),vt=m(),gt=l("p"),eo=n("Ensuite, nous pouvons cloner ce d\xE9p\xF4t dans un dossier local. S\u2019il existe d\xE9j\xE0, ce dossier local doit \xEAtre un clone existant du d\xE9p\xF4t avec lequel nous travaillons :"),Gs=m(),E(Fs.$$.fragment),Zn=m(),ye=l("p"),so=n("Nous pouvons maintenant t\xE9l\xE9charger tout ce que nous sauvegardons dans "),gn=l("code"),bn=n("output_dir"),to=n(" en appelant la m\xE9thode "),$n=l("code"),Qn=n("repo.push_to_hub()"),es=n(". Cela nous aidera \xE0 t\xE9l\xE9charger les mod\xE8les interm\xE9diaires \xE0 la fin de chaque \xE9poque."),ds=m(),qn=l("p"),no=n("Avant de nous entra\xEEner, ex\xE9cutons un test rapide pour voir si la fonction d\u2019\xE9valuation fonctionne correctement :"),ms=m(),E(bt.$$.fragment),kn=m(),E(Re.$$.fragment),ea=m(),ss=l("p"),Hs=n("Ce sont des valeurs tr\xE8s \xE9lev\xE9es pour la perte et la perplexit\xE9, mais ce n\u2019est pas surprenant puisque nous n\u2019avons pas encore entra\xEEn\xE9 le mod\xE8le. Avec cela, nous avons tout pr\xE9par\xE9 pour \xE9crire la partie principale du script d\u2019entra\xEEnement : la boucle d\u2019entra\xEEnement. Dans celle-ci, nous it\xE9rons sur le chargeur de donn\xE9es et transmettons les batchs au mod\xE8le. Avec les logits, nous pouvons alors \xE9valuer notre fonction de perte personnalis\xE9e. Nous mettons \xE0 l\u2019\xE9chelle la perte par le nombre d\u2019\xE9tapes d\u2019accumulation du gradient afin de ne pas cr\xE9er de plus grandes pertes en agr\xE9geant plus d\u2019\xE9tapes. Avant de proc\xE9der \xE0 l\u2019optimisation, nous d\xE9coupons \xE9galement les gradients pour une meilleure convergence. Enfin, tous les quelques pas, nous \xE9valuons le mod\xE8le sur l\u2019ensemble d\u2019\xE9valuation avec notre nouvelle fonction "),$t=l("code"),Is=n("evaluate()"),sa=n(" :"),De=m(),E(Rs.$$.fragment),qt=m(),kt=l("p"),ao=n("Et voil\xE0, vous disposez maintenant de votre propre boucle d\u2019entra\xEEnement personnalis\xE9e pour les mod\xE8les de langage causal tels que le GPT-2. Vous pouvez encore l\u2019adapter \xE0 vos besoins."),jt=m(),E(Vs.$$.fragment),ta=m(),E(fs.$$.fragment),this.h()},l(o){r=i(o,"H2",{class:!0});var q=u(r);_=i(q,"A",{id:!0,class:!0,href:!0});var Do=u(_);c=i(Do,"SPAN",{});var To=u(c);y(v.$$.fragment,To),To.forEach(t),Do.forEach(t),k=f(q),$=i(q,"SPAN",{});var jn=u($);z=a(jn,"Entra\xEEner avec \u{1F917} "),D=i(jn,"I",{});var Mo=u(D);j=a(Mo,"Accelerate"),Mo.forEach(t),jn.forEach(t),q.forEach(t),P=f(o),N=i(o,"P",{});var Et=u(N);M=a(Et,"Nous avons vu comment entra\xEEner un mod\xE8le avec le "),h=i(Et,"CODE",{});var En=u(h);T=a(En,"Trainer"),En.forEach(t),H=a(Et,", qui permet une certaine personnalisation. Cependant, parfois nous voulons un contr\xF4le total sur la boucle d\u2019entra\xEEnement ou nous souhaitons faire quelques changements exotiques. Dans ce cas, \u{1F917} "),F=i(Et,"EM",{});var Ao=u(F);Y=a(Ao,"Accelerate"),Ao.forEach(t),R=a(Et," est un excellent choix, et dans cette section, nous allons suivre les \xE9tapes pour l\u2019utiliser pour entra\xEEner notre mod\xE8le. Pour rendre les choses plus int\xE9ressantes, nous allons \xE9galement ajouter une touche \xE0 la boucle d\u2019entra\xEEnement."),Et.forEach(t),ee=f(o),y(W.$$.fragment,o),X=f(o),C=i(o,"P",{});var B=u(C);se=a(B,"Puisque nous sommes principalement int\xE9ress\xE9s par l\u2019autocompl\xE9tion pour les biblioth\xE8ques de science des donn\xE9es, il est logique de donner plus de poids aux \xE9chantillons d\u2019entra\xEEnement qui utilisent davantage ces biblioth\xE8ques. Nous pouvons facilement identifier ces exemples gr\xE2ce \xE0 l\u2019utilisation de mots-cl\xE9s tels que "),V=i(B,"CODE",{});var na=u(V);I=a(na,"plt"),na.forEach(t),S=a(B,", "),U=i(B,"CODE",{});var No=u(U);ae=a(No,"pd"),No.forEach(t),he=a(B,", "),J=i(B,"CODE",{});var Lo=u(J);ue=a(Lo,"sk"),Lo.forEach(t),ve=a(B,", "),ge=i(B,"CODE",{});var oo=u(ge);Q=a(oo,"fit"),oo.forEach(t),ze=a(B,", et "),je=i(B,"CODE",{});var yt=u(je);G=a(yt,"predict"),yt.forEach(t),K=a(B,", qui sont les noms d\u2019importation les plus fr\xE9quents pour "),Ae=i(B,"CODE",{});var ro=u(Ae);nt=a(ro,"matplotlib.pyplot"),ro.forEach(t),at=a(B,", "),Ne=i(B,"CODE",{});var wt=u(Ne);ns=a(wt,"pandas"),wt.forEach(t),ot=a(B,", et "),me=i(B,"CODE",{});var lo=u(me);rt=a(lo,"sklearn"),lo.forEach(t),lt=a(B," ainsi que les fonctions "),bs=i(B,"CODE",{});var qe=u(bs);za=a(qe,"fit"),qe.forEach(t),Pa=a(B," et "),it=i(B,"CODE",{});var Oo=u(it);$s=a(Oo,"predict"),Oo.forEach(t),zn=a(B," de cette derni\xE8re. Si chacun d\u2019entre eux est repr\xE9sent\xE9 par un seul "),oe=i(B,"EM",{});var aa=u(oe);Ca=a(aa,"token"),aa.forEach(t),ut=a(B,", nous pouvons facilement v\xE9rifier s\u2019ils apparaissent dans la s\xE9quence d\u2019entr\xE9e. Les "),Ot=i(B,"EM",{});var So=u(Ot);Da=a(So,"tokens"),So.forEach(t),St=a(B," peuvent avoir un pr\xE9fixe d\u2019espacement, donc nous v\xE9rifierons aussi ces versions dans le vocabulaire du "),Gt=i(B,"EM",{});var Go=u(Gt);Ta=a(Go,"tokenizer"),Go.forEach(t),Ft=a(B,". Pour v\xE9rifier que cela fonctionne, nous ajouterons un "),Ht=i(B,"EM",{});var oa=u(Ht);Ma=a(oa,"token"),oa.forEach(t),It=a(B," de test qui devrait \xEAtre divis\xE9 en plusieurs "),Rt=i(B,"EM",{});var Fo=u(Rt);Aa=a(Fo,"tokens"),Fo.forEach(t),Vt=a(B," :"),B.forEach(t),Pn=f(o),y(qs.$$.fragment,o),Ut=f(o),y(re.$$.fragment,o),Na=f(o),te=i(o,"P",{});var _e=u(te);be=a(_e,"Super, \xE7a a l\u2019air de bien fonctionner ! Nous pouvons maintenant \xE9crire une fonction de perte personnalis\xE9e qui prend la s\xE9quence d\u2019entr\xE9e, les logits et les "),Cn=i(_e,"EM",{});var ra=u(Cn);Dn=a(ra,"tokens"),ra.forEach(t),Le=a(_e," cl\xE9s que nous venons de s\xE9lectionner comme entr\xE9es. Tout d\u2019abord, nous devons aligner les logits et les entr\xE9es : la s\xE9quence d\u2019entr\xE9e d\xE9cal\xE9e d\u2019une unit\xE9 vers la droite forme les \xE9tiquettes, puisque le "),Bt=i(_e,"EM",{});var Ho=u(Bt);Wt=a(Ho,"token"),Ho.forEach(t),La=a(_e," suivant est l\u2019\xE9tiquette du "),Xt=i(_e,"EM",{});var Io=u(Xt);ks=a(Io,"token"),Io.forEach(t),Oa=a(_e," actuel. Nous pouvons y parvenir en commen\xE7ant les \xE9tiquettes \xE0 partir du deuxi\xE8me "),Kt=i(_e,"EM",{});var la=u(Kt);Tn=a(la,"token"),la.forEach(t),Xe=a(_e," de la s\xE9quence d\u2019entr\xE9e, puisque le mod\xE8le ne fait pas de pr\xE9diction pour le premier "),Oe=i(_e,"EM",{});var Ro=u(Oe);Jt=a(Ro,"token"),Ro.forEach(t),js=a(_e," de toute fa\xE7on. Ensuite, nous coupons le dernier logit, car nous n\u2019avons pas d\u2019\xE9tiquette pour le "),Yt=i(_e,"EM",{});var Vo=u(Yt);Zt=a(Vo,"token"),Vo.forEach(t),Sa=a(_e," qui suit la s\xE9quence d\u2019entr\xE9e compl\xE8te. Avec cela, nous pouvons calculer la perte par \xE9chantillon et compter les occurrences de tous les mots-cl\xE9s dans chaque \xE9chantillon. Enfin, nous calculons la moyenne pond\xE9r\xE9e sur tous les \xE9chantillons en utilisant les occurrences comme poids. Comme nous ne voulons pas rejeter tous les \xE9chantillons qui ne contiennent pas de mots-cl\xE9s, nous ajoutons 1 aux poids :"),_e.forEach(t),Qt=f(o),y(le.$$.fragment,o),Mn=f(o),Pe=i(o,"P",{});var io=u(Pe);Ga=a(io,"Avant de commencer \xE0 entra\xEEner avec cette nouvelle fonction de perte g\xE9niale, nous devons pr\xE9parer quelques \xE9l\xE9ments :"),io.forEach(t),pt=f(o),Se=i(o,"UL",{});var ts=u(Se);en=i(ts,"LI",{});var Uo=u(en);sn=a(Uo,"Nous avons besoin de chargeurs de donn\xE9es pour charger les donn\xE9es par batch."),Uo.forEach(t),Fa=f(ts),tn=i(ts,"LI",{});var uo=u(tn);Es=a(uo,"Nous devons d\xE9finir les param\xE8tres de d\xE9croissance des poids."),uo.forEach(t),nn=f(ts),an=i(ts,"LI",{});var Us=u(an);Ha=a(Us,"De temps en temps, nous voulons \xE9valuer, il est donc logique d\u2019envelopper le code d\u2019\xE9valuation dans une fonction."),Us.forEach(t),ts.forEach(t),on=f(o),ne=i(o,"P",{});var Bs=u(ne);Ia=a(Bs,"Commen\xE7ons par les chargeurs de donn\xE9es. Nous avons seulement besoin de d\xE9finir le format du jeu de donn\xE9es \xE0 "),ys=i(Bs,"CODE",{});var _s=u(ys);Ra=a(_s,'"torch"'),_s.forEach(t),Va=a(Bs," et ensuite nous pouvons le passer \xE0 un PyTorch "),ws=i(Bs,"CODE",{});var Ws=u(ws);Ua=a(Ws,"DataLoader"),Ws.forEach(t),Ba=a(Bs," avec la taille de batch appropri\xE9e :"),Bs.forEach(t),ct=f(o),y(xs.$$.fragment,o),An=f(o),Ke=i(o,"P",{});var xt=u(Ke);zs=a(xt,"Ensuite, nous regroupons les param\xE8tres de fa\xE7on \xE0 ce que l\u2019optimiseur sache lesquels b\xE9n\xE9ficieront d\u2019une d\xE9croissance de poids suppl\xE9mentaire. Habituellement, tous les termes de biais et les poids de la "),dt=i(xt,"EM",{});var zt=u(dt);mt=a(zt,"LayerNorm"),zt.forEach(t),Wa=a(xt," en sont exempt\xE9s. Voici comment nous pouvons le faire :"),xt.forEach(t),rn=f(o),y(Ce.$$.fragment,o),ln=f(o),Ee=i(o,"P",{});var ia=u(Ee);Nn=a(ia,"Puisque nous voulons \xE9valuer le mod\xE8le r\xE9guli\xE8rement sur l\u2019ensemble de validation pendant l\u2019entra\xEEnement, \xE9crivons une fonction pour cela aussi. Elle passe simplement par le "),Ge=i(ia,"EM",{});var ua=u(Ge);Xa=a(ua,"dataloader"),ua.forEach(t),un=a(ia," d\u2019\xE9valuation et rassemble toutes les pertes \xE0 travers les processus :"),ia.forEach(t),Ln=f(o),y(Ps.$$.fragment,o),pn=f(o),fe=i(o,"P",{});var Pt=u(fe);On=a(Pt,"Avec la fonction "),as=i(Pt,"CODE",{});var po=u(as);Ka=a(po,"evaluate()"),po.forEach(t),Sn=a(Pt," nous pouvons rapporter la perte et la "),Fe=i(Pt,"A",{href:!0});var ke=u(Fe);Gn=a(ke,"perplexit\xE9"),ke.forEach(t),Cs=a(Pt," \xE0 intervalles r\xE9guliers. Ensuite, nous red\xE9finissons notre mod\xE8le pour nous assurer que nous entra\xEEnons \xE0 nouveau \xE0 partir de z\xE9ro :"),Pt.forEach(t),cn=f(o),y(He.$$.fragment,o),Fn=f(o),Ds=i(o,"P",{});var Bo=u(Ds);os=a(Bo,"Nous pouvons ensuite d\xE9finir notre optimiseur, en utilisant la fonction pr\xE9c\xE9dente pour diviser les param\xE8tres de d\xE9croissance des poids :"),Bo.forEach(t),Hn=f(o),y(Je.$$.fragment,o),In=f(o),ft=i(o,"P",{});var pa=u(ft);Rn=a(pa,"Pr\xE9parons maintenant le mod\xE8le, l\u2019optimiseur et les chargeurs de donn\xE9es pour pouvoir commencer l\u2019entra\xEEnement :"),pa.forEach(t),rs=f(o),y(ls.$$.fragment,o),is=f(o),y(us.$$.fragment,o),Ye=f(o),$e=i(o,"P",{});var hs=u($e);_t=a(hs,"Maintenant que nous avons envoy\xE9 notre "),dn=i(hs,"CODE",{});var Wo=u(dn);Vn=a(Wo,"train_dataloader"),Wo.forEach(t),Ts=a(hs," \xE0 "),ht=i(hs,"CODE",{});var ca=u(ht);Ms=a(ca,"accelerator.prepare()"),ca.forEach(t),Un=a(hs,", nous pouvons utiliser sa longueur pour calculer le nombre d\u2019\xE9tapes d\u2019entra\xEEnement. Rappelez-vous que nous devons toujours faire cela apr\xE8s avoir pr\xE9par\xE9 le "),Ie=i(hs,"EM",{});var Xo=u(Ie);Ja=a(Xo,"dataloader"),Xo.forEach(t),mn=a(hs," car cette m\xE9thode modifiera sa longueur. Nous utilisons un programme lin\xE9aire classique du taux d\u2019apprentissage \xE0 0 :"),hs.forEach(t),Bn=f(o),y(As.$$.fragment,o),fn=f(o),Z=i(o,"P",{});var we=u(Z);ps=a(we,"Enfin, pour pousser notre mod\xE8le vers le "),Ns=i(we,"EM",{});var da=u(Ns);Ls=a(da,"Hub"),da.forEach(t),Ya=a(we,", nous aurons besoin de cr\xE9er un objet "),Os=i(we,"CODE",{});var Ko=u(Os);Za=a(Ko,"Repository"),Ko.forEach(t),Wn=a(we," dans un dossier de travail. Tout d\u2019abord, connectez-vous au "),Ze=i(we,"EM",{});var Jo=u(Ze);Xn=a(Jo,"Hub"),Jo.forEach(t),cs=a(we,", si vous n\u2019\xEAtes pas d\xE9j\xE0 connect\xE9. Nous d\xE9terminerons le nom du d\xE9p\xF4t \xE0 partir de l\u2019identifiant du mod\xE8le que nous voulons donner \xE0 notre mod\xE8le (n\u2019h\xE9sitez pas \xE0 remplacer le "),_n=i(we,"CODE",{});var ma=u(_n);hn=a(ma,"repo_name"),ma.forEach(t),Qa=a(we," par votre propre choix. Il doit juste contenir votre nom d\u2019utilisateur, ce que fait la fonction "),vn=i(we,"CODE",{});var Yo=u(vn);Kn=a(Yo,"get_full_repo_name()"),Yo.forEach(t),ie=a(we,") :"),we.forEach(t),Jn=f(o),y(Qe.$$.fragment,o),Yn=f(o),y(Ss.$$.fragment,o),vt=f(o),gt=i(o,"P",{});var Zo=u(gt);eo=a(Zo,"Ensuite, nous pouvons cloner ce d\xE9p\xF4t dans un dossier local. S\u2019il existe d\xE9j\xE0, ce dossier local doit \xEAtre un clone existant du d\xE9p\xF4t avec lequel nous travaillons :"),Zo.forEach(t),Gs=f(o),y(Fs.$$.fragment,o),Zn=f(o),ye=i(o,"P",{});var Xs=u(ye);so=a(Xs,"Nous pouvons maintenant t\xE9l\xE9charger tout ce que nous sauvegardons dans "),gn=i(Xs,"CODE",{});var Ve=u(gn);bn=a(Ve,"output_dir"),Ve.forEach(t),to=a(Xs," en appelant la m\xE9thode "),$n=i(Xs,"CODE",{});var Ue=u($n);Qn=a(Ue,"repo.push_to_hub()"),Ue.forEach(t),es=a(Xs,". Cela nous aidera \xE0 t\xE9l\xE9charger les mod\xE8les interm\xE9diaires \xE0 la fin de chaque \xE9poque."),Xs.forEach(t),ds=f(o),qn=i(o,"P",{});var yn=u(qn);no=a(yn,"Avant de nous entra\xEEner, ex\xE9cutons un test rapide pour voir si la fonction d\u2019\xE9valuation fonctionne correctement :"),yn.forEach(t),ms=f(o),y(bt.$$.fragment,o),kn=f(o),y(Re.$$.fragment,o),ea=f(o),ss=i(o,"P",{});var Te=u(ss);Hs=a(Te,"Ce sont des valeurs tr\xE8s \xE9lev\xE9es pour la perte et la perplexit\xE9, mais ce n\u2019est pas surprenant puisque nous n\u2019avons pas encore entra\xEEn\xE9 le mod\xE8le. Avec cela, nous avons tout pr\xE9par\xE9 pour \xE9crire la partie principale du script d\u2019entra\xEEnement : la boucle d\u2019entra\xEEnement. Dans celle-ci, nous it\xE9rons sur le chargeur de donn\xE9es et transmettons les batchs au mod\xE8le. Avec les logits, nous pouvons alors \xE9valuer notre fonction de perte personnalis\xE9e. Nous mettons \xE0 l\u2019\xE9chelle la perte par le nombre d\u2019\xE9tapes d\u2019accumulation du gradient afin de ne pas cr\xE9er de plus grandes pertes en agr\xE9geant plus d\u2019\xE9tapes. Avant de proc\xE9der \xE0 l\u2019optimisation, nous d\xE9coupons \xE9galement les gradients pour une meilleure convergence. Enfin, tous les quelques pas, nous \xE9valuons le mod\xE8le sur l\u2019ensemble d\u2019\xE9valuation avec notre nouvelle fonction "),$t=i(Te,"CODE",{});var Qo=u($t);Is=a(Qo,"evaluate()"),Qo.forEach(t),sa=a(Te," :"),Te.forEach(t),De=f(o),y(Rs.$$.fragment,o),qt=f(o),kt=i(o,"P",{});var fa=u(kt);ao=a(fa,"Et voil\xE0, vous disposez maintenant de votre propre boucle d\u2019entra\xEEnement personnalis\xE9e pour les mod\xE8les de langage causal tels que le GPT-2. Vous pouvez encore l\u2019adapter \xE0 vos besoins."),fa.forEach(t),jt=f(o),y(Vs.$$.fragment,o),ta=f(o),y(fs.$$.fragment,o),this.h()},h(){A(_,"id","entraner-avec-iacceleratei"),A(_,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),A(_,"href","#entraner-avec-iacceleratei"),A(r,"class","relative group"),A(Fe,"href","/course/fr/chapter7/3")},m(o,q){p(o,r,q),s(r,_),s(_,c),w(v,c,null),s(r,k),s(r,$),s($,z),s($,D),s(D,j),p(o,P,q),p(o,N,q),s(N,M),s(N,h),s(h,T),s(N,H),s(N,F),s(F,Y),s(N,R),p(o,ee,q),w(W,o,q),p(o,X,q),p(o,C,q),s(C,se),s(C,V),s(V,I),s(C,S),s(C,U),s(U,ae),s(C,he),s(C,J),s(J,ue),s(C,ve),s(C,ge),s(ge,Q),s(C,ze),s(C,je),s(je,G),s(C,K),s(C,Ae),s(Ae,nt),s(C,at),s(C,Ne),s(Ne,ns),s(C,ot),s(C,me),s(me,rt),s(C,lt),s(C,bs),s(bs,za),s(C,Pa),s(C,it),s(it,$s),s(C,zn),s(C,oe),s(oe,Ca),s(C,ut),s(C,Ot),s(Ot,Da),s(C,St),s(C,Gt),s(Gt,Ta),s(C,Ft),s(C,Ht),s(Ht,Ma),s(C,It),s(C,Rt),s(Rt,Aa),s(C,Vt),p(o,Pn,q),w(qs,o,q),p(o,Ut,q),w(re,o,q),p(o,Na,q),p(o,te,q),s(te,be),s(te,Cn),s(Cn,Dn),s(te,Le),s(te,Bt),s(Bt,Wt),s(te,La),s(te,Xt),s(Xt,ks),s(te,Oa),s(te,Kt),s(Kt,Tn),s(te,Xe),s(te,Oe),s(Oe,Jt),s(te,js),s(te,Yt),s(Yt,Zt),s(te,Sa),p(o,Qt,q),w(le,o,q),p(o,Mn,q),p(o,Pe,q),s(Pe,Ga),p(o,pt,q),p(o,Se,q),s(Se,en),s(en,sn),s(Se,Fa),s(Se,tn),s(tn,Es),s(Se,nn),s(Se,an),s(an,Ha),p(o,on,q),p(o,ne,q),s(ne,Ia),s(ne,ys),s(ys,Ra),s(ne,Va),s(ne,ws),s(ws,Ua),s(ne,Ba),p(o,ct,q),w(xs,o,q),p(o,An,q),p(o,Ke,q),s(Ke,zs),s(Ke,dt),s(dt,mt),s(Ke,Wa),p(o,rn,q),w(Ce,o,q),p(o,ln,q),p(o,Ee,q),s(Ee,Nn),s(Ee,Ge),s(Ge,Xa),s(Ee,un),p(o,Ln,q),w(Ps,o,q),p(o,pn,q),p(o,fe,q),s(fe,On),s(fe,as),s(as,Ka),s(fe,Sn),s(fe,Fe),s(Fe,Gn),s(fe,Cs),p(o,cn,q),w(He,o,q),p(o,Fn,q),p(o,Ds,q),s(Ds,os),p(o,Hn,q),w(Je,o,q),p(o,In,q),p(o,ft,q),s(ft,Rn),p(o,rs,q),w(ls,o,q),p(o,is,q),w(us,o,q),p(o,Ye,q),p(o,$e,q),s($e,_t),s($e,dn),s(dn,Vn),s($e,Ts),s($e,ht),s(ht,Ms),s($e,Un),s($e,Ie),s(Ie,Ja),s($e,mn),p(o,Bn,q),w(As,o,q),p(o,fn,q),p(o,Z,q),s(Z,ps),s(Z,Ns),s(Ns,Ls),s(Z,Ya),s(Z,Os),s(Os,Za),s(Z,Wn),s(Z,Ze),s(Ze,Xn),s(Z,cs),s(Z,_n),s(_n,hn),s(Z,Qa),s(Z,vn),s(vn,Kn),s(Z,ie),p(o,Jn,q),w(Qe,o,q),p(o,Yn,q),w(Ss,o,q),p(o,vt,q),p(o,gt,q),s(gt,eo),p(o,Gs,q),w(Fs,o,q),p(o,Zn,q),p(o,ye,q),s(ye,so),s(ye,gn),s(gn,bn),s(ye,to),s(ye,$n),s($n,Qn),s(ye,es),p(o,ds,q),p(o,qn,q),s(qn,no),p(o,ms,q),w(bt,o,q),p(o,kn,q),w(Re,o,q),p(o,ea,q),p(o,ss,q),s(ss,Hs),s(ss,$t),s($t,Is),s(ss,sa),p(o,De,q),w(Rs,o,q),p(o,qt,q),p(o,kt,q),s(kt,ao),p(o,jt,q),w(Vs,o,q),p(o,ta,q),w(fs,o,q),pe=!0},i(o){pe||(g(v.$$.fragment,o),g(W.$$.fragment,o),g(qs.$$.fragment,o),g(re.$$.fragment,o),g(le.$$.fragment,o),g(xs.$$.fragment,o),g(Ce.$$.fragment,o),g(Ps.$$.fragment,o),g(He.$$.fragment,o),g(Je.$$.fragment,o),g(ls.$$.fragment,o),g(us.$$.fragment,o),g(As.$$.fragment,o),g(Qe.$$.fragment,o),g(Ss.$$.fragment,o),g(Fs.$$.fragment,o),g(bt.$$.fragment,o),g(Re.$$.fragment,o),g(Rs.$$.fragment,o),g(Vs.$$.fragment,o),g(fs.$$.fragment,o),pe=!0)},o(o){b(v.$$.fragment,o),b(W.$$.fragment,o),b(qs.$$.fragment,o),b(re.$$.fragment,o),b(le.$$.fragment,o),b(xs.$$.fragment,o),b(Ce.$$.fragment,o),b(Ps.$$.fragment,o),b(He.$$.fragment,o),b(Je.$$.fragment,o),b(ls.$$.fragment,o),b(us.$$.fragment,o),b(As.$$.fragment,o),b(Qe.$$.fragment,o),b(Ss.$$.fragment,o),b(Fs.$$.fragment,o),b(bt.$$.fragment,o),b(Re.$$.fragment,o),b(Rs.$$.fragment,o),b(Vs.$$.fragment,o),b(fs.$$.fragment,o),pe=!1},d(o){o&&t(r),x(v),o&&t(P),o&&t(N),o&&t(ee),x(W,o),o&&t(X),o&&t(C),o&&t(Pn),x(qs,o),o&&t(Ut),x(re,o),o&&t(Na),o&&t(te),o&&t(Qt),x(le,o),o&&t(Mn),o&&t(Pe),o&&t(pt),o&&t(Se),o&&t(on),o&&t(ne),o&&t(ct),x(xs,o),o&&t(An),o&&t(Ke),o&&t(rn),x(Ce,o),o&&t(ln),o&&t(Ee),o&&t(Ln),x(Ps,o),o&&t(pn),o&&t(fe),o&&t(cn),x(He,o),o&&t(Fn),o&&t(Ds),o&&t(Hn),x(Je,o),o&&t(In),o&&t(ft),o&&t(rs),x(ls,o),o&&t(is),x(us,o),o&&t(Ye),o&&t($e),o&&t(Bn),x(As,o),o&&t(fn),o&&t(Z),o&&t(Jn),x(Qe,o),o&&t(Yn),x(Ss,o),o&&t(vt),o&&t(gt),o&&t(Gs),x(Fs,o),o&&t(Zn),o&&t(ye),o&&t(ds),o&&t(qn),o&&t(ms),x(bt,o),o&&t(kn),x(Re,o),o&&t(ea),o&&t(ss),o&&t(De),x(Rs,o),o&&t(qt),o&&t(kt),o&&t(jt),x(Vs,o),o&&t(ta),x(fs,o)}}}function Bp(O){let r,_,c,v,k;return{c(){r=l("p"),_=n("\u{1F6A8} Si vous vous entra\xEEnez sur un TPU, vous devrez d\xE9placer tout le code commen\xE7ant \xE0 la cellule ci-dessus dans une fonction d\u2019entra\xEEnement d\xE9di\xE9e. Voir le "),c=l("a"),v=n("chapitre 3"),k=n(" pour plus de d\xE9tails."),this.h()},l($){r=i($,"P",{});var z=u(r);_=a(z,"\u{1F6A8} Si vous vous entra\xEEnez sur un TPU, vous devrez d\xE9placer tout le code commen\xE7ant \xE0 la cellule ci-dessus dans une fonction d\u2019entra\xEEnement d\xE9di\xE9e. Voir le "),c=i(z,"A",{href:!0});var D=u(c);v=a(D,"chapitre 3"),D.forEach(t),k=a(z," pour plus de d\xE9tails."),z.forEach(t),this.h()},h(){A(c,"href","/course/fr/chapter3")},m($,z){p($,r,z),s(r,_),s(r,c),s(c,v),s(r,k)},d($){$&&t(r)}}}function Wp(O){let r,_,c,v,k;return{c(){r=l("p"),_=n("\u270F\uFE0F "),c=l("strong"),v=n("Essayez !"),k=n(" Vous pouvez cr\xE9er votre propre fonction de perte personnalis\xE9e, adapt\xE9e \xE0 votre cas d\u2019utilisation, ou ajouter une autre \xE9tape personnalis\xE9e dans la boucle d\u2019entra\xEEnement.")},l($){r=i($,"P",{});var z=u(r);_=a(z,"\u270F\uFE0F "),c=i(z,"STRONG",{});var D=u(c);v=a(D,"Essayez !"),D.forEach(t),k=a(z," Vous pouvez cr\xE9er votre propre fonction de perte personnalis\xE9e, adapt\xE9e \xE0 votre cas d\u2019utilisation, ou ajouter une autre \xE9tape personnalis\xE9e dans la boucle d\u2019entra\xEEnement."),z.forEach(t)},m($,z){p($,r,z),s(r,_),s(r,c),s(c,v),s(r,k)},d($){$&&t(r)}}}function Xp(O){let r,_,c,v,k,$,z,D,j,P,N;return{c(){r=l("p"),_=n("\u270F\uFE0F "),c=l("strong"),v=n("Essayez !"),k=n(" Lorsque vous effectuez de longues exp\xE9riences d\u2019entra\xEEnement, il est bon d\u2019enregistrer les mesures importantes \xE0 l\u2019aide d\u2019outils tels que "),$=l("em"),z=n("TensorBoard"),D=n(" ou "),j=l("em"),P=n("Weights & Biases"),N=n(". Ajoutez l\u2019un d\u2019eux \xE0 la boucle d\u2019entra\xEEnement afin de pouvoir toujours v\xE9rifier comment se d\xE9roule l\u2019entra\xEEnement.")},l(M){r=i(M,"P",{});var h=u(r);_=a(h,"\u270F\uFE0F "),c=i(h,"STRONG",{});var T=u(c);v=a(T,"Essayez !"),T.forEach(t),k=a(h," Lorsque vous effectuez de longues exp\xE9riences d\u2019entra\xEEnement, il est bon d\u2019enregistrer les mesures importantes \xE0 l\u2019aide d\u2019outils tels que "),$=i(h,"EM",{});var H=u($);z=a(H,"TensorBoard"),H.forEach(t),D=a(h," ou "),j=i(h,"EM",{});var F=u(j);P=a(F,"Weights & Biases"),F.forEach(t),N=a(h,". Ajoutez l\u2019un d\u2019eux \xE0 la boucle d\u2019entra\xEEnement afin de pouvoir toujours v\xE9rifier comment se d\xE9roule l\u2019entra\xEEnement."),h.forEach(t)},m(M,h){p(M,r,h),s(r,_),s(r,c),s(c,v),s(r,k),s(r,$),s($,z),s(r,D),s(r,j),s(j,P),s(r,N)},d(M){M&&t(r)}}}function Kp(O){let r,_,c,v,k,$,z,D,j,P,N,M,h,T,H,F,Y,R,ee,W,X,C,se,V,I,S,U,ae,he,J,ue,ve,ge,Q,ze,je,G,K,Ae,nt,at,Ne,ns,ot,me,rt,lt,bs,za,Pa,it,$s,zn,oe,Ca,ut,Ot,Da,St,Gt,Ta,Ft,Ht,Ma,It,Rt,Aa,Vt,Pn,qs,Ut,re,Na,te,be,Cn,Dn,Le,Bt,Wt,La,Xt,ks,Oa,Kt,Tn,Xe,Oe,Jt,js,Yt,Zt,Sa,Qt,le,Mn,Pe,Ga,pt,Se,en,sn,Fa,tn,Es,nn,an,Ha,on,ne,Ia,ys,Ra,Va,ws,Ua,Ba,ct,xs,An,Ke,zs,dt,mt,Wa,rn,Ce,ln,Ee,Nn,Ge,Xa,un,Ln,Ps,pn,fe,On,as,Ka,Sn,Fe,Gn,Cs,cn,He,Fn,Ds,os,Hn,Je,In,ft,Rn,rs,ls,is,us,Ye,$e,_t,dn,Vn,Ts,ht,Ms,Un,Ie,Ja,mn,Bn,As,fn,Z,ps,Ns,Ls,Ya,Os,Za,Wn,Ze,Xn,cs,_n,hn,Qa,vn,Kn,ie,Jn,Qe,Yn,Ss,vt,gt,eo,Gs,Fs,Zn,ye,so,gn,bn,to,$n,Qn,es,ds,qn,no,ms,bt,kn,Re,ea,ss,Hs,$t,Is,sa,De,Rs,qt,kt,ao,jt,Vs,ta,fs,pe,o,q,Do,To,jn,Mo,Et,En,Ao,B,na,No,Lo,oo,yt,ro,wt,lo,qe,Oo,aa,So,Go,oa,Fo,_e,ra,Ho,Io,la,Ro,Vo,io,ts,Uo,uo,Us,Bs,_s,Ws,xt,zt,ia,ua,Pt,po,ke,Bo,pa,hs,Wo,ca,Xo,we,da,Ko,Jo,ma,Yo,Zo,Xs,Ve,Ue,yn,Te,Qo,fa,Al,Nl,qr,Ll,Ol,Vr,Be,Sl,kr,Gl,Fl,jr,Hl,Il,Er,Rl,Vl,yr,Ul,Bl,Ur,Ks,Js,er,sr,Wl,Br,co,Wr,Ys,Zs,tr,nr,Xl,Xr,ar,_a,Kr,ha,Kl,wr,Jl,Yl,Jr,mo,Yr,va,Zl,xr,Ql,ei,Zr,ga,si,zr,ti,ni,Qr,fo,el,Qs,et,or,ba,sl,$a,tl,wn,qa,Pr,_o,ai,Cr,oi,nl,ka,ri,Dr,li,ii,al,st,tt,rr,lr,ui,ol,ho,rl,vo,ll,Ct,pi,Tr,ci,di,Mr,mi,fi,il,go,ul,bo,pl,We,_i,Ar,hi,vi,Nr,gi,bi,Lr,$i,qi,Or,ki,ji,cl,$o,dl,qo,ml,Dt,Ei,Sr,yi,wi,Gr,xi,zi,fl,ko,_l,jo,hl,ir,ur,vl;c=new Ep({props:{fw:O[0]}}),D=new $r({});const Di=[wp,yp],Eo=[];function Ti(e,d){return e[0]==="pt"?0:1}h=Ti(O),T=Eo[h]=Di[h](O),$s=new Ci({props:{id:"Vpjb1lu0MDk"}}),js=new $r({}),zs=new L({props:{code:`def any_keyword_in_string(string, keywords):
    for keyword in keywords:
        if keyword in string:
            return True
    return False`,highlighted:`<span class="hljs-keyword">def</span> <span class="hljs-title function_">any_keyword_in_string</span>(<span class="hljs-params">string, keywords</span>):
    <span class="hljs-keyword">for</span> keyword <span class="hljs-keyword">in</span> keywords:
        <span class="hljs-keyword">if</span> keyword <span class="hljs-keyword">in</span> string:
            <span class="hljs-keyword">return</span> <span class="hljs-literal">True</span>
    <span class="hljs-keyword">return</span> <span class="hljs-literal">False</span>`}}),Ce=new L({props:{code:`filters = ["pandas", "sklearn", "matplotlib", "seaborn"]
example_1 = "import numpy as np"
example_2 = "import pandas as pd"

print(
    any_keyword_in_string(example_1, filters), any_keyword_in_string(example_2, filters)
)`,highlighted:`filters = [<span class="hljs-string">&quot;pandas&quot;</span>, <span class="hljs-string">&quot;sklearn&quot;</span>, <span class="hljs-string">&quot;matplotlib&quot;</span>, <span class="hljs-string">&quot;seaborn&quot;</span>]
example_1 = <span class="hljs-string">&quot;import numpy as np&quot;</span>
example_2 = <span class="hljs-string">&quot;import pandas as pd&quot;</span>

<span class="hljs-built_in">print</span>(
    any_keyword_in_string(example_1, filters), any_keyword_in_string(example_2, filters)
)`}}),Ee=new L({props:{code:"False True",highlighted:'<span class="hljs-literal">False</span> <span class="hljs-literal">True</span>'}}),fe=new L({props:{code:`def filter_streaming_dataset(dataset, filters):
    filtered_dict = defaultdict(list)
    total = 0
    for sample in tqdm(iter(dataset)):
        total += 1
        if any_keyword_in_string(sample["content"], filters):
            for k, v in sample.items():
                filtered_dict[k].append(v)
    print(f"{len(filtered_dict['content'])/total:.2%} of data after filtering.")
    return Dataset.from_dict(filtered_dict)`,highlighted:`<span class="hljs-keyword">def</span> <span class="hljs-title function_">filter_streaming_dataset</span>(<span class="hljs-params">dataset, filters</span>):
    filtered_dict = defaultdict(<span class="hljs-built_in">list</span>)
    total = <span class="hljs-number">0</span>
    <span class="hljs-keyword">for</span> sample <span class="hljs-keyword">in</span> tqdm(<span class="hljs-built_in">iter</span>(dataset)):
        total += <span class="hljs-number">1</span>
        <span class="hljs-keyword">if</span> any_keyword_in_string(sample[<span class="hljs-string">&quot;content&quot;</span>], filters):
            <span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> sample.items():
                filtered_dict[k].append(v)
    <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;<span class="hljs-subst">{<span class="hljs-built_in">len</span>(filtered_dict[<span class="hljs-string">&#x27;content&#x27;</span>])/total:<span class="hljs-number">.2</span>%}</span> of data after filtering.&quot;</span>)
    <span class="hljs-keyword">return</span> Dataset.from_dict(filtered_dict)`}}),Fe=new L({props:{code:`# Cette cellule prendra beaucoup de temps \xE0 s'ex\xE9cuter, donc vous devriez la sauter et aller \xE0 la suivante !
from datasets import load_dataset

split = "train"  # "valid"
filters = ["pandas", "sklearn", "matplotlib", "seaborn"]

data = load_dataset(f"transformersbook/codeparrot-{split}", split=split, streaming=True)
filtered_data = filter_streaming_dataset(data, filters)`,highlighted:`<span class="hljs-comment"># Cette cellule prendra beaucoup de temps \xE0 s&#x27;ex\xE9cuter, donc vous devriez la sauter et aller \xE0 la suivante !</span>
<span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset

split = <span class="hljs-string">&quot;train&quot;</span>  <span class="hljs-comment"># &quot;valid&quot;</span>
filters = [<span class="hljs-string">&quot;pandas&quot;</span>, <span class="hljs-string">&quot;sklearn&quot;</span>, <span class="hljs-string">&quot;matplotlib&quot;</span>, <span class="hljs-string">&quot;seaborn&quot;</span>]

data = load_dataset(<span class="hljs-string">f&quot;transformersbook/codeparrot-<span class="hljs-subst">{split}</span>&quot;</span>, split=split, streaming=<span class="hljs-literal">True</span>)
filtered_data = filter_streaming_dataset(data, filters)`}}),Cs=new L({props:{code:"3.26% of data after filtering.",highlighted:'<span class="hljs-number">3.26</span>% of data after filtering.'}}),rs=new L({props:{code:`from datasets import load_dataset, DatasetDict

ds_train = load_dataset("huggingface-course/codeparrot-ds-train", split="train")
ds_valid = load_dataset("huggingface-course/codeparrot-ds-valid", split="train")

raw_datasets = DatasetDict(
    {
        "train": ds_train,  # .shuffle().select(range(50000)),
        "valid": ds_valid,  # .shuffle().select(range(500))
    }
)

raw_datasets`,highlighted:`<span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset, DatasetDict

ds_train = load_dataset(<span class="hljs-string">&quot;huggingface-course/codeparrot-ds-train&quot;</span>, split=<span class="hljs-string">&quot;train&quot;</span>)
ds_valid = load_dataset(<span class="hljs-string">&quot;huggingface-course/codeparrot-ds-valid&quot;</span>, split=<span class="hljs-string">&quot;train&quot;</span>)

raw_datasets = DatasetDict(
    {
        <span class="hljs-string">&quot;train&quot;</span>: ds_train,  <span class="hljs-comment"># .shuffle().select(range(50000)),</span>
        <span class="hljs-string">&quot;valid&quot;</span>: ds_valid,  <span class="hljs-comment"># .shuffle().select(range(500))</span>
    }
)

raw_datasets`}}),is=new L({props:{code:`DatasetDict({
    train: Dataset({
        features: ['repo_name', 'path', 'copies', 'size', 'content', 'license'],
        num_rows: 606720
    })
    valid: Dataset({
        features: ['repo_name', 'path', 'copies', 'size', 'content', 'license'],
        num_rows: 3322
    })
})`,highlighted:`DatasetDict({
    train: Dataset({
        features: [<span class="hljs-string">&#x27;repo_name&#x27;</span>, <span class="hljs-string">&#x27;path&#x27;</span>, <span class="hljs-string">&#x27;copies&#x27;</span>, <span class="hljs-string">&#x27;size&#x27;</span>, <span class="hljs-string">&#x27;content&#x27;</span>, <span class="hljs-string">&#x27;license&#x27;</span>],
        num_rows: <span class="hljs-number">606720</span>
    })
    valid: Dataset({
        features: [<span class="hljs-string">&#x27;repo_name&#x27;</span>, <span class="hljs-string">&#x27;path&#x27;</span>, <span class="hljs-string">&#x27;copies&#x27;</span>, <span class="hljs-string">&#x27;size&#x27;</span>, <span class="hljs-string">&#x27;content&#x27;</span>, <span class="hljs-string">&#x27;license&#x27;</span>],
        num_rows: <span class="hljs-number">3322</span>
    })
})`}}),Ye=new xa({props:{$$slots:{default:[xp]},$$scope:{ctx:O}}}),Ts=new L({props:{code:`for key in raw_datasets["train"][0]:
    print(f"{key.upper()}: {raw_datasets['train'][0][key][:200]}")`,highlighted:`<span class="hljs-keyword">for</span> key <span class="hljs-keyword">in</span> raw_datasets[<span class="hljs-string">&quot;train&quot;</span>][<span class="hljs-number">0</span>]:
    <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;<span class="hljs-subst">{key.upper()}</span>: <span class="hljs-subst">{raw_datasets[<span class="hljs-string">&#x27;train&#x27;</span>][<span class="hljs-number">0</span>][key][:<span class="hljs-number">200</span>]}</span>&quot;</span>)`}}),Ms=new L({props:{code:`'REPO_NAME: kmike/scikit-learn'
'PATH: sklearn/utils/__init__.py'
'COPIES: 3'
'SIZE: 10094'
'''CONTENT: """
The :mod:\`sklearn.utils\` module includes various utilites.
"""

from collections import Sequence

import numpy as np
from scipy.sparse import issparse
import warnings

from .murmurhash import murm
LICENSE: bsd-3-clause'''`,highlighted:`<span class="hljs-string">&#x27;REPO_NAME: kmike/scikit-learn&#x27;</span>
<span class="hljs-string">&#x27;PATH: sklearn/utils/__init__.py&#x27;</span>
<span class="hljs-string">&#x27;COPIES: 3&#x27;</span>
<span class="hljs-string">&#x27;SIZE: 10094&#x27;</span>
<span class="hljs-string">&#x27;&#x27;&#x27;CONTENT: &quot;&quot;&quot;
The :mod:\`sklearn.utils\` module includes various utilites.
&quot;&quot;&quot;

from collections import Sequence

import numpy as np
from scipy.sparse import issparse
import warnings

from .murmurhash import murm
LICENSE: bsd-3-clause&#x27;&#x27;&#x27;</span>`}}),Ls=new $r({}),Ze=new Ci({props:{id:"ma1TrR7gE7I"}}),Hs=new L({props:{code:`from transformers import AutoTokenizer

context_length = 128
tokenizer = AutoTokenizer.from_pretrained("huggingface-course/code-search-net-tokenizer")

outputs = tokenizer(
    raw_datasets["train"][:2]["content"],
    truncation=True,
    max_length=context_length,
    return_overflowing_tokens=True,
    return_length=True,
)

print(f"Input IDs length: {len(outputs['input_ids'])}")
print(f"Input chunk lengths: {(outputs['length'])}")
print(f"Chunk mapping: {outputs['overflow_to_sample_mapping']}")`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer

context_length = <span class="hljs-number">128</span>
tokenizer = AutoTokenizer.from_pretrained(<span class="hljs-string">&quot;huggingface-course/code-search-net-tokenizer&quot;</span>)

outputs = tokenizer(
    raw_datasets[<span class="hljs-string">&quot;train&quot;</span>][:<span class="hljs-number">2</span>][<span class="hljs-string">&quot;content&quot;</span>],
    truncation=<span class="hljs-literal">True</span>,
    max_length=context_length,
    return_overflowing_tokens=<span class="hljs-literal">True</span>,
    return_length=<span class="hljs-literal">True</span>,
)

<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Input IDs length: <span class="hljs-subst">{<span class="hljs-built_in">len</span>(outputs[<span class="hljs-string">&#x27;input_ids&#x27;</span>])}</span>&quot;</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Input chunk lengths: <span class="hljs-subst">{(outputs[<span class="hljs-string">&#x27;length&#x27;</span>])}</span>&quot;</span>)
<span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;Chunk mapping: <span class="hljs-subst">{outputs[<span class="hljs-string">&#x27;overflow_to_sample_mapping&#x27;</span>]}</span>&quot;</span>)`}}),Is=new L({props:{code:`Input IDs length: 34
Input chunk lengths: [128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 117, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 41]
Chunk mapping: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]`,highlighted:`Input IDs length: <span class="hljs-number">34</span>
Input chunk lengths: [<span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">117</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">128</span>, <span class="hljs-number">41</span>]
Chunk mapping: [<span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>]`}}),yt=new L({props:{code:`def tokenize(element):
    outputs = tokenizer(
        element["content"],
        truncation=True,
        max_length=context_length,
        return_overflowing_tokens=True,
        return_length=True,
    )
    input_batch = []
    for length, input_ids in zip(outputs["length"], outputs["input_ids"]):
        if length == context_length:
            input_batch.append(input_ids)
    return {"input_ids": input_batch}


tokenized_datasets = raw_datasets.map(
    tokenize, batched=True, remove_columns=raw_datasets["train"].column_names
)
tokenized_datasets`,highlighted:`<span class="hljs-keyword">def</span> <span class="hljs-title function_">tokenize</span>(<span class="hljs-params">element</span>):
    outputs = tokenizer(
        element[<span class="hljs-string">&quot;content&quot;</span>],
        truncation=<span class="hljs-literal">True</span>,
        max_length=context_length,
        return_overflowing_tokens=<span class="hljs-literal">True</span>,
        return_length=<span class="hljs-literal">True</span>,
    )
    input_batch = []
    <span class="hljs-keyword">for</span> length, input_ids <span class="hljs-keyword">in</span> <span class="hljs-built_in">zip</span>(outputs[<span class="hljs-string">&quot;length&quot;</span>], outputs[<span class="hljs-string">&quot;input_ids&quot;</span>]):
        <span class="hljs-keyword">if</span> length == context_length:
            input_batch.append(input_ids)
    <span class="hljs-keyword">return</span> {<span class="hljs-string">&quot;input_ids&quot;</span>: input_batch}


tokenized_datasets = raw_datasets.<span class="hljs-built_in">map</span>(
    tokenize, batched=<span class="hljs-literal">True</span>, remove_columns=raw_datasets[<span class="hljs-string">&quot;train&quot;</span>].column_names
)
tokenized_datasets`}}),wt=new L({props:{code:`DatasetDict({
    train: Dataset({
        features: ['input_ids'],
        num_rows: 16702061
    })
    valid: Dataset({
        features: ['input_ids'],
        num_rows: 93164
    })
})`,highlighted:`DatasetDict({
    train: Dataset({
        features: [<span class="hljs-string">&#x27;input_ids&#x27;</span>],
        num_rows: <span class="hljs-number">16702061</span>
    })
    valid: Dataset({
        features: [<span class="hljs-string">&#x27;input_ids&#x27;</span>],
        num_rows: <span class="hljs-number">93164</span>
    })
})`}}),Us=new xa({props:{$$slots:{default:[zp]},$$scope:{ctx:O}}}),zt=new $r({});const Mi=[Cp,Pp],yo=[];function Ai(e,d){return e[0]==="pt"?0:1}Ve=Ai(O),Ue=yo[Ve]=Mi[Ve](O);const Ni=[Tp,Dp],wo=[];function Li(e,d){return e[0]==="pt"?0:1}Ks=Li(O),Js=wo[Ks]=Ni[Ks](O),co=new L({props:{code:`out = data_collator([tokenized_dataset["train"][i] for i in range(5)])
for key in out:
    print(f"{key} shape: {out[key].shape}")`,highlighted:`out = data_collator([tokenized_dataset[<span class="hljs-string">&quot;train&quot;</span>][i] <span class="hljs-keyword">for</span> i <span class="hljs-keyword">in</span> <span class="hljs-built_in">range</span>(<span class="hljs-number">5</span>)])
<span class="hljs-keyword">for</span> key <span class="hljs-keyword">in</span> out:
    <span class="hljs-built_in">print</span>(<span class="hljs-string">f&quot;<span class="hljs-subst">{key}</span> shape: <span class="hljs-subst">{out[key].shape}</span>&quot;</span>)`}});const Oi=[Ap,Mp],xo=[];function Si(e,d){return e[0]==="pt"?0:1}Ys=Si(O),Zs=xo[Ys]=Oi[Ys](O);let ce=O[0]==="tf"&&hp();_a=new xa({props:{warning:!0,$$slots:{default:[Np]},$$scope:{ctx:O}}}),mo=new L({props:{code:`from huggingface_hub import notebook_login

notebook_login()`,highlighted:`<span class="hljs-keyword">from</span> huggingface_hub <span class="hljs-keyword">import</span> notebook_login

notebook_login()`}}),fo=new L({props:{code:"huggingface-cli login",highlighted:"huggingface-cli login"}});const Gi=[Op,Lp],zo=[];function Fi(e,d){return e[0]==="pt"?0:1}Qs=Fi(O),et=zo[Qs]=Gi[Qs](O),ba=new xa({props:{$$slots:{default:[Sp]},$$scope:{ctx:O}}}),$a=new xa({props:{$$slots:{default:[Hp]},$$scope:{ctx:O}}}),_o=new $r({});const Hi=[Rp,Ip],Po=[];function Ii(e,d){return e[0]==="pt"?0:1}st=Ii(O),tt=Po[st]=Hi[st](O),ho=new L({props:{code:`txt = """\\
# cr\xE9er des donn\xE9es
x = np.random.randn(100)
y = np.random.randn(100)

# cr\xE9er un nuage de points avec x, y
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])`,highlighted:`txt = <span class="hljs-string">&quot;&quot;&quot;\\
# cr\xE9er des donn\xE9es
x = np.random.randn(100)
y = np.random.randn(100)

# cr\xE9er un nuage de points avec x, y
&quot;&quot;&quot;</span>
<span class="hljs-built_in">print</span>(pipe(txt, num_return_sequences=<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>][<span class="hljs-string">&quot;generated_text&quot;</span>])`}}),vo=new L({props:{code:`# cr\xE9er des donn\xE9es
x = np.random.randn(100)
y = np.random.randn(100)

# cr\xE9er un nuage de points avec x, y
plt.scatter(x, y)`,highlighted:`<span class="hljs-comment"># cr\xE9er des donn\xE9es</span>
x = np.random.randn(<span class="hljs-number">100</span>)
y = np.random.randn(<span class="hljs-number">100</span>)

<span class="hljs-comment"># cr\xE9er un nuage de points avec x, y</span>
plt.scatter(x, y)`}}),go=new L({props:{code:`txt = """\\
# cr\xE9er des donn\xE9es
x = np.random.randn(100)
y = np.random.randn(100)

# cr\xE9er un tableau de donn\xE9es \xE0 partir de x et y
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])`,highlighted:`txt = <span class="hljs-string">&quot;&quot;&quot;\\
# cr\xE9er des donn\xE9es
x = np.random.randn(100)
y = np.random.randn(100)

# cr\xE9er un tableau de donn\xE9es \xE0 partir de x et y
&quot;&quot;&quot;</span>
<span class="hljs-built_in">print</span>(pipe(txt, num_return_sequences=<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>][<span class="hljs-string">&quot;generated_text&quot;</span>])`}}),bo=new L({props:{code:`# cr\xE9er des donn\xE9es
x = np.random.randn(100)
y = np.random.randn(100)

# cr\xE9er un tableau de donn\xE9es \xE0 partir de x et y
df = pd.DataFrame({'x': x, 'y': y})
df.insert(0,'x', x)
for`,highlighted:`<span class="hljs-comment"># cr\xE9er des donn\xE9es</span>
x = np.random.randn(<span class="hljs-number">100</span>)
y = np.random.randn(<span class="hljs-number">100</span>)

<span class="hljs-comment"># cr\xE9er un tableau de donn\xE9es \xE0 partir de x et y</span>
df = pd.DataFrame({<span class="hljs-string">&#x27;x&#x27;</span>: x, <span class="hljs-string">&#x27;y&#x27;</span>: y})
df.insert(<span class="hljs-number">0</span>,<span class="hljs-string">&#x27;x&#x27;</span>, x)
<span class="hljs-keyword">for</span>`}}),$o=new L({props:{code:`txt = """\\
# tableau de donn\xE9es avec profession, revenu et nom
df = pd.DataFrame({'profession': x, 'income':y, 'name': z})

# calculer le revenu moyen par profession
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])`,highlighted:`txt = <span class="hljs-string">&quot;&quot;&quot;\\
# tableau de donn\xE9es avec profession, revenu et nom
df = pd.DataFrame({&#x27;profession&#x27;: x, &#x27;income&#x27;:y, &#x27;name&#x27;: z})

# calculer le revenu moyen par profession
&quot;&quot;&quot;</span>
<span class="hljs-built_in">print</span>(pipe(txt, num_return_sequences=<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>][<span class="hljs-string">&quot;generated_text&quot;</span>])`}}),qo=new L({props:{code:`# tableau de donn\xE9es avec profession, revenu et nom
df = pd.DataFrame({'profession': x, 'income':y, 'name': z})

# calculer le revenu moyen par profession
profession = df.groupby(['profession']).mean()`,highlighted:`<span class="hljs-comment"># tableau de donn\xE9es avec profession, revenu et nom</span>
df = pd.DataFrame({<span class="hljs-string">&#x27;profession&#x27;</span>: x, <span class="hljs-string">&#x27;income&#x27;</span>:y, <span class="hljs-string">&#x27;name&#x27;</span>: z})

<span class="hljs-comment"># calculer le revenu moyen par profession</span>
profession = df.groupby([<span class="hljs-string">&#x27;profession&#x27;</span>]).mean()`}}),ko=new L({props:{code:`txt = """
# import random forest regressor from scikit-learn
from sklearn.ensemble import RandomForestRegressor

# entra\xEEnement du mod\xE8le de for\xEAt al\xE9atoire avec 300 estimateurs sur X, y :
"""
print(pipe(txt, num_return_sequences=1)[0]["generated_text"])`,highlighted:`txt = <span class="hljs-string">&quot;&quot;&quot;
# import random forest regressor from scikit-learn
from sklearn.ensemble import RandomForestRegressor

# entra\xEEnement du mod\xE8le de for\xEAt al\xE9atoire avec 300 estimateurs sur X, y :
&quot;&quot;&quot;</span>
<span class="hljs-built_in">print</span>(pipe(txt, num_return_sequences=<span class="hljs-number">1</span>)[<span class="hljs-number">0</span>][<span class="hljs-string">&quot;generated_text&quot;</span>])`}}),jo=new L({props:{code:`# import random forest regressor from scikit-learn
from sklearn.ensemble import RandomForestRegressor

# entra\xEEnement du mod\xE8le de for\xEAt al\xE9atoire avec 300 estimateurs sur X, y :
rf = RandomForestRegressor(n_estimators=300, random_state=random_state, max_depth=3)
rf.fit(X, y)
rf`,highlighted:`<span class="hljs-comment"># import random forest regressor from scikit-learn</span>
<span class="hljs-keyword">from</span> sklearn.ensemble <span class="hljs-keyword">import</span> RandomForestRegressor

<span class="hljs-comment"># entra\xEEnement du mod\xE8le de for\xEAt al\xE9atoire avec 300 estimateurs sur X, y :</span>
rf = RandomForestRegressor(n_estimators=<span class="hljs-number">300</span>, random_state=random_state, max_depth=<span class="hljs-number">3</span>)
rf.fit(X, y)
rf`}});function Ri(e,d){return e[0]==="tf"?Up:Vp}let gl=Ri(O),xn=gl(O),de=O[0]==="pt"&&vp(O);return{c(){r=l("meta"),_=m(),E(c.$$.fragment),v=m(),k=l("h1"),$=l("a"),z=l("span"),E(D.$$.fragment),j=m(),P=l("span"),N=n("Entra\xEEner un mod\xE8le de langage causal \xE0 partir de z\xE9ro"),M=m(),T.c(),H=m(),F=l("p"),Y=n("Jusqu\u2019\xE0 pr\xE9sent, nous avons surtout r\xE9utilis\xE9 des mod\xE8les pr\xE9-entra\xEEn\xE9s et les avons "),R=l("em"),ee=n("finetun\xE9s"),W=n(" sur de nouveaux cas d\u2019usage. Comme nous l\u2019avons vu dans le "),X=l("a"),C=n("chapitre 1"),se=n(", ceci est commun\xE9ment appel\xE9 "),V=l("em"),I=n("apprentissage par transfert"),S=n(", et il s\u2019agit d\u2019une strat\xE9gie tr\xE8s efficace pour appliquer les "),U=l("em"),ae=n("transformers"),he=n(" \xE0 la plupart des applications du monde r\xE9el o\xF9 les donn\xE9es \xE9tiquet\xE9es sont rares. Dans ce chapitre, nous allons adopter une approche diff\xE9rente consistant \xE0 entra\xEEner un mod\xE8le compl\xE8tement nouveau \xE0 partir de z\xE9ro. C\u2019est une bonne d\xE9marche \xE0 adopter si vous avez beaucoup de donn\xE9es et qu\u2019elles sont tr\xE8s diff\xE9rentes des donn\xE9es de pr\xE9-entra\xEEnement utilis\xE9es par les mod\xE8les disponibles. Cependant, le pr\xE9-entra\xEEnement d\u2019un mod\xE8le de langue n\xE9cessite beaucoup plus de ressources informatiques que le simple "),J=l("em"),ue=n("finetuning"),ve=n(" d\u2019un mod\xE8le existant. Parmi les exemples o\xF9 il peut \xEAtre utile d\u2019entra\xEEner un nouveau mod\xE8le, citons les jeux de donn\xE9es constitu\xE9s de notes de musique, de s\xE9quences mol\xE9culaires telles que l\u2019ADN, ou de langages de programmation. Ces derniers ont r\xE9cemment gagn\xE9 en popularit\xE9 gr\xE2ce \xE0 des outils tels que TabNine et Copilot de GitHub (aliment\xE9s par le mod\xE8le Codex d\u2019OpenAI) qui peuvent g\xE9n\xE9rer de longues s\xE9quences de code. Cette t\xE2che de g\xE9n\xE9ration de texte est mieux abord\xE9e avec des mod\xE8les de langage autor\xE9gressifs ou causaux tels que le GPT-2."),ge=m(),Q=l("p"),ze=n("Dans cette section, nous allons construire une version r\xE9duite d\u2019un mod\xE8le de g\xE9n\xE9ration de code Python. Nous nous concentrerons sur la compl\xE9tion d\u2019une ligne de code au lieu de fonctions ou de classes compl\xE8tes. Lorsque vous travaillez sur des projets de science des donn\xE9es en Python, vous \xEAtes souvent en contact avec les biblioth\xE8ques "),je=l("code"),G=n("matplotlib"),K=n(", "),Ae=l("code"),nt=n("seaborn"),at=n(", "),Ne=l("code"),ns=n("pandas"),ot=n(" et "),me=l("code"),rt=n("scikit-learn"),lt=n(". Lors de l\u2019utilisation de ces "),bs=l("em"),za=n("frameworks"),Pa=n(", il est fr\xE9quent d\u2019avoir besoin de rechercher des commandes sp\xE9cifiques. Il serait donc bien d\u2019utiliser un mod\xE8le pour compl\xE9ter ces appels pour nous."),it=m(),E($s.$$.fragment),zn=m(),oe=l("p"),Ca=n("Dans le "),ut=l("a"),Ot=n("chapitre 6"),Da=n(", nous avons cr\xE9\xE9 un "),St=l("em"),Gt=n("tokenizer"),Ta=n(" efficace pour traiter du code Python. Nous avons besoin d\u2019un jeu de donn\xE9es \xE0 grande \xE9chelle pour pr\xE9-entra\xEEner un mod\xE8le. Ici, nous allons appliquer notre "),Ft=l("em"),Ht=n("tokenizer"),Ma=n(" \xE0 un corpus de code Python provenant des d\xE9p\xF4ts GitHub. Nous utiliserons ensuite l\u2019API "),It=l("code"),Rt=n("Trainer"),Aa=n(" et \u{1F917} "),Vt=l("em"),Pn=n("Accelerate"),qs=n(" pour entra\xEEner le mod\xE8le. C\u2019est parti !"),Ut=m(),re=l("iframe"),te=m(),be=l("iframe"),Dn=m(),Le=l("p"),Bt=n("Il s\u2019agit d\u2019une pr\xE9sentation du mod\xE8le qui a \xE9t\xE9 entra\xEEn\xE9 \xE0 l\u2019aide du code pr\xE9sent\xE9 dans cette section et qui a ensuit\xE9 \xE9t\xE9 t\xE9l\xE9charg\xE9 sur le "),Wt=l("em"),La=n("Hub"),Xt=n(". Vous pouvez le trouver "),ks=l("a"),Oa=n("ici"),Kt=n(". Notez qu\u2019\xE9tant donn\xE9 qu\u2019il y a un certains al\xE9at dans la g\xE9n\xE9ration du texte, vous obtiendrez probablement un r\xE9sultat l\xE9g\xE8rement diff\xE9rent."),Tn=m(),Xe=l("h2"),Oe=l("a"),Jt=l("span"),E(js.$$.fragment),Yt=m(),Zt=l("span"),Sa=n("Collecte des donn\xE9es"),Qt=m(),le=l("p"),Mn=n("On peut trouver du code Python en abondance dans les d\xE9p\xF4ts de code tels que GitHub, que nous pouvons utiliser pour cr\xE9er un jeu de donn\xE9es en r\xE9cup\xE9rant chaque d\xE9p\xF4t Python. C\u2019est l\u2019approche adopt\xE9e dans le "),Pe=l("a"),Ga=n("livre "),pt=l("em"),Se=n("Natural Language Processing with Transformers"),en=n(" pour pr\xE9-entra\xEEner un grand GPT-2. En utilisant un d\xE9p\xF4t GitHub d\u2019environ 180 Go contenant approximativement 20 millions de fichiers Python, les auteurs du livre ont construit un jeu de donn\xE9es appel\xE9 "),sn=l("code"),Fa=n("codeparrot"),tn=n(" qu\u2019ils ont ensuite partag\xE9 sur le "),Es=l("a"),nn=l("em"),an=n("Hub"),Ha=n("."),on=m(),ne=l("p"),Ia=n("Cependant, entra\xEEner sur l\u2019ensemble du corpus prend beaucoup de temps et demande beaucoup de ressources de calculs. Dans notre cas, nous n\u2019avons besoin que du sous-ensemble du jeu de donn\xE9es qui est relatif aux codes portant sur la science des donn\xE9es. Commen\xE7ons donc par filtrer le jeu de donn\xE9es "),ys=l("code"),Ra=n("codeparrot"),Va=n(" en ne gardant que les fichiers incluant l\u2019une des biblioth\xE8ques de science des donn\xE9es \xE9num\xE9r\xE9es pr\xE9c\xE9demment. En raison de la taille du jeu de donn\xE9es, nous voulons \xE9viter de le t\xE9l\xE9charger. Nous utiliserons donc la fonctionnalit\xE9 de "),ws=l("em"),Ua=n("streaming"),Ba=n(" de \u{1F917} "),ct=l("em"),xs=n("Datasets"),An=n(" afin de le filtrer \xE0 la vol\xE9e. Pour nous aider \xE0 filtrer les \xE9chantillons de code utilisant les biblioth\xE8ques que nous avons mentionn\xE9es pr\xE9c\xE9demment, nous utilisons la fonction suivante :"),Ke=m(),E(zs.$$.fragment),dt=m(),mt=l("p"),Wa=n("Testons-le sur deux exemples :"),rn=m(),E(Ce.$$.fragment),ln=m(),E(Ee.$$.fragment),Nn=m(),Ge=l("p"),Xa=n("Nous pouvons l\u2019utiliser pour cr\xE9er une fonction qui va "),un=l("em"),Ln=n("streamer"),Ps=n(" le jeu de donner et filtrer les \xE9l\xE9ments que nous voulons :"),pn=m(),E(fe.$$.fragment),On=m(),as=l("p"),Ka=n("Ensuite, nous pouvons simplement appliquer cette fonction :"),Sn=m(),E(Fe.$$.fragment),Gn=m(),E(Cs.$$.fragment),cn=m(),He=l("p"),Fn=n("Cela nous laisse avec environ 3 % du jeu de donn\xE9es original, ce qui est tout de m\xEAme assez important puisqu\u2019il fait 6 Go et se compose de 600 000 scripts Python !"),Ds=m(),os=l("p"),Hn=n("Le filtrage peut prendre de 2 \xE0 3 heures, selon votre machine et votre bande passante. Si vous ne voulez pas passer par ce long processus, nous fournissons sur le "),Je=l("em"),In=n("Hub"),ft=n(" le jeu de donn\xE9es filtr\xE9 pour que vous puissiez le t\xE9l\xE9charger :"),Rn=m(),E(rs.$$.fragment),ls=m(),E(is.$$.fragment),us=m(),E(Ye.$$.fragment),$e=m(),_t=l("p"),dn=n("Examinons un exemple tir\xE9 du jeu de donn\xE9es. Nous ne montrerons que les 200 premiers caract\xE8res de chaque champ :"),Vn=m(),E(Ts.$$.fragment),ht=m(),E(Ms.$$.fragment),Un=m(),Ie=l("p"),Ja=n("Nous pouvons voir que le champ "),mn=l("code"),Bn=n("content"),As=n(" contient le code sur lequel nous voulons que notre mod\xE8le s\u2019entra\xEEne. Maintenant que nous avons un jeu de donn\xE9es, nous devons pr\xE9parer les textes afin qu\u2019ils soient dans un format appropri\xE9 pour le pr\xE9-entra\xEEnement."),fn=m(),Z=l("h2"),ps=l("a"),Ns=l("span"),E(Ls.$$.fragment),Ya=m(),Os=l("span"),Za=n("Pr\xE9paration du jeu de donn\xE9es"),Wn=m(),E(Ze.$$.fragment),Xn=m(),cs=l("p"),_n=n("La premi\xE8re \xE9tape est de tokeniser les donn\xE9es afin de pouvoir les utiliser pour l\u2019entra\xEEnement. Puisque notre objectif est d\u2019autocompl\xE9ter de courts appels de fonctions, nous pouvons garder la taille du contexte relativement petite. L\u2019avantage est que nous pouvons entra\xEEner le mod\xE8le beaucoup plus rapidement et qu\u2019il n\xE9cessite beaucoup moins de m\xE9moire. Si c\u2019est important pour votre application d\u2019avoir davantage de contexte (par exemple, si vous voulez que le mod\xE8le \xE9crive des tests unitaires bas\xE9s sur un fichier avec la d\xE9finition de la fonction), assurez-vous d\u2019augmenter ce nombre. Gardez n\xE9anmoins \xE0 l\u2019esprit que cela s\u2019accompagne d\u2019une plus grande empreinte m\xE9moire du GPU. Pour l\u2019instant, fixons la taille du contexte \xE0 128 "),hn=l("em"),Qa=n("tokens"),vn=n(", par opposition aux 1 024 ou 2 048 utilis\xE9s respectivement dans le GPT-2 et le GPT-3."),Kn=m(),ie=l("p"),Jn=n("La plupart des documents contiennent beaucoup plus de 128 "),Qe=l("em"),Yn=n("tokens"),Ss=n(", donc le fait de tronquer les entr\xE9es \xE0 la longueur maximale \xE9liminerait une grande partie de notre jeu de donn\xE9es. A la place, nous allons utiliser l\u2019option "),vt=l("code"),gt=n("return_overflowing_tokens"),eo=n(" pour tokeniser l\u2019entr\xE9e enti\xE8re et la diviser en plusieurs morceaux, comme nous l\u2019avons fait dans le "),Gs=l("a"),Fs=n("chapitre 6"),Zn=n(". Nous utiliserons \xE9galement l\u2019option "),ye=l("code"),so=n("return_length"),gn=n(" pour retourner automatiquement la longueur de chaque morceau cr\xE9\xE9. Souvent, le dernier morceau est plus petit que la taille du contexte et nous nous en d\xE9barrasserons pour \xE9viter les probl\xE8mes de "),bn=l("em"),to=n("padding"),$n=n(". Nous n\u2019en avons pas vraiment besoin puisque de toute fa\xE7on nous avons beaucoup de donn\xE9es."),Qn=m(),es=l("div"),ds=l("img"),no=m(),ms=l("img"),kn=m(),Re=l("p"),ea=n("Voyons comment cela fonctionne en examinant les deux premiers exemples :"),ss=m(),E(Hs.$$.fragment),$t=m(),E(Is.$$.fragment),sa=m(),De=l("p"),Rs=n("Nous pouvons voir que nous obtenons 34 morceaux \xE0 partir de ces deux exemples. En regardant leurs longueurs, nous pouvons voir qu\u2019ils se terminent avec moins de 128 "),qt=l("em"),kt=n("tokens"),ao=n(" (117 et 41, respectivement). Ils ne repr\xE9sentent qu\u2019une petite fraction du total des morceaux que nous avons (2/34), donc nous pouvons les jeter sans risque. Avec le champ "),jt=l("code"),Vs=n("overflow_to_sample_mapping"),ta=n(", nous pouvons aussi reconstruire quels morceaux appartenaient \xE0 quels \xE9chantillons d\u2019entr\xE9e."),fs=m(),pe=l("p"),o=n("Avec cette op\xE9ration, nous utilisons une fonctionnalit\xE9 pratique de la fonction "),q=l("code"),Do=n("Dataset.map()"),To=n(" de \u{1F917} "),jn=l("em"),Mo=n("Datasets"),Et=n(". En effet, celle-ci ne n\xE9cessite pas une correspondance un \xE0 un comme nous l\u2019avons vu dans la "),En=l("a"),Ao=n("section 3"),B=n(". Nous pouvons cr\xE9er des batchs avec plus ou moins d\u2019\xE9l\xE9ments que le batch d\u2019entr\xE9e. C\u2019est utile lorsque l\u2019on effectue des op\xE9rations telles que l\u2019augmentation ou le filtrage des donn\xE9es qui modifient le nombre d\u2019\xE9l\xE9ments. Dans notre cas, lors de la tokenisation de chaque \xE9l\xE9ment en morceaux de longeur de la taille de contexte sp\xE9cifi\xE9e, nous cr\xE9ons de nombreux \xE9chantillons de chaque document. Nous devons juste nous assurer de supprimer les colonnes existantes, car elles ont une taille conflictuelle. Si nous voulions les garder, nous pourrions les r\xE9p\xE9ter de mani\xE8re appropri\xE9e et les retourner dans l\u2019appel "),na=l("code"),No=n("Dataset.map()"),Lo=n(" :"),oo=m(),E(yt.$$.fragment),ro=m(),E(wt.$$.fragment),lo=m(),qe=l("p"),Oo=n("Nous avons maintenant 16,7 millions d\u2019exemples avec 128 "),aa=l("em"),So=n("tokens"),Go=n(" chacun, ce qui correspond \xE0 environ 2,1 milliards de "),oa=l("em"),Fo=n("tokens"),_e=n(" au total. A titre de comparaison, les mod\xE8les GPT-3 et Codex d\u2019OpenAI sont entra\xEEn\xE9s sur 300 et 100 milliards de "),ra=l("em"),Ho=n("tokens"),Io=n(", respectivement. Les mod\xE8les Codex \xE9tant initialis\xE9s \xE0 partir des "),la=l("em"),Ro=n("checkpoints"),Vo=n(" GPT-3. Notre objectif dans cette section n\u2019est pas de rivaliser avec ces mod\xE8les, qui peuvent g\xE9n\xE9rer des textes longs et coh\xE9rents, mais de cr\xE9er une version r\xE9duite fournissant une fonction d\u2019autocompl\xE9tion rapide."),io=m(),ts=l("p"),Uo=n("Maintenant que le jeu de donn\xE9es est pr\xEAt, configurons le mod\xE8le !"),uo=m(),E(Us.$$.fragment),Bs=m(),_s=l("h2"),Ws=l("a"),xt=l("span"),E(zt.$$.fragment),ia=m(),ua=l("span"),Pt=n("Initialisation d'un nouveau mod\xE8le"),po=m(),ke=l("p"),Bo=n("Notre premi\xE8re \xE9tape consiste \xE0 initialiser un GPT-2. Pour notre mod\xE8le, nous utiliserons la m\xEAme configuration que pour le petit mod\xE8le GPT-2. Ainsi nous chargeons la configuration pr\xE9-entra\xEEn\xE9e, nous nous assurons que la taille du "),pa=l("em"),hs=n("tokenizer"),Wo=n(" correspond \xE0 la taille du vocabulaire du mod\xE8le et nous passons les identifiants des "),ca=l("em"),Xo=n("tokens"),we=m(),da=l("code"),Ko=n("bos"),Jo=n(" et "),ma=l("code"),Yo=n("eos"),Zo=n(" (d\xE9but et fin de s\xE9quence) :"),Xs=m(),Ue.c(),yn=m(),Te=l("p"),Qo=n("Notre mod\xE8le comporte 124 millions de param\xE8tres que nous devrons r\xE9gler. Avant de commencer l\u2019entra\xEEnement, nous devons configurer un assembleur de donn\xE9es qui se chargera de cr\xE9er les batchs. Nous pouvons utiliser le assembleur "),fa=l("code"),Al=n("DataCollatorForLanguageModeling"),Nl=n(", qui est con\xE7u sp\xE9cifiquement pour la mod\xE9lisation du langage (comme son nom le sugg\xE8re subtilement). En plus de l\u2019empilage et du rembourrage des batchs, il s\u2019occupe aussi de la cr\xE9ation des \xE9tiquettes du mod\xE8le de langage. Dans la mod\xE9lisation causale du langage, les entr\xE9es servent aussi d\u2019\xE9tiquettes (juste d\xE9cal\xE9es d\u2019un \xE9l\xE9ment) et que le assembleur de donn\xE9es cr\xE9e \xE0 la vol\xE9e pendant l\u2019entra\xEEnement pour ne pas avoir \xE0 dupliquer les "),qr=l("code"),Ll=n("input_ids"),Ol=n("."),Vr=m(),Be=l("p"),Sl=n("Notez que "),kr=l("code"),Gl=n("DataCollatorForLanguageModeling"),Fl=n(" supporte \xE0 la fois la mod\xE9lisation du langage masqu\xE9 (MLM pour "),jr=l("em"),Hl=n("masked language modeling"),Il=n(") et la mod\xE9lisation du langage causal (CLM pour "),Er=l("em"),Rl=n("causal language modeling"),Vl=n("). Par d\xE9faut, il pr\xE9pare les donn\xE9es pour la MLM mais nous pouvons passer \xE0 la CLM en d\xE9finissant l\u2019argument "),yr=l("code"),Ul=n("mlm=False"),Bl=n(" :"),Ur=m(),Js.c(),er=m(),sr=l("p"),Wl=n("Prenons un exemple :"),Br=m(),E(co.$$.fragment),Wr=m(),Zs.c(),tr=m(),nr=l("p"),Xl=n("Nous pouvons voir que les exemples ont \xE9t\xE9 empil\xE9s et que tous les tenseurs ont la m\xEAme forme."),Xr=m(),ce&&ce.c(),ar=m(),E(_a.$$.fragment),Kr=m(),ha=l("p"),Kl=n("Nous avons maintenant tout ce qu\u2019il faut pour entra\xEEner notre mod\xE8le. Ce n\u2019\xE9tait pas si compliqu\xE9 ! Avant de commencer l\u2019entra\xEEnement, nous devons nous connecter \xE0 Hugging Face. Si vous travaillez dans un "),wr=l("em"),Jl=n("notebook"),Yl=n(", vous pouvez le faire avec la fonction utilitaire suivante :"),Jr=m(),E(mo.$$.fragment),Yr=m(),va=l("p"),Zl=n("Cela affichera un "),xr=l("em"),Ql=n("widget"),ei=n(" o\xF9 vous pourrez entrer vos identifiants de connexion \xE0 Hugging Face."),Zr=m(),ga=l("p"),si=n("Si vous ne travaillez pas dans un "),zr=l("em"),ti=n("notebook"),ni=n(", tapez simplement la ligne suivante dans votre terminal :"),Qr=m(),E(fo.$$.fragment),el=m(),et.c(),or=m(),E(ba.$$.fragment),sl=m(),E($a.$$.fragment),tl=m(),wn=l("h2"),qa=l("a"),Pr=l("span"),E(_o.$$.fragment),ai=m(),Cr=l("span"),oi=n("G\xE9n\xE9ration de code avec le pipeline"),nl=m(),ka=l("p"),ri=n("C\u2019est maintenant le moment de v\xE9rit\xE9 : voyons comment le mod\xE8le entra\xEEn\xE9 fonctionne r\xE9ellement ! Nous pouvons voir dans les logs que la perte a diminu\xE9 r\xE9guli\xE8rement, mais pour mettre le mod\xE8le \xE0 l\u2019\xE9preuve, regardons comment il fonctionne sur certains messages. Pour ce faire, nous allons envelopper le mod\xE8le dans un "),Dr=l("code"),li=n("pipeline"),ii=n(" de g\xE9n\xE9ration de texte et, s\u2019il y en a un de disponible, utiliser un GPU pour avoir des g\xE9n\xE9rations rapidement :"),al=m(),tt.c(),rr=m(),lr=l("p"),ui=n("Let\u2019s start with the simple task of creating a scatter plot:"),ol=m(),E(ho.$$.fragment),rl=m(),E(vo.$$.fragment),ll=m(),Ct=l("p"),pi=n("Le r\xE9sultat semble correct. Est-ce que cela fonctionne aussi pour une op\xE9ration "),Tr=l("code"),ci=n("pandas"),di=n(" ? Voyons si nous pouvons cr\xE9er un "),Mr=l("code"),mi=n("DataFrame"),fi=n(" \xE0 partir de deux tableaux :"),il=m(),E(go.$$.fragment),ul=m(),E(bo.$$.fragment),pl=m(),We=l("p"),_i=n("Bien, c\u2019est la bonne r\xE9ponse. Bien qu\u2019il ins\xE8re ensuite la colonne "),Ar=l("code"),hi=n("x"),vi=n(" \xE0 nouveau. Comme le nombre de "),Nr=l("em"),gi=n("tokens"),bi=n(" g\xE9n\xE9r\xE9s est limit\xE9, la boucle "),Lr=l("code"),$i=n("for"),qi=n(" suivante est coup\xE9e. Voyons si nous pouvons faire quelque chose d\u2019un peu plus complexe et faire en sorte que le mod\xE8le nous aide \xE0 utiliser l\u2019op\xE9ration "),Or=l("code"),ki=n("groupby"),ji=n(" :"),cl=m(),E($o.$$.fragment),dl=m(),E(qo.$$.fragment),ml=m(),Dt=l("p"),Ei=n("Pas mal, c\u2019est la bonne fa\xE7on de faire. Enfin, voyons si nous pouvons aussi l\u2019utiliser pour "),Sr=l("code"),yi=n("scikit-learn"),wi=n(" et utiliser un mod\xE8le "),Gr=l("em"),xi=n("Random Forest"),zi=n(" :"),fl=m(),E(ko.$$.fragment),_l=m(),E(jo.$$.fragment),hl=m(),xn.c(),ir=m(),de&&de.c(),ur=Ml(),this.h()},l(e){const d=kp('[data-svelte="svelte-1phssyn"]',document.head);r=i(d,"META",{name:!0,content:!0}),d.forEach(t),_=f(e),y(c.$$.fragment,e),v=f(e),k=i(e,"H1",{class:!0});var Co=u(k);$=i(Co,"A",{id:!0,class:!0,href:!0});var pr=u($);z=i(pr,"SPAN",{});var Fr=u(z);y(D.$$.fragment,Fr),Fr.forEach(t),pr.forEach(t),j=f(Co),P=i(Co,"SPAN",{});var Hr=u(P);N=a(Hr,"Entra\xEEner un mod\xE8le de langage causal \xE0 partir de z\xE9ro"),Hr.forEach(t),Co.forEach(t),M=f(e),T.l(e),H=f(e),F=i(e,"P",{});var xe=u(F);Y=a(xe,"Jusqu\u2019\xE0 pr\xE9sent, nous avons surtout r\xE9utilis\xE9 des mod\xE8les pr\xE9-entra\xEEn\xE9s et les avons "),R=i(xe,"EM",{});var cr=u(R);ee=a(cr,"finetun\xE9s"),cr.forEach(t),W=a(xe," sur de nouveaux cas d\u2019usage. Comme nous l\u2019avons vu dans le "),X=i(xe,"A",{href:!0});var dr=u(X);C=a(dr,"chapitre 1"),dr.forEach(t),se=a(xe,", ceci est commun\xE9ment appel\xE9 "),V=i(xe,"EM",{});var Ir=u(V);I=a(Ir,"apprentissage par transfert"),Ir.forEach(t),S=a(xe,", et il s\u2019agit d\u2019une strat\xE9gie tr\xE8s efficace pour appliquer les "),U=i(xe,"EM",{});var mr=u(U);ae=a(mr,"transformers"),mr.forEach(t),he=a(xe," \xE0 la plupart des applications du monde r\xE9el o\xF9 les donn\xE9es \xE9tiquet\xE9es sont rares. Dans ce chapitre, nous allons adopter une approche diff\xE9rente consistant \xE0 entra\xEEner un mod\xE8le compl\xE8tement nouveau \xE0 partir de z\xE9ro. C\u2019est une bonne d\xE9marche \xE0 adopter si vous avez beaucoup de donn\xE9es et qu\u2019elles sont tr\xE8s diff\xE9rentes des donn\xE9es de pr\xE9-entra\xEEnement utilis\xE9es par les mod\xE8les disponibles. Cependant, le pr\xE9-entra\xEEnement d\u2019un mod\xE8le de langue n\xE9cessite beaucoup plus de ressources informatiques que le simple "),J=i(xe,"EM",{});var Rr=u(J);ue=a(Rr,"finetuning"),Rr.forEach(t),ve=a(xe," d\u2019un mod\xE8le existant. Parmi les exemples o\xF9 il peut \xEAtre utile d\u2019entra\xEEner un nouveau mod\xE8le, citons les jeux de donn\xE9es constitu\xE9s de notes de musique, de s\xE9quences mol\xE9culaires telles que l\u2019ADN, ou de langages de programmation. Ces derniers ont r\xE9cemment gagn\xE9 en popularit\xE9 gr\xE2ce \xE0 des outils tels que TabNine et Copilot de GitHub (aliment\xE9s par le mod\xE8le Codex d\u2019OpenAI) qui peuvent g\xE9n\xE9rer de longues s\xE9quences de code. Cette t\xE2che de g\xE9n\xE9ration de texte est mieux abord\xE9e avec des mod\xE8les de langage autor\xE9gressifs ou causaux tels que le GPT-2."),xe.forEach(t),ge=f(e),Q=i(e,"P",{});var Me=u(Q);ze=a(Me,"Dans cette section, nous allons construire une version r\xE9duite d\u2019un mod\xE8le de g\xE9n\xE9ration de code Python. Nous nous concentrerons sur la compl\xE9tion d\u2019une ligne de code au lieu de fonctions ou de classes compl\xE8tes. Lorsque vous travaillez sur des projets de science des donn\xE9es en Python, vous \xEAtes souvent en contact avec les biblioth\xE8ques "),je=i(Me,"CODE",{});var fr=u(je);G=a(fr,"matplotlib"),fr.forEach(t),K=a(Me,", "),Ae=i(Me,"CODE",{});var Vi=u(Ae);nt=a(Vi,"seaborn"),Vi.forEach(t),at=a(Me,", "),Ne=i(Me,"CODE",{});var Ui=u(Ne);ns=a(Ui,"pandas"),Ui.forEach(t),ot=a(Me," et "),me=i(Me,"CODE",{});var Bi=u(me);rt=a(Bi,"scikit-learn"),Bi.forEach(t),lt=a(Me,". Lors de l\u2019utilisation de ces "),bs=i(Me,"EM",{});var Wi=u(bs);za=a(Wi,"frameworks"),Wi.forEach(t),Pa=a(Me,", il est fr\xE9quent d\u2019avoir besoin de rechercher des commandes sp\xE9cifiques. Il serait donc bien d\u2019utiliser un mod\xE8le pour compl\xE9ter ces appels pour nous."),Me.forEach(t),it=f(e),y($s.$$.fragment,e),zn=f(e),oe=i(e,"P",{});var vs=u(oe);Ca=a(vs,"Dans le "),ut=i(vs,"A",{href:!0});var Xi=u(ut);Ot=a(Xi,"chapitre 6"),Xi.forEach(t),Da=a(vs,", nous avons cr\xE9\xE9 un "),St=i(vs,"EM",{});var Ki=u(St);Gt=a(Ki,"tokenizer"),Ki.forEach(t),Ta=a(vs," efficace pour traiter du code Python. Nous avons besoin d\u2019un jeu de donn\xE9es \xE0 grande \xE9chelle pour pr\xE9-entra\xEEner un mod\xE8le. Ici, nous allons appliquer notre "),Ft=i(vs,"EM",{});var Ji=u(Ft);Ht=a(Ji,"tokenizer"),Ji.forEach(t),Ma=a(vs," \xE0 un corpus de code Python provenant des d\xE9p\xF4ts GitHub. Nous utiliserons ensuite l\u2019API "),It=i(vs,"CODE",{});var Yi=u(It);Rt=a(Yi,"Trainer"),Yi.forEach(t),Aa=a(vs," et \u{1F917} "),Vt=i(vs,"EM",{});var Zi=u(Vt);Pn=a(Zi,"Accelerate"),Zi.forEach(t),qs=a(vs," pour entra\xEEner le mod\xE8le. C\u2019est parti !"),vs.forEach(t),Ut=f(e),re=i(e,"IFRAME",{src:!0,frameborder:!0,height:!0,title:!0,class:!0,allow:!0,sandbox:!0}),u(re).forEach(t),te=f(e),be=i(e,"IFRAME",{src:!0,frameborder:!0,height:!0,title:!0,class:!0,allow:!0,sandbox:!0}),u(be).forEach(t),Dn=f(e),Le=i(e,"P",{});var _r=u(Le);Bt=a(_r,"Il s\u2019agit d\u2019une pr\xE9sentation du mod\xE8le qui a \xE9t\xE9 entra\xEEn\xE9 \xE0 l\u2019aide du code pr\xE9sent\xE9 dans cette section et qui a ensuit\xE9 \xE9t\xE9 t\xE9l\xE9charg\xE9 sur le "),Wt=i(_r,"EM",{});var Qi=u(Wt);La=a(Qi,"Hub"),Qi.forEach(t),Xt=a(_r,". Vous pouvez le trouver "),ks=i(_r,"A",{href:!0,rel:!0});var eu=u(ks);Oa=a(eu,"ici"),eu.forEach(t),Kt=a(_r,". Notez qu\u2019\xE9tant donn\xE9 qu\u2019il y a un certains al\xE9at dans la g\xE9n\xE9ration du texte, vous obtiendrez probablement un r\xE9sultat l\xE9g\xE8rement diff\xE9rent."),_r.forEach(t),Tn=f(e),Xe=i(e,"H2",{class:!0});var bl=u(Xe);Oe=i(bl,"A",{id:!0,class:!0,href:!0});var su=u(Oe);Jt=i(su,"SPAN",{});var tu=u(Jt);y(js.$$.fragment,tu),tu.forEach(t),su.forEach(t),Yt=f(bl),Zt=i(bl,"SPAN",{});var nu=u(Zt);Sa=a(nu,"Collecte des donn\xE9es"),nu.forEach(t),bl.forEach(t),Qt=f(e),le=i(e,"P",{});var ja=u(le);Mn=a(ja,"On peut trouver du code Python en abondance dans les d\xE9p\xF4ts de code tels que GitHub, que nous pouvons utiliser pour cr\xE9er un jeu de donn\xE9es en r\xE9cup\xE9rant chaque d\xE9p\xF4t Python. C\u2019est l\u2019approche adopt\xE9e dans le "),Pe=i(ja,"A",{href:!0,rel:!0});var Pi=u(Pe);Ga=a(Pi,"livre "),pt=i(Pi,"EM",{});var au=u(pt);Se=a(au,"Natural Language Processing with Transformers"),au.forEach(t),Pi.forEach(t),en=a(ja," pour pr\xE9-entra\xEEner un grand GPT-2. En utilisant un d\xE9p\xF4t GitHub d\u2019environ 180 Go contenant approximativement 20 millions de fichiers Python, les auteurs du livre ont construit un jeu de donn\xE9es appel\xE9 "),sn=i(ja,"CODE",{});var ou=u(sn);Fa=a(ou,"codeparrot"),ou.forEach(t),tn=a(ja," qu\u2019ils ont ensuite partag\xE9 sur le "),Es=i(ja,"A",{href:!0,rel:!0});var ru=u(Es);nn=i(ru,"EM",{});var lu=u(nn);an=a(lu,"Hub"),lu.forEach(t),ru.forEach(t),Ha=a(ja,"."),ja.forEach(t),on=f(e),ne=i(e,"P",{});var Ea=u(ne);Ia=a(Ea,"Cependant, entra\xEEner sur l\u2019ensemble du corpus prend beaucoup de temps et demande beaucoup de ressources de calculs. Dans notre cas, nous n\u2019avons besoin que du sous-ensemble du jeu de donn\xE9es qui est relatif aux codes portant sur la science des donn\xE9es. Commen\xE7ons donc par filtrer le jeu de donn\xE9es "),ys=i(Ea,"CODE",{});var iu=u(ys);Ra=a(iu,"codeparrot"),iu.forEach(t),Va=a(Ea," en ne gardant que les fichiers incluant l\u2019une des biblioth\xE8ques de science des donn\xE9es \xE9num\xE9r\xE9es pr\xE9c\xE9demment. En raison de la taille du jeu de donn\xE9es, nous voulons \xE9viter de le t\xE9l\xE9charger. Nous utiliserons donc la fonctionnalit\xE9 de "),ws=i(Ea,"EM",{});var uu=u(ws);Ua=a(uu,"streaming"),uu.forEach(t),Ba=a(Ea," de \u{1F917} "),ct=i(Ea,"EM",{});var pu=u(ct);xs=a(pu,"Datasets"),pu.forEach(t),An=a(Ea," afin de le filtrer \xE0 la vol\xE9e. Pour nous aider \xE0 filtrer les \xE9chantillons de code utilisant les biblioth\xE8ques que nous avons mentionn\xE9es pr\xE9c\xE9demment, nous utilisons la fonction suivante :"),Ea.forEach(t),Ke=f(e),y(zs.$$.fragment,e),dt=f(e),mt=i(e,"P",{});var cu=u(mt);Wa=a(cu,"Testons-le sur deux exemples :"),cu.forEach(t),rn=f(e),y(Ce.$$.fragment,e),ln=f(e),y(Ee.$$.fragment,e),Nn=f(e),Ge=i(e,"P",{});var $l=u(Ge);Xa=a($l,"Nous pouvons l\u2019utiliser pour cr\xE9er une fonction qui va "),un=i($l,"EM",{});var du=u(un);Ln=a(du,"streamer"),du.forEach(t),Ps=a($l," le jeu de donner et filtrer les \xE9l\xE9ments que nous voulons :"),$l.forEach(t),pn=f(e),y(fe.$$.fragment,e),On=f(e),as=i(e,"P",{});var mu=u(as);Ka=a(mu,"Ensuite, nous pouvons simplement appliquer cette fonction :"),mu.forEach(t),Sn=f(e),y(Fe.$$.fragment,e),Gn=f(e),y(Cs.$$.fragment,e),cn=f(e),He=i(e,"P",{});var fu=u(He);Fn=a(fu,"Cela nous laisse avec environ 3 % du jeu de donn\xE9es original, ce qui est tout de m\xEAme assez important puisqu\u2019il fait 6 Go et se compose de 600 000 scripts Python !"),fu.forEach(t),Ds=f(e),os=i(e,"P",{});var ql=u(os);Hn=a(ql,"Le filtrage peut prendre de 2 \xE0 3 heures, selon votre machine et votre bande passante. Si vous ne voulez pas passer par ce long processus, nous fournissons sur le "),Je=i(ql,"EM",{});var _u=u(Je);In=a(_u,"Hub"),_u.forEach(t),ft=a(ql," le jeu de donn\xE9es filtr\xE9 pour que vous puissiez le t\xE9l\xE9charger :"),ql.forEach(t),Rn=f(e),y(rs.$$.fragment,e),ls=f(e),y(is.$$.fragment,e),us=f(e),y(Ye.$$.fragment,e),$e=f(e),_t=i(e,"P",{});var hu=u(_t);dn=a(hu,"Examinons un exemple tir\xE9 du jeu de donn\xE9es. Nous ne montrerons que les 200 premiers caract\xE8res de chaque champ :"),hu.forEach(t),Vn=f(e),y(Ts.$$.fragment,e),ht=f(e),y(Ms.$$.fragment,e),Un=f(e),Ie=i(e,"P",{});var kl=u(Ie);Ja=a(kl,"Nous pouvons voir que le champ "),mn=i(kl,"CODE",{});var vu=u(mn);Bn=a(vu,"content"),vu.forEach(t),As=a(kl," contient le code sur lequel nous voulons que notre mod\xE8le s\u2019entra\xEEne. Maintenant que nous avons un jeu de donn\xE9es, nous devons pr\xE9parer les textes afin qu\u2019ils soient dans un format appropri\xE9 pour le pr\xE9-entra\xEEnement."),kl.forEach(t),fn=f(e),Z=i(e,"H2",{class:!0});var jl=u(Z);ps=i(jl,"A",{id:!0,class:!0,href:!0});var gu=u(ps);Ns=i(gu,"SPAN",{});var bu=u(Ns);y(Ls.$$.fragment,bu),bu.forEach(t),gu.forEach(t),Ya=f(jl),Os=i(jl,"SPAN",{});var $u=u(Os);Za=a($u,"Pr\xE9paration du jeu de donn\xE9es"),$u.forEach(t),jl.forEach(t),Wn=f(e),y(Ze.$$.fragment,e),Xn=f(e),cs=i(e,"P",{});var El=u(cs);_n=a(El,"La premi\xE8re \xE9tape est de tokeniser les donn\xE9es afin de pouvoir les utiliser pour l\u2019entra\xEEnement. Puisque notre objectif est d\u2019autocompl\xE9ter de courts appels de fonctions, nous pouvons garder la taille du contexte relativement petite. L\u2019avantage est que nous pouvons entra\xEEner le mod\xE8le beaucoup plus rapidement et qu\u2019il n\xE9cessite beaucoup moins de m\xE9moire. Si c\u2019est important pour votre application d\u2019avoir davantage de contexte (par exemple, si vous voulez que le mod\xE8le \xE9crive des tests unitaires bas\xE9s sur un fichier avec la d\xE9finition de la fonction), assurez-vous d\u2019augmenter ce nombre. Gardez n\xE9anmoins \xE0 l\u2019esprit que cela s\u2019accompagne d\u2019une plus grande empreinte m\xE9moire du GPU. Pour l\u2019instant, fixons la taille du contexte \xE0 128 "),hn=i(El,"EM",{});var qu=u(hn);Qa=a(qu,"tokens"),qu.forEach(t),vn=a(El,", par opposition aux 1 024 ou 2 048 utilis\xE9s respectivement dans le GPT-2 et le GPT-3."),El.forEach(t),Kn=f(e),ie=i(e,"P",{});var gs=u(ie);Jn=a(gs,"La plupart des documents contiennent beaucoup plus de 128 "),Qe=i(gs,"EM",{});var ku=u(Qe);Yn=a(ku,"tokens"),ku.forEach(t),Ss=a(gs,", donc le fait de tronquer les entr\xE9es \xE0 la longueur maximale \xE9liminerait une grande partie de notre jeu de donn\xE9es. A la place, nous allons utiliser l\u2019option "),vt=i(gs,"CODE",{});var ju=u(vt);gt=a(ju,"return_overflowing_tokens"),ju.forEach(t),eo=a(gs," pour tokeniser l\u2019entr\xE9e enti\xE8re et la diviser en plusieurs morceaux, comme nous l\u2019avons fait dans le "),Gs=i(gs,"A",{href:!0});var Eu=u(Gs);Fs=a(Eu,"chapitre 6"),Eu.forEach(t),Zn=a(gs,". Nous utiliserons \xE9galement l\u2019option "),ye=i(gs,"CODE",{});var yu=u(ye);so=a(yu,"return_length"),yu.forEach(t),gn=a(gs," pour retourner automatiquement la longueur de chaque morceau cr\xE9\xE9. Souvent, le dernier morceau est plus petit que la taille du contexte et nous nous en d\xE9barrasserons pour \xE9viter les probl\xE8mes de "),bn=i(gs,"EM",{});var wu=u(bn);to=a(wu,"padding"),wu.forEach(t),$n=a(gs,". Nous n\u2019en avons pas vraiment besoin puisque de toute fa\xE7on nous avons beaucoup de donn\xE9es."),gs.forEach(t),Qn=f(e),es=i(e,"DIV",{class:!0});var yl=u(es);ds=i(yl,"IMG",{class:!0,src:!0,alt:!0}),no=f(yl),ms=i(yl,"IMG",{class:!0,src:!0,alt:!0}),yl.forEach(t),kn=f(e),Re=i(e,"P",{});var xu=u(Re);ea=a(xu,"Voyons comment cela fonctionne en examinant les deux premiers exemples :"),xu.forEach(t),ss=f(e),y(Hs.$$.fragment,e),$t=f(e),y(Is.$$.fragment,e),sa=f(e),De=i(e,"P",{});var hr=u(De);Rs=a(hr,"Nous pouvons voir que nous obtenons 34 morceaux \xE0 partir de ces deux exemples. En regardant leurs longueurs, nous pouvons voir qu\u2019ils se terminent avec moins de 128 "),qt=i(hr,"EM",{});var zu=u(qt);kt=a(zu,"tokens"),zu.forEach(t),ao=a(hr," (117 et 41, respectivement). Ils ne repr\xE9sentent qu\u2019une petite fraction du total des morceaux que nous avons (2/34), donc nous pouvons les jeter sans risque. Avec le champ "),jt=i(hr,"CODE",{});var Pu=u(jt);Vs=a(Pu,"overflow_to_sample_mapping"),Pu.forEach(t),ta=a(hr,", nous pouvons aussi reconstruire quels morceaux appartenaient \xE0 quels \xE9chantillons d\u2019entr\xE9e."),hr.forEach(t),fs=f(e),pe=i(e,"P",{});var Tt=u(pe);o=a(Tt,"Avec cette op\xE9ration, nous utilisons une fonctionnalit\xE9 pratique de la fonction "),q=i(Tt,"CODE",{});var Cu=u(q);Do=a(Cu,"Dataset.map()"),Cu.forEach(t),To=a(Tt," de \u{1F917} "),jn=i(Tt,"EM",{});var Du=u(jn);Mo=a(Du,"Datasets"),Du.forEach(t),Et=a(Tt,". En effet, celle-ci ne n\xE9cessite pas une correspondance un \xE0 un comme nous l\u2019avons vu dans la "),En=i(Tt,"A",{href:!0});var Tu=u(En);Ao=a(Tu,"section 3"),Tu.forEach(t),B=a(Tt,". Nous pouvons cr\xE9er des batchs avec plus ou moins d\u2019\xE9l\xE9ments que le batch d\u2019entr\xE9e. C\u2019est utile lorsque l\u2019on effectue des op\xE9rations telles que l\u2019augmentation ou le filtrage des donn\xE9es qui modifient le nombre d\u2019\xE9l\xE9ments. Dans notre cas, lors de la tokenisation de chaque \xE9l\xE9ment en morceaux de longeur de la taille de contexte sp\xE9cifi\xE9e, nous cr\xE9ons de nombreux \xE9chantillons de chaque document. Nous devons juste nous assurer de supprimer les colonnes existantes, car elles ont une taille conflictuelle. Si nous voulions les garder, nous pourrions les r\xE9p\xE9ter de mani\xE8re appropri\xE9e et les retourner dans l\u2019appel "),na=i(Tt,"CODE",{});var Mu=u(na);No=a(Mu,"Dataset.map()"),Mu.forEach(t),Lo=a(Tt," :"),Tt.forEach(t),oo=f(e),y(yt.$$.fragment,e),ro=f(e),y(wt.$$.fragment,e),lo=f(e),qe=i(e,"P",{});var Mt=u(qe);Oo=a(Mt,"Nous avons maintenant 16,7 millions d\u2019exemples avec 128 "),aa=i(Mt,"EM",{});var Au=u(aa);So=a(Au,"tokens"),Au.forEach(t),Go=a(Mt," chacun, ce qui correspond \xE0 environ 2,1 milliards de "),oa=i(Mt,"EM",{});var Nu=u(oa);Fo=a(Nu,"tokens"),Nu.forEach(t),_e=a(Mt," au total. A titre de comparaison, les mod\xE8les GPT-3 et Codex d\u2019OpenAI sont entra\xEEn\xE9s sur 300 et 100 milliards de "),ra=i(Mt,"EM",{});var Lu=u(ra);Ho=a(Lu,"tokens"),Lu.forEach(t),Io=a(Mt,", respectivement. Les mod\xE8les Codex \xE9tant initialis\xE9s \xE0 partir des "),la=i(Mt,"EM",{});var Ou=u(la);Ro=a(Ou,"checkpoints"),Ou.forEach(t),Vo=a(Mt," GPT-3. Notre objectif dans cette section n\u2019est pas de rivaliser avec ces mod\xE8les, qui peuvent g\xE9n\xE9rer des textes longs et coh\xE9rents, mais de cr\xE9er une version r\xE9duite fournissant une fonction d\u2019autocompl\xE9tion rapide."),Mt.forEach(t),io=f(e),ts=i(e,"P",{});var Su=u(ts);Uo=a(Su,"Maintenant que le jeu de donn\xE9es est pr\xEAt, configurons le mod\xE8le !"),Su.forEach(t),uo=f(e),y(Us.$$.fragment,e),Bs=f(e),_s=i(e,"H2",{class:!0});var wl=u(_s);Ws=i(wl,"A",{id:!0,class:!0,href:!0});var Gu=u(Ws);xt=i(Gu,"SPAN",{});var Fu=u(xt);y(zt.$$.fragment,Fu),Fu.forEach(t),Gu.forEach(t),ia=f(wl),ua=i(wl,"SPAN",{});var Hu=u(ua);Pt=a(Hu,"Initialisation d'un nouveau mod\xE8le"),Hu.forEach(t),wl.forEach(t),po=f(e),ke=i(e,"P",{});var At=u(ke);Bo=a(At,"Notre premi\xE8re \xE9tape consiste \xE0 initialiser un GPT-2. Pour notre mod\xE8le, nous utiliserons la m\xEAme configuration que pour le petit mod\xE8le GPT-2. Ainsi nous chargeons la configuration pr\xE9-entra\xEEn\xE9e, nous nous assurons que la taille du "),pa=i(At,"EM",{});var Iu=u(pa);hs=a(Iu,"tokenizer"),Iu.forEach(t),Wo=a(At," correspond \xE0 la taille du vocabulaire du mod\xE8le et nous passons les identifiants des "),ca=i(At,"EM",{});var Ru=u(ca);Xo=a(Ru,"tokens"),Ru.forEach(t),we=f(At),da=i(At,"CODE",{});var Vu=u(da);Ko=a(Vu,"bos"),Vu.forEach(t),Jo=a(At," et "),ma=i(At,"CODE",{});var Uu=u(ma);Yo=a(Uu,"eos"),Uu.forEach(t),Zo=a(At," (d\xE9but et fin de s\xE9quence) :"),At.forEach(t),Xs=f(e),Ue.l(e),yn=f(e),Te=i(e,"P",{});var vr=u(Te);Qo=a(vr,"Notre mod\xE8le comporte 124 millions de param\xE8tres que nous devrons r\xE9gler. Avant de commencer l\u2019entra\xEEnement, nous devons configurer un assembleur de donn\xE9es qui se chargera de cr\xE9er les batchs. Nous pouvons utiliser le assembleur "),fa=i(vr,"CODE",{});var Bu=u(fa);Al=a(Bu,"DataCollatorForLanguageModeling"),Bu.forEach(t),Nl=a(vr,", qui est con\xE7u sp\xE9cifiquement pour la mod\xE9lisation du langage (comme son nom le sugg\xE8re subtilement). En plus de l\u2019empilage et du rembourrage des batchs, il s\u2019occupe aussi de la cr\xE9ation des \xE9tiquettes du mod\xE8le de langage. Dans la mod\xE9lisation causale du langage, les entr\xE9es servent aussi d\u2019\xE9tiquettes (juste d\xE9cal\xE9es d\u2019un \xE9l\xE9ment) et que le assembleur de donn\xE9es cr\xE9e \xE0 la vol\xE9e pendant l\u2019entra\xEEnement pour ne pas avoir \xE0 dupliquer les "),qr=i(vr,"CODE",{});var Wu=u(qr);Ll=a(Wu,"input_ids"),Wu.forEach(t),Ol=a(vr,"."),vr.forEach(t),Vr=f(e),Be=i(e,"P",{});var Nt=u(Be);Sl=a(Nt,"Notez que "),kr=i(Nt,"CODE",{});var Xu=u(kr);Gl=a(Xu,"DataCollatorForLanguageModeling"),Xu.forEach(t),Fl=a(Nt," supporte \xE0 la fois la mod\xE9lisation du langage masqu\xE9 (MLM pour "),jr=i(Nt,"EM",{});var Ku=u(jr);Hl=a(Ku,"masked language modeling"),Ku.forEach(t),Il=a(Nt,") et la mod\xE9lisation du langage causal (CLM pour "),Er=i(Nt,"EM",{});var Ju=u(Er);Rl=a(Ju,"causal language modeling"),Ju.forEach(t),Vl=a(Nt,"). Par d\xE9faut, il pr\xE9pare les donn\xE9es pour la MLM mais nous pouvons passer \xE0 la CLM en d\xE9finissant l\u2019argument "),yr=i(Nt,"CODE",{});var Yu=u(yr);Ul=a(Yu,"mlm=False"),Yu.forEach(t),Bl=a(Nt," :"),Nt.forEach(t),Ur=f(e),Js.l(e),er=f(e),sr=i(e,"P",{});var Zu=u(sr);Wl=a(Zu,"Prenons un exemple :"),Zu.forEach(t),Br=f(e),y(co.$$.fragment,e),Wr=f(e),Zs.l(e),tr=f(e),nr=i(e,"P",{});var Qu=u(nr);Xl=a(Qu,"Nous pouvons voir que les exemples ont \xE9t\xE9 empil\xE9s et que tous les tenseurs ont la m\xEAme forme."),Qu.forEach(t),Xr=f(e),ce&&ce.l(e),ar=f(e),y(_a.$$.fragment,e),Kr=f(e),ha=i(e,"P",{});var xl=u(ha);Kl=a(xl,"Nous avons maintenant tout ce qu\u2019il faut pour entra\xEEner notre mod\xE8le. Ce n\u2019\xE9tait pas si compliqu\xE9 ! Avant de commencer l\u2019entra\xEEnement, nous devons nous connecter \xE0 Hugging Face. Si vous travaillez dans un "),wr=i(xl,"EM",{});var ep=u(wr);Jl=a(ep,"notebook"),ep.forEach(t),Yl=a(xl,", vous pouvez le faire avec la fonction utilitaire suivante :"),xl.forEach(t),Jr=f(e),y(mo.$$.fragment,e),Yr=f(e),va=i(e,"P",{});var zl=u(va);Zl=a(zl,"Cela affichera un "),xr=i(zl,"EM",{});var sp=u(xr);Ql=a(sp,"widget"),sp.forEach(t),ei=a(zl," o\xF9 vous pourrez entrer vos identifiants de connexion \xE0 Hugging Face."),zl.forEach(t),Zr=f(e),ga=i(e,"P",{});var Pl=u(ga);si=a(Pl,"Si vous ne travaillez pas dans un "),zr=i(Pl,"EM",{});var tp=u(zr);ti=a(tp,"notebook"),tp.forEach(t),ni=a(Pl,", tapez simplement la ligne suivante dans votre terminal :"),Pl.forEach(t),Qr=f(e),y(fo.$$.fragment,e),el=f(e),et.l(e),or=f(e),y(ba.$$.fragment,e),sl=f(e),y($a.$$.fragment,e),tl=f(e),wn=i(e,"H2",{class:!0});var Cl=u(wn);qa=i(Cl,"A",{id:!0,class:!0,href:!0});var np=u(qa);Pr=i(np,"SPAN",{});var ap=u(Pr);y(_o.$$.fragment,ap),ap.forEach(t),np.forEach(t),ai=f(Cl),Cr=i(Cl,"SPAN",{});var op=u(Cr);oi=a(op,"G\xE9n\xE9ration de code avec le pipeline"),op.forEach(t),Cl.forEach(t),nl=f(e),ka=i(e,"P",{});var Dl=u(ka);ri=a(Dl,"C\u2019est maintenant le moment de v\xE9rit\xE9 : voyons comment le mod\xE8le entra\xEEn\xE9 fonctionne r\xE9ellement ! Nous pouvons voir dans les logs que la perte a diminu\xE9 r\xE9guli\xE8rement, mais pour mettre le mod\xE8le \xE0 l\u2019\xE9preuve, regardons comment il fonctionne sur certains messages. Pour ce faire, nous allons envelopper le mod\xE8le dans un "),Dr=i(Dl,"CODE",{});var rp=u(Dr);li=a(rp,"pipeline"),rp.forEach(t),ii=a(Dl," de g\xE9n\xE9ration de texte et, s\u2019il y en a un de disponible, utiliser un GPU pour avoir des g\xE9n\xE9rations rapidement :"),Dl.forEach(t),al=f(e),tt.l(e),rr=f(e),lr=i(e,"P",{});var lp=u(lr);ui=a(lp,"Let\u2019s start with the simple task of creating a scatter plot:"),lp.forEach(t),ol=f(e),y(ho.$$.fragment,e),rl=f(e),y(vo.$$.fragment,e),ll=f(e),Ct=i(e,"P",{});var gr=u(Ct);pi=a(gr,"Le r\xE9sultat semble correct. Est-ce que cela fonctionne aussi pour une op\xE9ration "),Tr=i(gr,"CODE",{});var ip=u(Tr);ci=a(ip,"pandas"),ip.forEach(t),di=a(gr," ? Voyons si nous pouvons cr\xE9er un "),Mr=i(gr,"CODE",{});var up=u(Mr);mi=a(up,"DataFrame"),up.forEach(t),fi=a(gr," \xE0 partir de deux tableaux :"),gr.forEach(t),il=f(e),y(go.$$.fragment,e),ul=f(e),y(bo.$$.fragment,e),pl=f(e),We=i(e,"P",{});var Lt=u(We);_i=a(Lt,"Bien, c\u2019est la bonne r\xE9ponse. Bien qu\u2019il ins\xE8re ensuite la colonne "),Ar=i(Lt,"CODE",{});var pp=u(Ar);hi=a(pp,"x"),pp.forEach(t),vi=a(Lt," \xE0 nouveau. Comme le nombre de "),Nr=i(Lt,"EM",{});var cp=u(Nr);gi=a(cp,"tokens"),cp.forEach(t),bi=a(Lt," g\xE9n\xE9r\xE9s est limit\xE9, la boucle "),Lr=i(Lt,"CODE",{});var dp=u(Lr);$i=a(dp,"for"),dp.forEach(t),qi=a(Lt," suivante est coup\xE9e. Voyons si nous pouvons faire quelque chose d\u2019un peu plus complexe et faire en sorte que le mod\xE8le nous aide \xE0 utiliser l\u2019op\xE9ration "),Or=i(Lt,"CODE",{});var mp=u(Or);ki=a(mp,"groupby"),mp.forEach(t),ji=a(Lt," :"),Lt.forEach(t),cl=f(e),y($o.$$.fragment,e),dl=f(e),y(qo.$$.fragment,e),ml=f(e),Dt=i(e,"P",{});var br=u(Dt);Ei=a(br,"Pas mal, c\u2019est la bonne fa\xE7on de faire. Enfin, voyons si nous pouvons aussi l\u2019utiliser pour "),Sr=i(br,"CODE",{});var fp=u(Sr);yi=a(fp,"scikit-learn"),fp.forEach(t),wi=a(br," et utiliser un mod\xE8le "),Gr=i(br,"EM",{});var _p=u(Gr);xi=a(_p,"Random Forest"),_p.forEach(t),zi=a(br," :"),br.forEach(t),fl=f(e),y(ko.$$.fragment,e),_l=f(e),y(jo.$$.fragment,e),hl=f(e),xn.l(e),ir=f(e),de&&de.l(e),ur=Ml(),this.h()},h(){A(r,"name","hf:doc:metadata"),A(r,"content",JSON.stringify(Jp)),A($,"id","entraner-un-modle-de-langage-causal-partir-de-zro"),A($,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),A($,"href","#entraner-un-modle-de-langage-causal-partir-de-zro"),A(k,"class","relative group"),A(X,"href","/course/fr/chapter1"),A(ut,"href","/course/fr/chapter6"),Tl(re.src,Na="https://hf.space/gradioiframe/course-demos/codeparrot-ds/+")||A(re,"src",Na),A(re,"frameborder","0"),A(re,"height","300"),A(re,"title","Gradio app"),A(re,"class","block dark:hidden container p-0 flex-grow space-iframe"),A(re,"allow","accelerometer; ambient-light-sensor; autoplay; battery; camera; document-domain; encrypted-media; fullscreen; geolocation; gyroscope; layout-animations; legacy-image-formats; magnetometer; microphone; midi; oversized-images; payment; picture-in-picture; publickey-credentials-get; sync-xhr; usb; vr ; wake-lock; xr-spatial-tracking"),A(re,"sandbox","allow-forms allow-modals allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-downloads"),Tl(be.src,Cn="https://hf.space/gradioiframe/course-demos/codeparrot-ds-darkmode/+")||A(be,"src",Cn),A(be,"frameborder","0"),A(be,"height","300"),A(be,"title","Gradio app"),A(be,"class","hidden dark:block container p-0 flex-grow space-iframe"),A(be,"allow","accelerometer; ambient-light-sensor; autoplay; battery; camera; document-domain; encrypted-media; fullscreen; geolocation; gyroscope; layout-animations; legacy-image-formats; magnetometer; microphone; midi; oversized-images; payment; picture-in-picture; publickey-credentials-get; sync-xhr; usb; vr ; wake-lock; xr-spatial-tracking"),A(be,"sandbox","allow-forms allow-modals allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts allow-downloads"),A(ks,"href","https://huggingface.co/huggingface-course/codeparrot-ds?text=plt.imshow%28"),A(ks,"rel","nofollow"),A(Oe,"id","collecte-des-donnes"),A(Oe,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),A(Oe,"href","#collecte-des-donnes"),A(Xe,"class","relative group"),A(Pe,"href","https://learning.oreilly.com/library/view/natural-language-processing/9781098103231/"),A(Pe,"rel","nofollow"),A(Es,"href","https://huggingface.co/datasets/transformersbook/codeparrot"),A(Es,"rel","nofollow"),A(ps,"id","prparation-du-jeu-de-donnes"),A(ps,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),A(ps,"href","#prparation-du-jeu-de-donnes"),A(Z,"class","relative group"),A(Gs,"href","/course/fr/chapter6/4"),A(ds,"class","block dark:hidden"),Tl(ds.src,qn="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter7/chunking_texts.svg")||A(ds,"src",qn),A(ds,"alt","Chunking a large texts in several pieces."),A(ms,"class","hidden dark:block"),Tl(ms.src,bt="https://huggingface.co/datasets/huggingface-course/documentation-images/resolve/main/en/chapter7/chunking_texts-dark.svg")||A(ms,"src",bt),A(ms,"alt","Chunking a large texts in several pieces."),A(es,"class","flex justify-center"),A(En,"href","/course/fr/chapter7/3"),A(Ws,"id","initialisation-dun-nouveau-modle"),A(Ws,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),A(Ws,"href","#initialisation-dun-nouveau-modle"),A(_s,"class","relative group"),A(qa,"id","gnration-de-code-avec-le-pipeline"),A(qa,"class","header-link block pr-1.5 text-lg no-hover:hidden with-hover:absolute with-hover:p-1.5 with-hover:opacity-0 with-hover:group-hover:opacity-100 with-hover:right-full"),A(qa,"href","#gnration-de-code-avec-le-pipeline"),A(wn,"class","relative group")},m(e,d){s(document.head,r),p(e,_,d),w(c,e,d),p(e,v,d),p(e,k,d),s(k,$),s($,z),w(D,z,null),s(k,j),s(k,P),s(P,N),p(e,M,d),Eo[h].m(e,d),p(e,H,d),p(e,F,d),s(F,Y),s(F,R),s(R,ee),s(F,W),s(F,X),s(X,C),s(F,se),s(F,V),s(V,I),s(F,S),s(F,U),s(U,ae),s(F,he),s(F,J),s(J,ue),s(F,ve),p(e,ge,d),p(e,Q,d),s(Q,ze),s(Q,je),s(je,G),s(Q,K),s(Q,Ae),s(Ae,nt),s(Q,at),s(Q,Ne),s(Ne,ns),s(Q,ot),s(Q,me),s(me,rt),s(Q,lt),s(Q,bs),s(bs,za),s(Q,Pa),p(e,it,d),w($s,e,d),p(e,zn,d),p(e,oe,d),s(oe,Ca),s(oe,ut),s(ut,Ot),s(oe,Da),s(oe,St),s(St,Gt),s(oe,Ta),s(oe,Ft),s(Ft,Ht),s(oe,Ma),s(oe,It),s(It,Rt),s(oe,Aa),s(oe,Vt),s(Vt,Pn),s(oe,qs),p(e,Ut,d),p(e,re,d),p(e,te,d),p(e,be,d),p(e,Dn,d),p(e,Le,d),s(Le,Bt),s(Le,Wt),s(Wt,La),s(Le,Xt),s(Le,ks),s(ks,Oa),s(Le,Kt),p(e,Tn,d),p(e,Xe,d),s(Xe,Oe),s(Oe,Jt),w(js,Jt,null),s(Xe,Yt),s(Xe,Zt),s(Zt,Sa),p(e,Qt,d),p(e,le,d),s(le,Mn),s(le,Pe),s(Pe,Ga),s(Pe,pt),s(pt,Se),s(le,en),s(le,sn),s(sn,Fa),s(le,tn),s(le,Es),s(Es,nn),s(nn,an),s(le,Ha),p(e,on,d),p(e,ne,d),s(ne,Ia),s(ne,ys),s(ys,Ra),s(ne,Va),s(ne,ws),s(ws,Ua),s(ne,Ba),s(ne,ct),s(ct,xs),s(ne,An),p(e,Ke,d),w(zs,e,d),p(e,dt,d),p(e,mt,d),s(mt,Wa),p(e,rn,d),w(Ce,e,d),p(e,ln,d),w(Ee,e,d),p(e,Nn,d),p(e,Ge,d),s(Ge,Xa),s(Ge,un),s(un,Ln),s(Ge,Ps),p(e,pn,d),w(fe,e,d),p(e,On,d),p(e,as,d),s(as,Ka),p(e,Sn,d),w(Fe,e,d),p(e,Gn,d),w(Cs,e,d),p(e,cn,d),p(e,He,d),s(He,Fn),p(e,Ds,d),p(e,os,d),s(os,Hn),s(os,Je),s(Je,In),s(os,ft),p(e,Rn,d),w(rs,e,d),p(e,ls,d),w(is,e,d),p(e,us,d),w(Ye,e,d),p(e,$e,d),p(e,_t,d),s(_t,dn),p(e,Vn,d),w(Ts,e,d),p(e,ht,d),w(Ms,e,d),p(e,Un,d),p(e,Ie,d),s(Ie,Ja),s(Ie,mn),s(mn,Bn),s(Ie,As),p(e,fn,d),p(e,Z,d),s(Z,ps),s(ps,Ns),w(Ls,Ns,null),s(Z,Ya),s(Z,Os),s(Os,Za),p(e,Wn,d),w(Ze,e,d),p(e,Xn,d),p(e,cs,d),s(cs,_n),s(cs,hn),s(hn,Qa),s(cs,vn),p(e,Kn,d),p(e,ie,d),s(ie,Jn),s(ie,Qe),s(Qe,Yn),s(ie,Ss),s(ie,vt),s(vt,gt),s(ie,eo),s(ie,Gs),s(Gs,Fs),s(ie,Zn),s(ie,ye),s(ye,so),s(ie,gn),s(ie,bn),s(bn,to),s(ie,$n),p(e,Qn,d),p(e,es,d),s(es,ds),s(es,no),s(es,ms),p(e,kn,d),p(e,Re,d),s(Re,ea),p(e,ss,d),w(Hs,e,d),p(e,$t,d),w(Is,e,d),p(e,sa,d),p(e,De,d),s(De,Rs),s(De,qt),s(qt,kt),s(De,ao),s(De,jt),s(jt,Vs),s(De,ta),p(e,fs,d),p(e,pe,d),s(pe,o),s(pe,q),s(q,Do),s(pe,To),s(pe,jn),s(jn,Mo),s(pe,Et),s(pe,En),s(En,Ao),s(pe,B),s(pe,na),s(na,No),s(pe,Lo),p(e,oo,d),w(yt,e,d),p(e,ro,d),w(wt,e,d),p(e,lo,d),p(e,qe,d),s(qe,Oo),s(qe,aa),s(aa,So),s(qe,Go),s(qe,oa),s(oa,Fo),s(qe,_e),s(qe,ra),s(ra,Ho),s(qe,Io),s(qe,la),s(la,Ro),s(qe,Vo),p(e,io,d),p(e,ts,d),s(ts,Uo),p(e,uo,d),w(Us,e,d),p(e,Bs,d),p(e,_s,d),s(_s,Ws),s(Ws,xt),w(zt,xt,null),s(_s,ia),s(_s,ua),s(ua,Pt),p(e,po,d),p(e,ke,d),s(ke,Bo),s(ke,pa),s(pa,hs),s(ke,Wo),s(ke,ca),s(ca,Xo),s(ke,we),s(ke,da),s(da,Ko),s(ke,Jo),s(ke,ma),s(ma,Yo),s(ke,Zo),p(e,Xs,d),yo[Ve].m(e,d),p(e,yn,d),p(e,Te,d),s(Te,Qo),s(Te,fa),s(fa,Al),s(Te,Nl),s(Te,qr),s(qr,Ll),s(Te,Ol),p(e,Vr,d),p(e,Be,d),s(Be,Sl),s(Be,kr),s(kr,Gl),s(Be,Fl),s(Be,jr),s(jr,Hl),s(Be,Il),s(Be,Er),s(Er,Rl),s(Be,Vl),s(Be,yr),s(yr,Ul),s(Be,Bl),p(e,Ur,d),wo[Ks].m(e,d),p(e,er,d),p(e,sr,d),s(sr,Wl),p(e,Br,d),w(co,e,d),p(e,Wr,d),xo[Ys].m(e,d),p(e,tr,d),p(e,nr,d),s(nr,Xl),p(e,Xr,d),ce&&ce.m(e,d),p(e,ar,d),w(_a,e,d),p(e,Kr,d),p(e,ha,d),s(ha,Kl),s(ha,wr),s(wr,Jl),s(ha,Yl),p(e,Jr,d),w(mo,e,d),p(e,Yr,d),p(e,va,d),s(va,Zl),s(va,xr),s(xr,Ql),s(va,ei),p(e,Zr,d),p(e,ga,d),s(ga,si),s(ga,zr),s(zr,ti),s(ga,ni),p(e,Qr,d),w(fo,e,d),p(e,el,d),zo[Qs].m(e,d),p(e,or,d),w(ba,e,d),p(e,sl,d),w($a,e,d),p(e,tl,d),p(e,wn,d),s(wn,qa),s(qa,Pr),w(_o,Pr,null),s(wn,ai),s(wn,Cr),s(Cr,oi),p(e,nl,d),p(e,ka,d),s(ka,ri),s(ka,Dr),s(Dr,li),s(ka,ii),p(e,al,d),Po[st].m(e,d),p(e,rr,d),p(e,lr,d),s(lr,ui),p(e,ol,d),w(ho,e,d),p(e,rl,d),w(vo,e,d),p(e,ll,d),p(e,Ct,d),s(Ct,pi),s(Ct,Tr),s(Tr,ci),s(Ct,di),s(Ct,Mr),s(Mr,mi),s(Ct,fi),p(e,il,d),w(go,e,d),p(e,ul,d),w(bo,e,d),p(e,pl,d),p(e,We,d),s(We,_i),s(We,Ar),s(Ar,hi),s(We,vi),s(We,Nr),s(Nr,gi),s(We,bi),s(We,Lr),s(Lr,$i),s(We,qi),s(We,Or),s(Or,ki),s(We,ji),p(e,cl,d),w($o,e,d),p(e,dl,d),w(qo,e,d),p(e,ml,d),p(e,Dt,d),s(Dt,Ei),s(Dt,Sr),s(Sr,yi),s(Dt,wi),s(Dt,Gr),s(Gr,xi),s(Dt,zi),p(e,fl,d),w(ko,e,d),p(e,_l,d),w(jo,e,d),p(e,hl,d),xn.m(e,d),p(e,ir,d),de&&de.m(e,d),p(e,ur,d),vl=!0},p(e,[d]){const Co={};d&1&&(Co.fw=e[0]),c.$set(Co);let pr=h;h=Ti(e),h!==pr&&(wa(),b(Eo[pr],1,1,()=>{Eo[pr]=null}),ya(),T=Eo[h],T||(T=Eo[h]=Di[h](e),T.c()),g(T,1),T.m(H.parentNode,H));const Fr={};d&2&&(Fr.$$scope={dirty:d,ctx:e}),Ye.$set(Fr);const Hr={};d&2&&(Hr.$$scope={dirty:d,ctx:e}),Us.$set(Hr);let xe=Ve;Ve=Ai(e),Ve!==xe&&(wa(),b(yo[xe],1,1,()=>{yo[xe]=null}),ya(),Ue=yo[Ve],Ue||(Ue=yo[Ve]=Mi[Ve](e),Ue.c()),g(Ue,1),Ue.m(yn.parentNode,yn));let cr=Ks;Ks=Li(e),Ks!==cr&&(wa(),b(wo[cr],1,1,()=>{wo[cr]=null}),ya(),Js=wo[Ks],Js||(Js=wo[Ks]=Ni[Ks](e),Js.c()),g(Js,1),Js.m(er.parentNode,er));let dr=Ys;Ys=Si(e),Ys!==dr&&(wa(),b(xo[dr],1,1,()=>{xo[dr]=null}),ya(),Zs=xo[Ys],Zs||(Zs=xo[Ys]=Oi[Ys](e),Zs.c()),g(Zs,1),Zs.m(tr.parentNode,tr)),e[0]==="tf"?ce?d&1&&g(ce,1):(ce=hp(),ce.c(),g(ce,1),ce.m(ar.parentNode,ar)):ce&&(wa(),b(ce,1,1,()=>{ce=null}),ya());const Ir={};d&2&&(Ir.$$scope={dirty:d,ctx:e}),_a.$set(Ir);let mr=Qs;Qs=Fi(e),Qs!==mr&&(wa(),b(zo[mr],1,1,()=>{zo[mr]=null}),ya(),et=zo[Qs],et||(et=zo[Qs]=Gi[Qs](e),et.c()),g(et,1),et.m(or.parentNode,or));const Rr={};d&2&&(Rr.$$scope={dirty:d,ctx:e}),ba.$set(Rr);const Me={};d&3&&(Me.$$scope={dirty:d,ctx:e}),$a.$set(Me);let fr=st;st=Ii(e),st!==fr&&(wa(),b(Po[fr],1,1,()=>{Po[fr]=null}),ya(),tt=Po[st],tt||(tt=Po[st]=Hi[st](e),tt.c()),g(tt,1),tt.m(rr.parentNode,rr)),gl!==(gl=Ri(e))&&(xn.d(1),xn=gl(e),xn&&(xn.c(),xn.m(ir.parentNode,ir))),e[0]==="pt"?de?d&1&&g(de,1):(de=vp(e),de.c(),g(de,1),de.m(ur.parentNode,ur)):de&&(wa(),b(de,1,1,()=>{de=null}),ya())},i(e){vl||(g(c.$$.fragment,e),g(D.$$.fragment,e),g(T),g($s.$$.fragment,e),g(js.$$.fragment,e),g(zs.$$.fragment,e),g(Ce.$$.fragment,e),g(Ee.$$.fragment,e),g(fe.$$.fragment,e),g(Fe.$$.fragment,e),g(Cs.$$.fragment,e),g(rs.$$.fragment,e),g(is.$$.fragment,e),g(Ye.$$.fragment,e),g(Ts.$$.fragment,e),g(Ms.$$.fragment,e),g(Ls.$$.fragment,e),g(Ze.$$.fragment,e),g(Hs.$$.fragment,e),g(Is.$$.fragment,e),g(yt.$$.fragment,e),g(wt.$$.fragment,e),g(Us.$$.fragment,e),g(zt.$$.fragment,e),g(Ue),g(Js),g(co.$$.fragment,e),g(Zs),g(ce),g(_a.$$.fragment,e),g(mo.$$.fragment,e),g(fo.$$.fragment,e),g(et),g(ba.$$.fragment,e),g($a.$$.fragment,e),g(_o.$$.fragment,e),g(tt),g(ho.$$.fragment,e),g(vo.$$.fragment,e),g(go.$$.fragment,e),g(bo.$$.fragment,e),g($o.$$.fragment,e),g(qo.$$.fragment,e),g(ko.$$.fragment,e),g(jo.$$.fragment,e),g(de),vl=!0)},o(e){b(c.$$.fragment,e),b(D.$$.fragment,e),b(T),b($s.$$.fragment,e),b(js.$$.fragment,e),b(zs.$$.fragment,e),b(Ce.$$.fragment,e),b(Ee.$$.fragment,e),b(fe.$$.fragment,e),b(Fe.$$.fragment,e),b(Cs.$$.fragment,e),b(rs.$$.fragment,e),b(is.$$.fragment,e),b(Ye.$$.fragment,e),b(Ts.$$.fragment,e),b(Ms.$$.fragment,e),b(Ls.$$.fragment,e),b(Ze.$$.fragment,e),b(Hs.$$.fragment,e),b(Is.$$.fragment,e),b(yt.$$.fragment,e),b(wt.$$.fragment,e),b(Us.$$.fragment,e),b(zt.$$.fragment,e),b(Ue),b(Js),b(co.$$.fragment,e),b(Zs),b(ce),b(_a.$$.fragment,e),b(mo.$$.fragment,e),b(fo.$$.fragment,e),b(et),b(ba.$$.fragment,e),b($a.$$.fragment,e),b(_o.$$.fragment,e),b(tt),b(ho.$$.fragment,e),b(vo.$$.fragment,e),b(go.$$.fragment,e),b(bo.$$.fragment,e),b($o.$$.fragment,e),b(qo.$$.fragment,e),b(ko.$$.fragment,e),b(jo.$$.fragment,e),b(de),vl=!1},d(e){t(r),e&&t(_),x(c,e),e&&t(v),e&&t(k),x(D),e&&t(M),Eo[h].d(e),e&&t(H),e&&t(F),e&&t(ge),e&&t(Q),e&&t(it),x($s,e),e&&t(zn),e&&t(oe),e&&t(Ut),e&&t(re),e&&t(te),e&&t(be),e&&t(Dn),e&&t(Le),e&&t(Tn),e&&t(Xe),x(js),e&&t(Qt),e&&t(le),e&&t(on),e&&t(ne),e&&t(Ke),x(zs,e),e&&t(dt),e&&t(mt),e&&t(rn),x(Ce,e),e&&t(ln),x(Ee,e),e&&t(Nn),e&&t(Ge),e&&t(pn),x(fe,e),e&&t(On),e&&t(as),e&&t(Sn),x(Fe,e),e&&t(Gn),x(Cs,e),e&&t(cn),e&&t(He),e&&t(Ds),e&&t(os),e&&t(Rn),x(rs,e),e&&t(ls),x(is,e),e&&t(us),x(Ye,e),e&&t($e),e&&t(_t),e&&t(Vn),x(Ts,e),e&&t(ht),x(Ms,e),e&&t(Un),e&&t(Ie),e&&t(fn),e&&t(Z),x(Ls),e&&t(Wn),x(Ze,e),e&&t(Xn),e&&t(cs),e&&t(Kn),e&&t(ie),e&&t(Qn),e&&t(es),e&&t(kn),e&&t(Re),e&&t(ss),x(Hs,e),e&&t($t),x(Is,e),e&&t(sa),e&&t(De),e&&t(fs),e&&t(pe),e&&t(oo),x(yt,e),e&&t(ro),x(wt,e),e&&t(lo),e&&t(qe),e&&t(io),e&&t(ts),e&&t(uo),x(Us,e),e&&t(Bs),e&&t(_s),x(zt),e&&t(po),e&&t(ke),e&&t(Xs),yo[Ve].d(e),e&&t(yn),e&&t(Te),e&&t(Vr),e&&t(Be),e&&t(Ur),wo[Ks].d(e),e&&t(er),e&&t(sr),e&&t(Br),x(co,e),e&&t(Wr),xo[Ys].d(e),e&&t(tr),e&&t(nr),e&&t(Xr),ce&&ce.d(e),e&&t(ar),x(_a,e),e&&t(Kr),e&&t(ha),e&&t(Jr),x(mo,e),e&&t(Yr),e&&t(va),e&&t(Zr),e&&t(ga),e&&t(Qr),x(fo,e),e&&t(el),zo[Qs].d(e),e&&t(or),x(ba,e),e&&t(sl),x($a,e),e&&t(tl),e&&t(wn),x(_o),e&&t(nl),e&&t(ka),e&&t(al),Po[st].d(e),e&&t(rr),e&&t(lr),e&&t(ol),x(ho,e),e&&t(rl),x(vo,e),e&&t(ll),e&&t(Ct),e&&t(il),x(go,e),e&&t(ul),x(bo,e),e&&t(pl),e&&t(We),e&&t(cl),x($o,e),e&&t(dl),x(qo,e),e&&t(ml),e&&t(Dt),e&&t(fl),x(ko,e),e&&t(_l),x(jo,e),e&&t(hl),xn.d(e),e&&t(ir),de&&de.d(e),e&&t(ur)}}}const Jp={local:"entraner-un-modle-de-langage-causal-partir-de-zro",sections:[{local:"collecte-des-donnes",title:"Collecte des donn\xE9es"},{local:"prparation-du-jeu-de-donnes",title:"Pr\xE9paration du jeu de donn\xE9es"},{local:"initialisation-dun-nouveau-modle",title:"Initialisation d'un nouveau mod\xE8le"},{local:"gnration-de-code-avec-le-pipeline",title:"G\xE9n\xE9ration de code avec le pipeline"},{local:"entraner-avec-iacceleratei",title:"Entra\xEEner avec \u{1F917} <i>Accelerate</i>"}],title:"Entra\xEEner un mod\xE8le de langage causal \xE0 partir de z\xE9ro"};function Yp(O,r,_){let c="pt";return jp(()=>{const v=new URLSearchParams(window.location.search);_(0,c=v.get("fw")||"pt")}),[c]}class oc extends bp{constructor(r){super();$p(this,r,Yp,Kp,qp,{})}}export{oc as default,Jp as metadata};
