import{S as Dn,i as Mn,s as Nn,e as r,k as d,w as q,t as a,M as Fn,c as l,d as t,m as c,x as b,a as i,h as n,b as h,G as s,g as u,y as g,q as E,o as k,B as j,v as Kn}from"../../chunks/vendor-hf-doc-builder.js";import{T as _t}from"../../chunks/Tip-hf-doc-builder.js";import{Y as ht}from"../../chunks/Youtube-hf-doc-builder.js";import{I as $t}from"../../chunks/IconCopyLink-hf-doc-builder.js";import{C as G}from"../../chunks/CodeBlock-hf-doc-builder.js";import{D as Ln}from"../../chunks/DocNotebookDropdown-hf-doc-builder.js";import{F as Un}from"../../chunks/FrameworkSwitchCourse-hf-doc-builder.js";function On(O){let p,z,m,x,$,f,C,w;return{c(){p=r("p"),z=a("Notez que les mod\xE8les \u{1F917} "),m=r("em"),x=a("Transformers"),$=a(" ont une capacit\xE9 sp\xE9ciale que la plupart des mod\xE8les Keras n\u2019ont pas. Ils peuvent automatiquement utiliser une perte appropri\xE9e qu\u2019ils calculent en interne. Ils utiliseront cette perte par d\xE9faut si vous ne d\xE9finissez pas un argument de perte dans "),f=r("code"),C=a("compile()"),w=a(". Notez que pour utiliser la perte interne, vous devrez passer vos labels comme faisant partie de l\u2019entr\xE9e, et non pas comme un label s\xE9par\xE9, ce qui est la fa\xE7on normale d\u2019utiliser les labels avec les mod\xE8les Keras. Vous verrez des exemples de cela dans la partie 2 du cours, o\xF9 la d\xE9finition de la fonction de perte correcte peut \xEAtre d\xE9licate. Pour la classification des s\xE9quences, cependant, une fonction de perte standard de Keras fonctionne bien, et c\u2019est donc ce que nous utiliserons ici.")},l(_){p=l(_,"P",{});var v=i(p);z=n(v,"Notez que les mod\xE8les \u{1F917} "),m=l(v,"EM",{});var A=i(m);x=n(A,"Transformers"),A.forEach(t),$=n(v," ont une capacit\xE9 sp\xE9ciale que la plupart des mod\xE8les Keras n\u2019ont pas. Ils peuvent automatiquement utiliser une perte appropri\xE9e qu\u2019ils calculent en interne. Ils utiliseront cette perte par d\xE9faut si vous ne d\xE9finissez pas un argument de perte dans "),f=l(v,"CODE",{});var y=i(f);C=n(y,"compile()"),y.forEach(t),w=n(v,". Notez que pour utiliser la perte interne, vous devrez passer vos labels comme faisant partie de l\u2019entr\xE9e, et non pas comme un label s\xE9par\xE9, ce qui est la fa\xE7on normale d\u2019utiliser les labels avec les mod\xE8les Keras. Vous verrez des exemples de cela dans la partie 2 du cours, o\xF9 la d\xE9finition de la fonction de perte correcte peut \xEAtre d\xE9licate. Pour la classification des s\xE9quences, cependant, une fonction de perte standard de Keras fonctionne bien, et c\u2019est donc ce que nous utiliserons ici."),v.forEach(t)},m(_,v){u(_,p,v),s(p,z),s(p,m),s(m,x),s(p,$),s(p,f),s(f,C),s(p,w)},d(_){_&&t(p)}}}function In(O){let p,z,m,x,$,f,C,w;return{c(){p=r("p"),z=a("Notez un pi\xE8ge tr\xE8s commun ici. Vous "),m=r("em"),x=a("pouvez"),$=a(" simplement passer le nom de la perte comme une cha\xEEne \xE0 Keras, mais par d\xE9faut Keras supposera que vous avez d\xE9j\xE0 appliqu\xE9 une fonction softmax \xE0 vos sorties. Cependant, de nombreux mod\xE8les produisent les valeurs juste avant l\u2019application de la softmax, que l\u2019on appelle aussi les "),f=r("em"),C=a("logits"),w=a(". Nous devons indiquer \xE0 la fonction de perte que c\u2019est ce que fait notre mod\xE8le, et la seule fa\xE7on de le faire est de l\u2019appeler directement, plut\xF4t que par son nom avec une cha\xEEne.")},l(_){p=l(_,"P",{});var v=i(p);z=n(v,"Notez un pi\xE8ge tr\xE8s commun ici. Vous "),m=l(v,"EM",{});var A=i(m);x=n(A,"pouvez"),A.forEach(t),$=n(v," simplement passer le nom de la perte comme une cha\xEEne \xE0 Keras, mais par d\xE9faut Keras supposera que vous avez d\xE9j\xE0 appliqu\xE9 une fonction softmax \xE0 vos sorties. Cependant, de nombreux mod\xE8les produisent les valeurs juste avant l\u2019application de la softmax, que l\u2019on appelle aussi les "),f=l(v,"EM",{});var y=i(f);C=n(y,"logits"),y.forEach(t),w=n(v,". Nous devons indiquer \xE0 la fonction de perte que c\u2019est ce que fait notre mod\xE8le, et la seule fa\xE7on de le faire est de l\u2019appeler directement, plut\xF4t que par son nom avec une cha\xEEne."),v.forEach(t)},m(_,v){u(_,p,v),s(p,z),s(p,m),s(m,x),s(p,$),s(p,f),s(f,C),s(p,w)},d(_){_&&t(p)}}}function Gn(O){let p,z,m,x,$,f,C,w,_,v,A;return{c(){p=r("p"),z=a("La biblioth\xE8que \u{1F917} "),m=r("em"),x=a("Transformers"),$=a(" poss\xE8de \xE9galement une fonction "),f=r("code"),C=a("create_optimizer()"),w=a(" qui cr\xE9era un optimiseur "),_=r("code"),v=a("AdamW"),A=a(" avec un taux d\u2019apprentissage d\xE9croissant. Il s\u2019agit d\u2019un raccourci pratique que vous verrez en d\xE9tail dans les prochaines sections du cours.")},l(y){p=l(y,"P",{});var T=i(p);z=n(T,"La biblioth\xE8que \u{1F917} "),m=l(T,"EM",{});var I=i(m);x=n(I,"Transformers"),I.forEach(t),$=n(T," poss\xE8de \xE9galement une fonction "),f=l(T,"CODE",{});var S=i(f);C=n(S,"create_optimizer()"),S.forEach(t),w=n(T," qui cr\xE9era un optimiseur "),_=l(T,"CODE",{});var P=i(_);v=n(P,"AdamW"),P.forEach(t),A=n(T," avec un taux d\u2019apprentissage d\xE9croissant. Il s\u2019agit d\u2019un raccourci pratique que vous verrez en d\xE9tail dans les prochaines sections du cours."),T.forEach(t)},m(y,T){u(y,p,T),s(p,z),s(p,m),s(m,x),s(p,$),s(p,f),s(f,C),s(p,w),s(p,_),s(_,v),s(p,A)},d(y){y&&t(p)}}}function Vn(O){let p,z,m,x,$,f,C,w,_,v,A,y,T,I;return{c(){p=r("p"),z=a("\u{1F4A1} Si vous voulez t\xE9l\xE9charger automatiquement votre mod\xE8le sur le "),m=r("em"),x=a("Hub"),$=a(" pendant l\u2019entra\xEEnement, vous pouvez passer un "),f=r("code"),C=a("PushToHubCallback"),w=a(" dans la m\xE9thode "),_=r("code"),v=a("model.fit()"),A=a(". Nous en apprendrons davantage \xE0 ce sujet au "),y=r("a"),T=a("chapitre 4"),I=a("."),this.h()},l(S){p=l(S,"P",{});var P=i(p);z=n(P,"\u{1F4A1} Si vous voulez t\xE9l\xE9charger automatiquement votre mod\xE8le sur le "),m=l(P,"EM",{});var N=i(m);x=n(N,"Hub"),N.forEach(t),$=n(P," pendant l\u2019entra\xEEnement, vous pouvez passer un "),f=l(P,"CODE",{});var Se=i(f);C=n(Se,"PushToHubCallback"),Se.forEach(t),w=n(P," dans la m\xE9thode "),_=l(P,"CODE",{});var Q=i(_);v=n(Q,"model.fit()"),Q.forEach(t),A=n(P,". Nous en apprendrons davantage \xE0 ce sujet au "),y=l(P,"A",{href:!0});var De=i(y);T=n(De,"chapitre 4"),De.forEach(t),I=n(P,"."),P.forEach(t),this.h()},h(){h(y,"href","/course/fr/chapter4/3")},m(S,P){u(S,p,P),s(p,z),s(p,m),s(m,x),s(p,$),s(p,f),s(f,C),s(p,w),s(p,_),s(_,v),s(p,A),s(p,y),s(y,T),s(p,I)},d(S){S&&t(p)}}}function Hn(O){let p,z,m,x,$,f,C,w,_,v,A,y,T,I,S,P,N,Se,Q,De,qt,ce,bt,gt,ws,Me,Et,zs,me,xs,W,X,Re,fe,kt,Be,jt,ys,Z,wt,We,zt,xt,Cs,ve,Ps,Ne,yt,As,_e,Ts,V,Ct,Fe,Pt,At,Ye,Tt,St,Ss,he,Ds,ee,Dt,Ke,Mt,Nt,Ms,M,Ft,Je,Kt,Lt,Qe,Ut,Ot,Xe,It,Gt,Ze,Vt,Ht,Ns,se,Fs,$e,Ks,te,Ls,Y,ae,es,qe,Rt,ss,Bt,Us,be,Os,H,Wt,ts,Yt,Jt,as,Qt,Xt,Is,D,Zt,ns,ea,sa,os,ta,aa,rs,na,oa,ls,ra,la,is,ia,ua,Gs,ge,Vs,ne,Hs,Le,pa,Rs,Ee,Bs,oe,da,us,ca,ma,Ws,ke,Ys,re,Js,J,le,ps,je,fa,ds,va,Qs,we,Xs,R,_a,cs,ha,$a,ms,qa,ba,Zs,ze,et,ie,ga,fs,Ea,ka,st,xe,tt,ye,at,F,ja,vs,wa,za,_s,xa,ya,hs,Ca,Pa,nt,Ce,ot,Pe,rt,K,Aa,Ae,Ta,Sa,$s,Da,Ma,qs,Na,Fa,lt,L,Ka,bs,La,Ua,Ue,Oa,Ia,gs,Ga,Va,it;return m=new Un({props:{fw:O[0]}}),w=new $t({}),S=new Ln({props:{classNames:"absolute z-10 right-0 top-0",options:[{label:"Google Colab",value:"https://colab.research.google.com/github/huggingface/notebooks/blob/master/course/chapter3/section3_tf.ipynb"},{label:"Aws Studio",value:"https://studiolab.sagemaker.aws/import/github/huggingface/notebooks/blob/master/course/chapter3/section3_tf.ipynb"}]}}),me=new G({props:{code:`from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding
import numpy as np

raw_datasets = load_dataset("glue", "mrpc")
checkpoint = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)


def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)


tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)

data_collator = DataCollatorWithPadding(tokenizer=tokenizer, return_tensors="tf")

tf_train_dataset = tokenized_datasets["train"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "token_type_ids"],
    label_cols=["labels"],
    shuffle=True,
    collate_fn=data_collator,
    batch_size=8,
)

tf_validation_dataset = tokenized_datasets["validation"].to_tf_dataset(
    columns=["attention_mask", "input_ids", "token_type_ids"],
    label_cols=["labels"],
    shuffle=False,
    collate_fn=data_collator,
    batch_size=8,
)`,highlighted:`<span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoTokenizer, DataCollatorWithPadding
<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np

raw_datasets = load_dataset(<span class="hljs-string">&quot;glue&quot;</span>, <span class="hljs-string">&quot;mrpc&quot;</span>)
checkpoint = <span class="hljs-string">&quot;bert-base-uncased&quot;</span>
tokenizer = AutoTokenizer.from_pretrained(checkpoint)


<span class="hljs-keyword">def</span> <span class="hljs-title function_">tokenize_function</span>(<span class="hljs-params">example</span>):
    <span class="hljs-keyword">return</span> tokenizer(example[<span class="hljs-string">&quot;sentence1&quot;</span>], example[<span class="hljs-string">&quot;sentence2&quot;</span>], truncation=<span class="hljs-literal">True</span>)


tokenized_datasets = raw_datasets.<span class="hljs-built_in">map</span>(tokenize_function, batched=<span class="hljs-literal">True</span>)

data_collator = DataCollatorWithPadding(tokenizer=tokenizer, return_tensors=<span class="hljs-string">&quot;tf&quot;</span>)

tf_train_dataset = tokenized_datasets[<span class="hljs-string">&quot;train&quot;</span>].to_tf_dataset(
    columns=[<span class="hljs-string">&quot;attention_mask&quot;</span>, <span class="hljs-string">&quot;input_ids&quot;</span>, <span class="hljs-string">&quot;token_type_ids&quot;</span>],
    label_cols=[<span class="hljs-string">&quot;labels&quot;</span>],
    shuffle=<span class="hljs-literal">True</span>,
    collate_fn=data_collator,
    batch_size=<span class="hljs-number">8</span>,
)

tf_validation_dataset = tokenized_datasets[<span class="hljs-string">&quot;validation&quot;</span>].to_tf_dataset(
    columns=[<span class="hljs-string">&quot;attention_mask&quot;</span>, <span class="hljs-string">&quot;input_ids&quot;</span>, <span class="hljs-string">&quot;token_type_ids&quot;</span>],
    label_cols=[<span class="hljs-string">&quot;labels&quot;</span>],
    shuffle=<span class="hljs-literal">False</span>,
    collate_fn=data_collator,
    batch_size=<span class="hljs-number">8</span>,
)`}}),fe=new $t({}),ve=new ht({props:{id:"rnTGBy2ax1c"}}),_e=new ht({props:{id:"AUozVp78dhk"}}),he=new G({props:{code:`from transformers import TFAutoModelForSequenceClassification

model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> TFAutoModelForSequenceClassification

model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=<span class="hljs-number">2</span>)`}}),se=new _t({props:{$$slots:{default:[On]},$$scope:{ctx:O}}}),$e=new G({props:{code:`from tensorflow.keras.losses import SparseCategoricalCrossentropy

model.compile(
    optimizer="adam",
    loss=SparseCategoricalCrossentropy(from_logits=True),
    metrics=["accuracy"],
)
model.fit(
    tf_train_dataset,
    validation_data=tf_validation_dataset,
)`,highlighted:`<span class="hljs-keyword">from</span> tensorflow.keras.losses <span class="hljs-keyword">import</span> SparseCategoricalCrossentropy

model.<span class="hljs-built_in">compile</span>(
    optimizer=<span class="hljs-string">&quot;adam&quot;</span>,
    loss=SparseCategoricalCrossentropy(from_logits=<span class="hljs-literal">True</span>),
    metrics=[<span class="hljs-string">&quot;accuracy&quot;</span>],
)
model.fit(
    tf_train_dataset,
    validation_data=tf_validation_dataset,
)`}}),te=new _t({props:{warning:!0,$$slots:{default:[In]},$$scope:{ctx:O}}}),qe=new $t({}),be=new ht({props:{id:"cpzq6ESSM5c"}}),ge=new G({props:{code:`from tensorflow.keras.optimizers.schedules import PolynomialDecay

batch_size = 8
num_epochs = 3
# Le nombre d'\xE9tapes d'entra\xEEnement est le nombre d'\xE9chantillons dans l'ensemble de donn\xE9es, divis\xE9 par la taille du batch puis multipli\xE9
# par le nombre total d'\xE9poques. Notez que le jeu de donn\xE9es tf_train_dataset est ici un lot tf.data.Dataset
# et non le jeu de donn\xE9es original Hugging Face Dataset, donc son len() est d\xE9j\xE0 num_samples // batch_size.
num_train_steps = len(tf_train_dataset) * num_epochs
lr_scheduler = PolynomialDecay(
    initial_learning_rate=5e-5, end_learning_rate=0.0, decay_steps=num_train_steps
)
from tensorflow.keras.optimizers import Adam

opt = Adam(learning_rate=lr_scheduler)`,highlighted:`<span class="hljs-keyword">from</span> tensorflow.keras.optimizers.schedules <span class="hljs-keyword">import</span> PolynomialDecay

batch_size = <span class="hljs-number">8</span>
num_epochs = <span class="hljs-number">3</span>
<span class="hljs-comment"># Le nombre d&#x27;\xE9tapes d&#x27;entra\xEEnement est le nombre d&#x27;\xE9chantillons dans l&#x27;ensemble de donn\xE9es, divis\xE9 par la taille du batch puis multipli\xE9</span>
<span class="hljs-comment"># par le nombre total d&#x27;\xE9poques. Notez que le jeu de donn\xE9es tf_train_dataset est ici un lot tf.data.Dataset</span>
<span class="hljs-comment"># et non le jeu de donn\xE9es original Hugging Face Dataset, donc son len() est d\xE9j\xE0 num_samples // batch_size.</span>
num_train_steps = <span class="hljs-built_in">len</span>(tf_train_dataset) * num_epochs
lr_scheduler = PolynomialDecay(
    initial_learning_rate=<span class="hljs-number">5e-5</span>, end_learning_rate=<span class="hljs-number">0.0</span>, decay_steps=num_train_steps
)
<span class="hljs-keyword">from</span> tensorflow.keras.optimizers <span class="hljs-keyword">import</span> Adam

opt = Adam(learning_rate=lr_scheduler)`}}),ne=new _t({props:{$$slots:{default:[Gn]},$$scope:{ctx:O}}}),Ee=new G({props:{code:`import tensorflow as tf

model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer=opt, loss=loss, metrics=["accuracy"])`,highlighted:`<span class="hljs-keyword">import</span> tensorflow <span class="hljs-keyword">as</span> tf

model = TFAutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=<span class="hljs-number">2</span>)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=<span class="hljs-literal">True</span>)
model.<span class="hljs-built_in">compile</span>(optimizer=opt, loss=loss, metrics=[<span class="hljs-string">&quot;accuracy&quot;</span>])`}}),ke=new G({props:{code:"model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=3)",highlighted:'model.fit(tf_train_dataset, validation_data=tf_validation_dataset, epochs=<span class="hljs-number">3</span>)'}}),re=new _t({props:{$$slots:{default:[Vn]},$$scope:{ctx:O}}}),je=new $t({}),we=new ht({props:{id:"nx10eh4CoOs"}}),ze=new G({props:{code:'preds = model.predict(tf_validation_dataset)["logits"]',highlighted:'preds = model.predict(tf_validation_dataset)[<span class="hljs-string">&quot;logits&quot;</span>]'}}),xe=new G({props:{code:`class_preds = np.argmax(preds, axis=1)
print(preds.shape, class_preds.shape)`,highlighted:`class_preds = np.argmax(preds, axis=<span class="hljs-number">1</span>)
<span class="hljs-built_in">print</span>(preds.shape, class_preds.shape)`}}),ye=new G({props:{code:"(408, 2) (408,)",highlighted:'(<span class="hljs-number">408</span>, <span class="hljs-number">2</span>) (<span class="hljs-number">408</span>,)'}}),Ce=new G({props:{code:`from datasets import load_metric

metric = load_metric("glue", "mrpc")
metric.compute(predictions=class_preds, references=raw_datasets["validation"]["label"])`,highlighted:`<span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_metric

metric = load_metric(<span class="hljs-string">&quot;glue&quot;</span>, <span class="hljs-string">&quot;mrpc&quot;</span>)
metric.compute(predictions=class_preds, references=raw_datasets[<span class="hljs-string">&quot;validation&quot;</span>][<span class="hljs-string">&quot;label&quot;</span>])`}}),Pe=new G({props:{code:"{'accuracy': 0.8578431372549019, 'f1': 0.8996539792387542}",highlighted:'{<span class="hljs-string">&#x27;accuracy&#x27;</span>: <span class="hljs-number">0.8578431372549019</span>, <span class="hljs-string">&#x27;f1&#x27;</span>: <span class="hljs-number">0.8996539792387542</span>}'}}),{c(){p=r("meta"),z=d(),q(m.$$.fragment),x=d(),$=r("h1"),f=r("a"),C=r("span"),q(w.$$.fragment),_=d(),v=r("span"),A=r("i"),y=a("Finetuner"),T=a(" un mod\xE8le avec Keras"),I=d(),q(S.$$.fragment),P=d(),N=r("p"),Se=a("Une fois que vous avez fait tout le travail de pr\xE9traitement des donn\xE9es dans la derni\xE8re section, il ne vous reste que quelques \xE9tapes pour entra\xEEner le mod\xE8le. Notez, cependant, que la commande "),Q=r("code"),De=a("model.fit()"),qt=a(" s\u2019ex\xE9cutera tr\xE8s lentement sur un CPU. Si vous n\u2019avez pas de GPU, vous pouvez avoir acc\xE8s \xE0 des GPUs ou TPUs gratuits sur "),ce=r("a"),bt=a("Google Colab"),gt=a("."),ws=d(),Me=r("p"),Et=a("Les exemples de code ci-dessous supposent que vous avez d\xE9j\xE0 ex\xE9cut\xE9 les exemples de la section pr\xE9c\xE9dente. Voici un bref r\xE9sum\xE9 de ce dont vous avez besoin :"),zs=d(),q(me.$$.fragment),xs=d(),W=r("h3"),X=r("a"),Re=r("span"),q(fe.$$.fragment),kt=d(),Be=r("span"),jt=a("Entra\xEEnement"),ys=d(),Z=r("p"),wt=a("Les mod\xE8les TensorFlow import\xE9s depuis \u{1F917} "),We=r("em"),zt=a("Transformers"),xt=a(" sont d\xE9j\xE0 des mod\xE8les Keras. Voici une courte introduction \xE0 Keras."),Cs=d(),q(ve.$$.fragment),Ps=d(),Ne=r("p"),yt=a("Cela signifie qu\u2019une fois que nous disposons de nos donn\xE9es, tr\xE8s peu de travail est n\xE9cessaire pour commencer \xE0 entra\xEEner sur celles-ci."),As=d(),q(_e.$$.fragment),Ts=d(),V=r("p"),Ct=a("Comme dans le "),Fe=r("a"),Pt=a("chapitre pr\xE9c\xE9dent"),At=a(", nous allons utiliser la classe "),Ye=r("code"),Tt=a("TFAutoModelForSequenceClassification"),St=a(", avec deux \xE9tiquettes :"),Ss=d(),q(he.$$.fragment),Ds=d(),ee=r("p"),Dt=a("Vous remarquerez que, contrairement au "),Ke=r("a"),Mt=a("chapitre 2"),Nt=a(", vous obtenez un message d\u2019avertissement apr\xE8s l\u2019instanciation de ce mod\xE8le pr\xE9-entra\xEEn\xE9. Ceci est d\xFB au fait que BERT n\u2019a pas \xE9t\xE9 pr\xE9-entra\xEEn\xE9 \xE0 la classification de paires de phrases, donc la t\xEAte du mod\xE8le pr\xE9-entra\xEEn\xE9 a \xE9t\xE9 supprim\xE9e et une nouvelle t\xEAte adapt\xE9e \xE0 la classification de s\xE9quences a \xE9t\xE9 ins\xE9r\xE9e \xE0 la place. Les messages d\u2019avertissement indiquent que certains poids n\u2019ont pas \xE9t\xE9 utilis\xE9s (ceux correspondant \xE0 la t\xEAte de pr\xE9-entra\xEEnement abandonn\xE9e) et que d\u2019autres ont \xE9t\xE9 initialis\xE9s de mani\xE8re al\xE9atoire (ceux pour la nouvelle t\xEAte). Il conclut en vous encourageant \xE0 entra\xEEner le mod\xE8le, ce qui est exactement ce que nous allons faire maintenant."),Ms=d(),M=r("p"),Ft=a("Pour "),Je=r("em"),Kt=a("finetuner"),Lt=a(" le mod\xE8le sur notre jeu de donn\xE9es, nous devons simplement "),Qe=r("code"),Ut=a("compiler()"),Ot=a(" notre mod\xE8le et ensuite passer nos donn\xE9es \xE0 la m\xE9thode "),Xe=r("code"),It=a("fit()"),Gt=a(". Cela va d\xE9marrer le processus de "),Ze=r("em"),Vt=a("finetuning"),Ht=a(" (qui devrait prendre quelques minutes sur un GPU) et rapporter la perte d\u2019entra\xEEnement au fur et \xE0 mesure, plus la perte de validation \xE0 la fin de chaque \xE9poque."),Ns=d(),q(se.$$.fragment),Fs=d(),q($e.$$.fragment),Ks=d(),q(te.$$.fragment),Ls=d(),Y=r("h3"),ae=r("a"),es=r("span"),q(qe.$$.fragment),Rt=d(),ss=r("span"),Bt=a("Am\xE9liorer les performances d'entra\xEEnement"),Us=d(),q(be.$$.fragment),Os=d(),H=r("p"),Wt=a("Si vous essayez le code ci-dessus, il fonctionne certainement, mais vous constaterez que la perte ne diminue que lentement ou sporadiquement. La cause principale est le "),ts=r("em"),Yt=a("taux d\u2019apprentissage"),Jt=a(". Comme pour la perte, lorsque nous transmettons \xE0 Keras le nom d\u2019un optimiseur sous forme de cha\xEEne de caract\xE8res, Keras initialise cet optimiseur avec des valeurs par d\xE9faut pour tous les param\xE8tres, y compris le taux d\u2019apprentissage. Cependant, nous savons depuis longtemps que les "),as=r("em"),Qt=a("transformers"),Xt=a(" b\xE9n\xE9ficient d\u2019un taux d\u2019apprentissage beaucoup plus faible que celui par d\xE9faut d\u2019Adam, qui est de 1e-3, \xE9galement \xE9crit comme 10 \xE0 la puissance -3, ou 0,001. 5e-5 (0,00005), qui est environ vingt fois inf\xE9rieur, est un bien meilleur point de d\xE9part."),Is=d(),D=r("p"),Zt=a("En plus de r\xE9duire le taux d\u2019apprentissage, nous avons une deuxi\xE8me astuce dans notre manche : nous pouvons r\xE9duire lentement le taux d\u2019apprentissage au cours de l\u2019entra\xEEnement. Dans la litt\xE9rature, on parle parfois de "),ns=r("em"),ea=a("d\xE9croissance"),sa=a(" ou d\u2019"),os=r("em"),ta=a("annulation"),aa=a(" du taux d\u2019apprentissage.le taux d\u2019apprentissage. Dans Keras, la meilleure fa\xE7on de le faire est d\u2019utiliser un "),rs=r("em"),na=a("planificateur du taux d\u2019apprentissage"),oa=a(". Un bon planificateur \xE0 utiliser est "),ls=r("code"),ra=a("PolynomialDecay"),la=a(". Malgr\xE9 son nom, avec les param\xE8tres par d\xE9faut, il diminue simplement de fa\xE7on lin\xE9aire le taux d\u2019apprentissage de la valeur initiale \xE0 la valeur finale au cours de l\u2019entra\xEEnement, ce qui est exactement ce que nous voulons. Afin d\u2019utiliser correctement un planificateur, nous devons lui dire combien de temps l\u2019entra\xEEnement va durer. Nous calculons cela comme "),is=r("code"),ia=a("num_train_steps"),ua=a(" ci-dessous."),Gs=d(),q(ge.$$.fragment),Vs=d(),q(ne.$$.fragment),Hs=d(),Le=r("p"),pa=a("Nous avons maintenant notre tout nouvel optimiseur et nous pouvons essayer de nous entra\xEEner avec lui. Tout d\u2019abord, rechargeons le mod\xE8le pour r\xE9initialiser les modifications apport\xE9es aux poids lors de l\u2019entra\xEEnement que nous venons d\u2019effectuer, puis nous pouvons le compiler avec le nouvel optimiseur :"),Rs=d(),q(Ee.$$.fragment),Bs=d(),oe=r("p"),da=a("Maintenant, on "),us=r("em"),ca=a("fit"),ma=a(" :"),Ws=d(),q(ke.$$.fragment),Ys=d(),q(re.$$.fragment),Js=d(),J=r("h3"),le=r("a"),ps=r("span"),q(je.$$.fragment),fa=d(),ds=r("span"),va=a("Pr\xE9dictions du mod\xE8le"),Qs=d(),q(we.$$.fragment),Xs=d(),R=r("p"),_a=a("Entra\xEEner et regarder la perte diminuer, c\u2019est tr\xE8s bien, mais que faire si l\u2019on veut r\xE9ellement obtenir des r\xE9sultats du mod\xE8le entra\xEEn\xE9, soit pour calculer des m\xE9triques, soit pour utiliser le mod\xE8le en production ? Pour ce faire, nous pouvons simplement utiliser la m\xE9thode "),cs=r("code"),ha=a("predict()"),$a=a(". Ceci retournera les "),ms=r("em"),qa=a("logits"),ba=a(" de la t\xEAte de sortie du mod\xE8le, un par classe."),Zs=d(),q(ze.$$.fragment),et=d(),ie=r("p"),ga=a("Nous pouvons convertir ces logits en pr\xE9dictions de classe du mod\xE8le en utilisant "),fs=r("code"),Ea=a("argmax"),ka=a(" pour trouver le logit le plus \xE9lev\xE9, qui correspond \xE0 la classe la plus probable :"),st=d(),q(xe.$$.fragment),tt=d(),q(ye.$$.fragment),at=d(),F=r("p"),ja=a("Maintenant, utilisons ces "),vs=r("code"),wa=a("preds"),za=a(" pour calculer des m\xE9triques ! Nous pouvons charger les m\xE9triques associ\xE9es au jeu de donn\xE9es MRPC aussi facilement que nous avons charg\xE9 le jeu de donn\xE9es, cette fois avec la fonction "),_s=r("code"),xa=a("load_metric()"),ya=a(". L\u2019objet retourn\xE9 a une m\xE9thode "),hs=r("code"),Ca=a("compute()"),Pa=a(" que nous pouvons utiliser pour faire le calcul de la m\xE9trique :"),nt=d(),q(Ce.$$.fragment),ot=d(),q(Pe.$$.fragment),rt=d(),K=r("p"),Aa=a("Les r\xE9sultats exacts que vous obtiendrez peuvent varier, car l\u2019initialisation al\xE9atoire de la t\xEAte du mod\xE8le peut modifier les m\xE9triques obtenues. Ici, nous pouvons voir que notre mod\xE8le a une pr\xE9cision de 85,78% sur l\u2019ensemble de validation et un score F1 de 89,97. Ce sont les deux m\xE9triques utilis\xE9es pour \xE9valuer les r\xE9sultats sur le jeu de donn\xE9es MRPC pour le benchmark GLUE. Le tableau du papier de "),Ae=r("a"),Ta=a("BERT"),Sa=a(" indique un score F1 de 88,9 pour le mod\xE8le de base. Il s\u2019agissait du mod\xE8le "),$s=r("code"),Da=a("uncased"),Ma=a(" alors que nous utilisons actuellement le mod\xE8le "),qs=r("code"),Na=a("cased"),Fa=a(", ce qui explique le meilleur r\xE9sultat."),lt=d(),L=r("p"),Ka=a("Ceci conclut l\u2019introduction \xE0 le "),bs=r("em"),La=a("finetuning"),Ua=a(" en utilisant l\u2019API Keras. Un exemple d\u2019application de cette m\xE9thode aux t\xE2ches les plus courantes du traitement automatique des langues sera pr\xE9sent\xE9 au "),Ue=r("a"),Oa=a("chapitre 7"),Ia=a(". Si vous souhaitez affiner vos connaissances de l\u2019API Keras, essayez "),gs=r("em"),Ga=a("finetuner"),Va=a(" un mod\xE8le sur le jeu de donn\xE9es GLUE SST-2, en utilisant le traitement des donn\xE9es que vous avez effectu\xE9 dans la section 2."),this.h()},l(e){const o=Fn('[data-svelte="svelte-1phssyn"]',document.head);p=l(o,"META",{name:!0,content:!0}),o.forEach(t),z=c(e),b(m.$$.fragment,e),x=c(e),$=l(e,"H1",{class:!0});var Te=i($);f=l(Te,"A",{id:!0,class:!0,href:!0});var Es=i(f);C=l(Es,"SPAN",{});var ks=i(C);b(w.$$.fragment,ks),ks.forEach(t),Es.forEach(t),_=c(Te),v=l(Te,"SPAN",{});var Oe=i(v);A=l(Oe,"I",{});var js=i(A);y=n(js,"Finetuner"),js.forEach(t),T=n(Oe," un mod\xE8le avec Keras"),Oe.forEach(t),Te.forEach(t),I=c(e),b(S.$$.fragment,e),P=c(e),N=l(e,"P",{});var Ie=i(N);Se=n(Ie,"Une fois que vous avez fait tout le travail de pr\xE9traitement des donn\xE9es dans la derni\xE8re section, il ne vous reste que quelques \xE9tapes pour entra\xEEner le mod\xE8le. Notez, cependant, que la commande "),Q=l(Ie,"CODE",{});var Ha=i(Q);De=n(Ha,"model.fit()"),Ha.forEach(t),qt=n(Ie," s\u2019ex\xE9cutera tr\xE8s lentement sur un CPU. Si vous n\u2019avez pas de GPU, vous pouvez avoir acc\xE8s \xE0 des GPUs ou TPUs gratuits sur "),ce=l(Ie,"A",{href:!0,rel:!0});var Ra=i(ce);bt=n(Ra,"Google Colab"),Ra.forEach(t),gt=n(Ie,"."),Ie.forEach(t),ws=c(e),Me=l(e,"P",{});var Ba=i(Me);Et=n(Ba,"Les exemples de code ci-dessous supposent que vous avez d\xE9j\xE0 ex\xE9cut\xE9 les exemples de la section pr\xE9c\xE9dente. Voici un bref r\xE9sum\xE9 de ce dont vous avez besoin :"),Ba.forEach(t),zs=c(e),b(me.$$.fragment,e),xs=c(e),W=l(e,"H3",{class:!0});var ut=i(W);X=l(ut,"A",{id:!0,class:!0,href:!0});var Wa=i(X);Re=l(Wa,"SPAN",{});var Ya=i(Re);b(fe.$$.fragment,Ya),Ya.forEach(t),Wa.forEach(t),kt=c(ut),Be=l(ut,"SPAN",{});var Ja=i(Be);jt=n(Ja,"Entra\xEEnement"),Ja.forEach(t),ut.forEach(t),ys=c(e),Z=l(e,"P",{});var pt=i(Z);wt=n(pt,"Les mod\xE8les TensorFlow import\xE9s depuis \u{1F917} "),We=l(pt,"EM",{});var Qa=i(We);zt=n(Qa,"Transformers"),Qa.forEach(t),xt=n(pt," sont d\xE9j\xE0 des mod\xE8les Keras. Voici une courte introduction \xE0 Keras."),pt.forEach(t),Cs=c(e),b(ve.$$.fragment,e),Ps=c(e),Ne=l(e,"P",{});var Xa=i(Ne);yt=n(Xa,"Cela signifie qu\u2019une fois que nous disposons de nos donn\xE9es, tr\xE8s peu de travail est n\xE9cessaire pour commencer \xE0 entra\xEEner sur celles-ci."),Xa.forEach(t),As=c(e),b(_e.$$.fragment,e),Ts=c(e),V=l(e,"P",{});var Ge=i(V);Ct=n(Ge,"Comme dans le "),Fe=l(Ge,"A",{href:!0});var Za=i(Fe);Pt=n(Za,"chapitre pr\xE9c\xE9dent"),Za.forEach(t),At=n(Ge,", nous allons utiliser la classe "),Ye=l(Ge,"CODE",{});var en=i(Ye);Tt=n(en,"TFAutoModelForSequenceClassification"),en.forEach(t),St=n(Ge,", avec deux \xE9tiquettes :"),Ge.forEach(t),Ss=c(e),b(he.$$.fragment,e),Ds=c(e),ee=l(e,"P",{});var dt=i(ee);Dt=n(dt,"Vous remarquerez que, contrairement au "),Ke=l(dt,"A",{href:!0});var sn=i(Ke);Mt=n(sn,"chapitre 2"),sn.forEach(t),Nt=n(dt,", vous obtenez un message d\u2019avertissement apr\xE8s l\u2019instanciation de ce mod\xE8le pr\xE9-entra\xEEn\xE9. Ceci est d\xFB au fait que BERT n\u2019a pas \xE9t\xE9 pr\xE9-entra\xEEn\xE9 \xE0 la classification de paires de phrases, donc la t\xEAte du mod\xE8le pr\xE9-entra\xEEn\xE9 a \xE9t\xE9 supprim\xE9e et une nouvelle t\xEAte adapt\xE9e \xE0 la classification de s\xE9quences a \xE9t\xE9 ins\xE9r\xE9e \xE0 la place. Les messages d\u2019avertissement indiquent que certains poids n\u2019ont pas \xE9t\xE9 utilis\xE9s (ceux correspondant \xE0 la t\xEAte de pr\xE9-entra\xEEnement abandonn\xE9e) et que d\u2019autres ont \xE9t\xE9 initialis\xE9s de mani\xE8re al\xE9atoire (ceux pour la nouvelle t\xEAte). Il conclut en vous encourageant \xE0 entra\xEEner le mod\xE8le, ce qui est exactement ce que nous allons faire maintenant."),dt.forEach(t),Ms=c(e),M=l(e,"P",{});var B=i(M);Ft=n(B,"Pour "),Je=l(B,"EM",{});var tn=i(Je);Kt=n(tn,"finetuner"),tn.forEach(t),Lt=n(B," le mod\xE8le sur notre jeu de donn\xE9es, nous devons simplement "),Qe=l(B,"CODE",{});var an=i(Qe);Ut=n(an,"compiler()"),an.forEach(t),Ot=n(B," notre mod\xE8le et ensuite passer nos donn\xE9es \xE0 la m\xE9thode "),Xe=l(B,"CODE",{});var nn=i(Xe);It=n(nn,"fit()"),nn.forEach(t),Gt=n(B,". Cela va d\xE9marrer le processus de "),Ze=l(B,"EM",{});var on=i(Ze);Vt=n(on,"finetuning"),on.forEach(t),Ht=n(B," (qui devrait prendre quelques minutes sur un GPU) et rapporter la perte d\u2019entra\xEEnement au fur et \xE0 mesure, plus la perte de validation \xE0 la fin de chaque \xE9poque."),B.forEach(t),Ns=c(e),b(se.$$.fragment,e),Fs=c(e),b($e.$$.fragment,e),Ks=c(e),b(te.$$.fragment,e),Ls=c(e),Y=l(e,"H3",{class:!0});var ct=i(Y);ae=l(ct,"A",{id:!0,class:!0,href:!0});var rn=i(ae);es=l(rn,"SPAN",{});var ln=i(es);b(qe.$$.fragment,ln),ln.forEach(t),rn.forEach(t),Rt=c(ct),ss=l(ct,"SPAN",{});var un=i(ss);Bt=n(un,"Am\xE9liorer les performances d'entra\xEEnement"),un.forEach(t),ct.forEach(t),Us=c(e),b(be.$$.fragment,e),Os=c(e),H=l(e,"P",{});var Ve=i(H);Wt=n(Ve,"Si vous essayez le code ci-dessus, il fonctionne certainement, mais vous constaterez que la perte ne diminue que lentement ou sporadiquement. La cause principale est le "),ts=l(Ve,"EM",{});var pn=i(ts);Yt=n(pn,"taux d\u2019apprentissage"),pn.forEach(t),Jt=n(Ve,". Comme pour la perte, lorsque nous transmettons \xE0 Keras le nom d\u2019un optimiseur sous forme de cha\xEEne de caract\xE8res, Keras initialise cet optimiseur avec des valeurs par d\xE9faut pour tous les param\xE8tres, y compris le taux d\u2019apprentissage. Cependant, nous savons depuis longtemps que les "),as=l(Ve,"EM",{});var dn=i(as);Qt=n(dn,"transformers"),dn.forEach(t),Xt=n(Ve," b\xE9n\xE9ficient d\u2019un taux d\u2019apprentissage beaucoup plus faible que celui par d\xE9faut d\u2019Adam, qui est de 1e-3, \xE9galement \xE9crit comme 10 \xE0 la puissance -3, ou 0,001. 5e-5 (0,00005), qui est environ vingt fois inf\xE9rieur, est un bien meilleur point de d\xE9part."),Ve.forEach(t),Is=c(e),D=l(e,"P",{});var U=i(D);Zt=n(U,"En plus de r\xE9duire le taux d\u2019apprentissage, nous avons une deuxi\xE8me astuce dans notre manche : nous pouvons r\xE9duire lentement le taux d\u2019apprentissage au cours de l\u2019entra\xEEnement. Dans la litt\xE9rature, on parle parfois de "),ns=l(U,"EM",{});var cn=i(ns);ea=n(cn,"d\xE9croissance"),cn.forEach(t),sa=n(U," ou d\u2019"),os=l(U,"EM",{});var mn=i(os);ta=n(mn,"annulation"),mn.forEach(t),aa=n(U," du taux d\u2019apprentissage.le taux d\u2019apprentissage. Dans Keras, la meilleure fa\xE7on de le faire est d\u2019utiliser un "),rs=l(U,"EM",{});var fn=i(rs);na=n(fn,"planificateur du taux d\u2019apprentissage"),fn.forEach(t),oa=n(U,". Un bon planificateur \xE0 utiliser est "),ls=l(U,"CODE",{});var vn=i(ls);ra=n(vn,"PolynomialDecay"),vn.forEach(t),la=n(U,". Malgr\xE9 son nom, avec les param\xE8tres par d\xE9faut, il diminue simplement de fa\xE7on lin\xE9aire le taux d\u2019apprentissage de la valeur initiale \xE0 la valeur finale au cours de l\u2019entra\xEEnement, ce qui est exactement ce que nous voulons. Afin d\u2019utiliser correctement un planificateur, nous devons lui dire combien de temps l\u2019entra\xEEnement va durer. Nous calculons cela comme "),is=l(U,"CODE",{});var _n=i(is);ia=n(_n,"num_train_steps"),_n.forEach(t),ua=n(U," ci-dessous."),U.forEach(t),Gs=c(e),b(ge.$$.fragment,e),Vs=c(e),b(ne.$$.fragment,e),Hs=c(e),Le=l(e,"P",{});var hn=i(Le);pa=n(hn,"Nous avons maintenant notre tout nouvel optimiseur et nous pouvons essayer de nous entra\xEEner avec lui. Tout d\u2019abord, rechargeons le mod\xE8le pour r\xE9initialiser les modifications apport\xE9es aux poids lors de l\u2019entra\xEEnement que nous venons d\u2019effectuer, puis nous pouvons le compiler avec le nouvel optimiseur :"),hn.forEach(t),Rs=c(e),b(Ee.$$.fragment,e),Bs=c(e),oe=l(e,"P",{});var mt=i(oe);da=n(mt,"Maintenant, on "),us=l(mt,"EM",{});var $n=i(us);ca=n($n,"fit"),$n.forEach(t),ma=n(mt," :"),mt.forEach(t),Ws=c(e),b(ke.$$.fragment,e),Ys=c(e),b(re.$$.fragment,e),Js=c(e),J=l(e,"H3",{class:!0});var ft=i(J);le=l(ft,"A",{id:!0,class:!0,href:!0});var qn=i(le);ps=l(qn,"SPAN",{});var bn=i(ps);b(je.$$.fragment,bn),bn.forEach(t),qn.forEach(t),fa=c(ft),ds=l(ft,"SPAN",{});var gn=i(ds);va=n(gn,"Pr\xE9dictions du mod\xE8le"),gn.forEach(t),ft.forEach(t),Qs=c(e),b(we.$$.fragment,e),Xs=c(e),R=l(e,"P",{});var He=i(R);_a=n(He,"Entra\xEEner et regarder la perte diminuer, c\u2019est tr\xE8s bien, mais que faire si l\u2019on veut r\xE9ellement obtenir des r\xE9sultats du mod\xE8le entra\xEEn\xE9, soit pour calculer des m\xE9triques, soit pour utiliser le mod\xE8le en production ? Pour ce faire, nous pouvons simplement utiliser la m\xE9thode "),cs=l(He,"CODE",{});var En=i(cs);ha=n(En,"predict()"),En.forEach(t),$a=n(He,". Ceci retournera les "),ms=l(He,"EM",{});var kn=i(ms);qa=n(kn,"logits"),kn.forEach(t),ba=n(He," de la t\xEAte de sortie du mod\xE8le, un par classe."),He.forEach(t),Zs=c(e),b(ze.$$.fragment,e),et=c(e),ie=l(e,"P",{});var vt=i(ie);ga=n(vt,"Nous pouvons convertir ces logits en pr\xE9dictions de classe du mod\xE8le en utilisant "),fs=l(vt,"CODE",{});var jn=i(fs);Ea=n(jn,"argmax"),jn.forEach(t),ka=n(vt," pour trouver le logit le plus \xE9lev\xE9, qui correspond \xE0 la classe la plus probable :"),vt.forEach(t),st=c(e),b(xe.$$.fragment,e),tt=c(e),b(ye.$$.fragment,e),at=c(e),F=l(e,"P",{});var ue=i(F);ja=n(ue,"Maintenant, utilisons ces "),vs=l(ue,"CODE",{});var wn=i(vs);wa=n(wn,"preds"),wn.forEach(t),za=n(ue," pour calculer des m\xE9triques ! Nous pouvons charger les m\xE9triques associ\xE9es au jeu de donn\xE9es MRPC aussi facilement que nous avons charg\xE9 le jeu de donn\xE9es, cette fois avec la fonction "),_s=l(ue,"CODE",{});var zn=i(_s);xa=n(zn,"load_metric()"),zn.forEach(t),ya=n(ue,". L\u2019objet retourn\xE9 a une m\xE9thode "),hs=l(ue,"CODE",{});var xn=i(hs);Ca=n(xn,"compute()"),xn.forEach(t),Pa=n(ue," que nous pouvons utiliser pour faire le calcul de la m\xE9trique :"),ue.forEach(t),nt=c(e),b(Ce.$$.fragment,e),ot=c(e),b(Pe.$$.fragment,e),rt=c(e),K=l(e,"P",{});var pe=i(K);Aa=n(pe,"Les r\xE9sultats exacts que vous obtiendrez peuvent varier, car l\u2019initialisation al\xE9atoire de la t\xEAte du mod\xE8le peut modifier les m\xE9triques obtenues. Ici, nous pouvons voir que notre mod\xE8le a une pr\xE9cision de 85,78% sur l\u2019ensemble de validation et un score F1 de 89,97. Ce sont les deux m\xE9triques utilis\xE9es pour \xE9valuer les r\xE9sultats sur le jeu de donn\xE9es MRPC pour le benchmark GLUE. Le tableau du papier de "),Ae=l(pe,"A",{href:!0,rel:!0});var yn=i(Ae);Ta=n(yn,"BERT"),yn.forEach(t),Sa=n(pe," indique un score F1 de 88,9 pour le mod\xE8le de base. Il s\u2019agissait du mod\xE8le "),$s=l(pe,"CODE",{});var Cn=i($s);Da=n(Cn,"uncased"),Cn.forEach(t),Ma=n(pe," alors que nous utilisons actuellement le mod\xE8le "),qs=l(pe,"CODE",{});var Pn=i(qs);Na=n(Pn,"cased"),Pn.forEach(t),Fa=n(pe,", ce qui explique le meilleur r\xE9sultat."),pe.forEach(t),lt=c(e),L=l(e,"P",{});var de=i(L);Ka=n(de,"Ceci conclut l\u2019introduction \xE0 le "),bs=l(de,"EM",{});var An=i(bs);La=n(An,"finetuning"),An.forEach(t),Ua=n(de," en utilisant l\u2019API Keras. Un exemple d\u2019application de cette m\xE9thode aux t\xE2ches les plus courantes du traitement automatique des langues sera pr\xE9sent\xE9 au "),Ue=l(de,"A",{href:!0});var Tn=i(Ue);Oa=n(Tn,"chapitre 7"),Tn.forEach(t),Ia=n(de,". Si vous souhaitez affiner vos connaissances de l\u2019API Keras, essayez "),gs=l(de,"EM",{});var Sn=i(gs);Ga=n(Sn,"finetuner"),Sn.forEach(t),Va=n(de," un mod\xE8le sur le jeu de donn\xE9es GLUE SST-2, en utilisant le traitement des donn\xE9es que vous avez effectu\xE9 dans la section 2."),de.forEach(t),this.h()},h(){h(p,"name","hf:doc:metadata"),h(p,"content",JSON.stringify(Rn)),h(f,"id","ifinetuneri-un-modle-avec-keras"),h(f,"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"),h(f,"href","#ifinetuneri-un-modle-avec-keras"),h($,"class","relative group"),h(ce,"href","https://colab.research.google.com/"),h(ce,"rel","nofollow"),h(X,"id","entranement"),h(X,"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"),h(X,"href","#entranement"),h(W,"class","relative group"),h(Fe,"href","/course/fr/chapter2"),h(Ke,"href","/course/fr/chapter2"),h(ae,"id","amliorer-les-performances-dentranement"),h(ae,"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"),h(ae,"href","#amliorer-les-performances-dentranement"),h(Y,"class","relative group"),h(le,"id","prdictions-du-modle"),h(le,"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"),h(le,"href","#prdictions-du-modle"),h(J,"class","relative group"),h(Ae,"href","https://arxiv.org/pdf/1810.04805.pdf"),h(Ae,"rel","nofollow"),h(Ue,"href","/course/fr/chapter7")},m(e,o){s(document.head,p),u(e,z,o),g(m,e,o),u(e,x,o),u(e,$,o),s($,f),s(f,C),g(w,C,null),s($,_),s($,v),s(v,A),s(A,y),s(v,T),u(e,I,o),g(S,e,o),u(e,P,o),u(e,N,o),s(N,Se),s(N,Q),s(Q,De),s(N,qt),s(N,ce),s(ce,bt),s(N,gt),u(e,ws,o),u(e,Me,o),s(Me,Et),u(e,zs,o),g(me,e,o),u(e,xs,o),u(e,W,o),s(W,X),s(X,Re),g(fe,Re,null),s(W,kt),s(W,Be),s(Be,jt),u(e,ys,o),u(e,Z,o),s(Z,wt),s(Z,We),s(We,zt),s(Z,xt),u(e,Cs,o),g(ve,e,o),u(e,Ps,o),u(e,Ne,o),s(Ne,yt),u(e,As,o),g(_e,e,o),u(e,Ts,o),u(e,V,o),s(V,Ct),s(V,Fe),s(Fe,Pt),s(V,At),s(V,Ye),s(Ye,Tt),s(V,St),u(e,Ss,o),g(he,e,o),u(e,Ds,o),u(e,ee,o),s(ee,Dt),s(ee,Ke),s(Ke,Mt),s(ee,Nt),u(e,Ms,o),u(e,M,o),s(M,Ft),s(M,Je),s(Je,Kt),s(M,Lt),s(M,Qe),s(Qe,Ut),s(M,Ot),s(M,Xe),s(Xe,It),s(M,Gt),s(M,Ze),s(Ze,Vt),s(M,Ht),u(e,Ns,o),g(se,e,o),u(e,Fs,o),g($e,e,o),u(e,Ks,o),g(te,e,o),u(e,Ls,o),u(e,Y,o),s(Y,ae),s(ae,es),g(qe,es,null),s(Y,Rt),s(Y,ss),s(ss,Bt),u(e,Us,o),g(be,e,o),u(e,Os,o),u(e,H,o),s(H,Wt),s(H,ts),s(ts,Yt),s(H,Jt),s(H,as),s(as,Qt),s(H,Xt),u(e,Is,o),u(e,D,o),s(D,Zt),s(D,ns),s(ns,ea),s(D,sa),s(D,os),s(os,ta),s(D,aa),s(D,rs),s(rs,na),s(D,oa),s(D,ls),s(ls,ra),s(D,la),s(D,is),s(is,ia),s(D,ua),u(e,Gs,o),g(ge,e,o),u(e,Vs,o),g(ne,e,o),u(e,Hs,o),u(e,Le,o),s(Le,pa),u(e,Rs,o),g(Ee,e,o),u(e,Bs,o),u(e,oe,o),s(oe,da),s(oe,us),s(us,ca),s(oe,ma),u(e,Ws,o),g(ke,e,o),u(e,Ys,o),g(re,e,o),u(e,Js,o),u(e,J,o),s(J,le),s(le,ps),g(je,ps,null),s(J,fa),s(J,ds),s(ds,va),u(e,Qs,o),g(we,e,o),u(e,Xs,o),u(e,R,o),s(R,_a),s(R,cs),s(cs,ha),s(R,$a),s(R,ms),s(ms,qa),s(R,ba),u(e,Zs,o),g(ze,e,o),u(e,et,o),u(e,ie,o),s(ie,ga),s(ie,fs),s(fs,Ea),s(ie,ka),u(e,st,o),g(xe,e,o),u(e,tt,o),g(ye,e,o),u(e,at,o),u(e,F,o),s(F,ja),s(F,vs),s(vs,wa),s(F,za),s(F,_s),s(_s,xa),s(F,ya),s(F,hs),s(hs,Ca),s(F,Pa),u(e,nt,o),g(Ce,e,o),u(e,ot,o),g(Pe,e,o),u(e,rt,o),u(e,K,o),s(K,Aa),s(K,Ae),s(Ae,Ta),s(K,Sa),s(K,$s),s($s,Da),s(K,Ma),s(K,qs),s(qs,Na),s(K,Fa),u(e,lt,o),u(e,L,o),s(L,Ka),s(L,bs),s(bs,La),s(L,Ua),s(L,Ue),s(Ue,Oa),s(L,Ia),s(L,gs),s(gs,Ga),s(L,Va),it=!0},p(e,[o]){const Te={};o&1&&(Te.fw=e[0]),m.$set(Te);const Es={};o&2&&(Es.$$scope={dirty:o,ctx:e}),se.$set(Es);const ks={};o&2&&(ks.$$scope={dirty:o,ctx:e}),te.$set(ks);const Oe={};o&2&&(Oe.$$scope={dirty:o,ctx:e}),ne.$set(Oe);const js={};o&2&&(js.$$scope={dirty:o,ctx:e}),re.$set(js)},i(e){it||(E(m.$$.fragment,e),E(w.$$.fragment,e),E(S.$$.fragment,e),E(me.$$.fragment,e),E(fe.$$.fragment,e),E(ve.$$.fragment,e),E(_e.$$.fragment,e),E(he.$$.fragment,e),E(se.$$.fragment,e),E($e.$$.fragment,e),E(te.$$.fragment,e),E(qe.$$.fragment,e),E(be.$$.fragment,e),E(ge.$$.fragment,e),E(ne.$$.fragment,e),E(Ee.$$.fragment,e),E(ke.$$.fragment,e),E(re.$$.fragment,e),E(je.$$.fragment,e),E(we.$$.fragment,e),E(ze.$$.fragment,e),E(xe.$$.fragment,e),E(ye.$$.fragment,e),E(Ce.$$.fragment,e),E(Pe.$$.fragment,e),it=!0)},o(e){k(m.$$.fragment,e),k(w.$$.fragment,e),k(S.$$.fragment,e),k(me.$$.fragment,e),k(fe.$$.fragment,e),k(ve.$$.fragment,e),k(_e.$$.fragment,e),k(he.$$.fragment,e),k(se.$$.fragment,e),k($e.$$.fragment,e),k(te.$$.fragment,e),k(qe.$$.fragment,e),k(be.$$.fragment,e),k(ge.$$.fragment,e),k(ne.$$.fragment,e),k(Ee.$$.fragment,e),k(ke.$$.fragment,e),k(re.$$.fragment,e),k(je.$$.fragment,e),k(we.$$.fragment,e),k(ze.$$.fragment,e),k(xe.$$.fragment,e),k(ye.$$.fragment,e),k(Ce.$$.fragment,e),k(Pe.$$.fragment,e),it=!1},d(e){t(p),e&&t(z),j(m,e),e&&t(x),e&&t($),j(w),e&&t(I),j(S,e),e&&t(P),e&&t(N),e&&t(ws),e&&t(Me),e&&t(zs),j(me,e),e&&t(xs),e&&t(W),j(fe),e&&t(ys),e&&t(Z),e&&t(Cs),j(ve,e),e&&t(Ps),e&&t(Ne),e&&t(As),j(_e,e),e&&t(Ts),e&&t(V),e&&t(Ss),j(he,e),e&&t(Ds),e&&t(ee),e&&t(Ms),e&&t(M),e&&t(Ns),j(se,e),e&&t(Fs),j($e,e),e&&t(Ks),j(te,e),e&&t(Ls),e&&t(Y),j(qe),e&&t(Us),j(be,e),e&&t(Os),e&&t(H),e&&t(Is),e&&t(D),e&&t(Gs),j(ge,e),e&&t(Vs),j(ne,e),e&&t(Hs),e&&t(Le),e&&t(Rs),j(Ee,e),e&&t(Bs),e&&t(oe),e&&t(Ws),j(ke,e),e&&t(Ys),j(re,e),e&&t(Js),e&&t(J),j(je),e&&t(Qs),j(we,e),e&&t(Xs),e&&t(R),e&&t(Zs),j(ze,e),e&&t(et),e&&t(ie),e&&t(st),j(xe,e),e&&t(tt),j(ye,e),e&&t(at),e&&t(F),e&&t(nt),j(Ce,e),e&&t(ot),j(Pe,e),e&&t(rt),e&&t(K),e&&t(lt),e&&t(L)}}}const Rn={local:"ifinetuneri-un-modle-avec-keras",sections:[{local:"entranement",title:"Entra\xEEnement"},{local:"amliorer-les-performances-dentranement",title:"Am\xE9liorer les performances d'entra\xEEnement"},{local:"prdictions-du-modle",title:"Pr\xE9dictions du mod\xE8le"}],title:"<i>Finetuner</i> un mod\xE8le avec Keras"};function Bn(O,p,z){let m="pt";return Kn(()=>{const x=new URLSearchParams(window.location.search);z(0,m=x.get("fw")||"pt")}),[m]}class so extends Dn{constructor(p){super();Mn(this,p,Bn,Hn,Nn,{})}}export{so as default,Rn as metadata};
