import{S as tn,i as ln,s as rn,e as l,k as d,w as h,t as o,M as nn,c as r,d as a,m as c,a as n,x as b,h as t,b as u,G as s,g as p,y as E,L as pn,q as v,o as q,B as y,v as dn}from"../chunks/vendor-hf-doc-builder.js";import{I as Ka}from"../chunks/IconCopyLink-hf-doc-builder.js";import{C as L}from"../chunks/CodeBlock-hf-doc-builder.js";function cn(Nl){let R,Vs,N,U,Ae,de,Va,Se,Wa,Ws,H,Za,Pe,eo,so,Zs,D,ao,Le,oo,to,Re,lo,ro,ea,g,no,Ne,io,po,Me,co,uo,Fe,mo,fo,sa,m,_o,Ye,ho,bo,Ge,Eo,vo,Ue,qo,yo,He,go,jo,Xe,wo,ko,aa,ce,oa,$e,Po,ta,M,Je,$o,Co,Qe,Do,xo,la,$,Be,Oo,zo,Ke,Io,To,Ve,Ao,So,ra,x,Lo,We,Ro,No,Ze,Mo,Fo,na,C,es,Yo,Go,ss,Uo,Ho,as,Xo,Jo,ia,f,Qo,os,Bo,Ko,ts,Vo,Wo,ls,Zo,et,rs,st,at,pa,X,ot,ns,tt,lt,da,ue,ca,j,rt,is,nt,it,ps,pt,dt,ds,ct,ut,ua,me,ma,Ce,mt,fa,F,J,cs,fe,ft,us,_t,_a,O,ht,ms,bt,Et,fs,vt,qt,ha,_e,ba,Q,yt,_s,gt,jt,Ea,he,va,Y,B,hs,be,wt,bs,kt,qa,K,Pt,Es,$t,Ct,ya,Ee,ga,V,Dt,vs,xt,Ot,ja,ve,wa,W,zt,qs,It,Tt,ka,qe,Pa,z,At,ys,St,Lt,gs,Rt,Nt,$a,ye,Ca,_,Mt,js,Ft,Yt,ws,Gt,Ut,ks,Ht,Xt,Ps,Jt,Qt,Da,ge,xa,G,Z,$s,je,Bt,Cs,Kt,Oa,I,Vt,Ds,Wt,Zt,xs,el,sl,za,ee,al,Os,ol,tl,Ia,w,ll,zs,rl,nl,Is,il,pl,Ts,dl,cl,Ta,T,ul,As,ml,fl,Ss,_l,hl,Aa,se,bl,Ls,El,vl,Sa,k,ae,Rs,ql,yl,Ns,gl,jl,wl,oe,Ms,kl,Pl,Fs,$l,Cl,Dl,te,Ys,xl,Ol,Gs,zl,Il,Tl,le,Us,Al,Sl,Hs,Ll,Rl,La;return de=new Ka({}),ce=new L({props:{code:`from transformers import Pipeline


class MyPipeline(Pipeline):
    def _sanitize_parameters(self, **kwargs):
        preprocess_kwargs = {}
        if "maybe_arg" in kwargs:
            preprocess_kwargs["maybe_arg"] = kwargs["maybe_arg"]
        return preprocess_kwargs, {}, {}

    def preprocess(self, inputs, maybe_arg=2):
        model_input = Tensor(inputs["input_ids"])
        return {"model_input": model_input}

    def _forward(self, model_inputs):
        # model_inputs == {"model_input": model_input}
        outputs = self.model(**model_inputs)
        # Quiz\xE1 {"logits": Tensor(...)}
        return outputs

    def postprocess(self, model_outputs):
        best_class = model_outputs["logits"].softmax(-1)
        return best_class`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> Pipeline


<span class="hljs-keyword">class</span> <span class="hljs-title class_">MyPipeline</span>(<span class="hljs-title class_ inherited__">Pipeline</span>):
    <span class="hljs-keyword">def</span> <span class="hljs-title function_">_sanitize_parameters</span>(<span class="hljs-params">self, **kwargs</span>):
        preprocess_kwargs = {}
        <span class="hljs-keyword">if</span> <span class="hljs-string">&quot;maybe_arg&quot;</span> <span class="hljs-keyword">in</span> kwargs:
            preprocess_kwargs[<span class="hljs-string">&quot;maybe_arg&quot;</span>] = kwargs[<span class="hljs-string">&quot;maybe_arg&quot;</span>]
        <span class="hljs-keyword">return</span> preprocess_kwargs, {}, {}

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">preprocess</span>(<span class="hljs-params">self, inputs, maybe_arg=<span class="hljs-number">2</span></span>):
        model_input = Tensor(inputs[<span class="hljs-string">&quot;input_ids&quot;</span>])
        <span class="hljs-keyword">return</span> {<span class="hljs-string">&quot;model_input&quot;</span>: model_input}

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">_forward</span>(<span class="hljs-params">self, model_inputs</span>):
        <span class="hljs-comment"># model_inputs == {&quot;model_input&quot;: model_input}</span>
        outputs = self.model(**model_inputs)
        <span class="hljs-comment"># Quiz\xE1 {&quot;logits&quot;: Tensor(...)}</span>
        <span class="hljs-keyword">return</span> outputs

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">postprocess</span>(<span class="hljs-params">self, model_outputs</span>):
        best_class = model_outputs[<span class="hljs-string">&quot;logits&quot;</span>].softmax(-<span class="hljs-number">1</span>)
        <span class="hljs-keyword">return</span> best_class`}}),ue=new L({props:{code:`pipe = pipeline("my-new-task")
pipe("This is a test")

pipe("This is a test", top_k=2)`,highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span>pipe = pipeline(<span class="hljs-string">&quot;my-new-task&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>pipe(<span class="hljs-string">&quot;This is a test&quot;</span>)
[{<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;1-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.8</span>}, {<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;2-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.1</span>}, {<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;3-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.05</span>}
{<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;4-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.025</span>}, {<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;5-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.025</span>}]

<span class="hljs-meta">&gt;&gt;&gt; </span>pipe(<span class="hljs-string">&quot;This is a test&quot;</span>, top_k=<span class="hljs-number">2</span>)
[{<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;1-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.8</span>}, {<span class="hljs-string">&quot;label&quot;</span>: <span class="hljs-string">&quot;2-star&quot;</span>, <span class="hljs-string">&quot;score&quot;</span>: <span class="hljs-number">0.1</span>}]`}}),me=new L({props:{code:`def postprocess(self, model_outputs, top_k=5):
    best_class = model_outputs["logits"].softmax(-1)
    # A\xF1ade la l\xF3gica para manejar el top_k
    return best_class


def _sanitize_parameters(self, **kwargs):
    preprocess_kwargs = {}
    if "maybe_arg" in kwargs:
        preprocess_kwargs["maybe_arg"] = kwargs["maybe_arg"]

    postprocess_kwargs = {}
    if "top_k" in kwargs:
        postprocess_kwargs["top_k"] = kwargs["top_k"]
    return preprocess_kwargs, {}, postprocess_kwargs`,highlighted:`<span class="hljs-keyword">def</span> <span class="hljs-title function_">postprocess</span>(<span class="hljs-params">self, model_outputs, top_k=<span class="hljs-number">5</span></span>):
    best_class = model_outputs[<span class="hljs-string">&quot;logits&quot;</span>].softmax(-<span class="hljs-number">1</span>)
    <span class="hljs-comment"># A\xF1ade la l\xF3gica para manejar el top_k</span>
    <span class="hljs-keyword">return</span> best_class


<span class="hljs-keyword">def</span> <span class="hljs-title function_">_sanitize_parameters</span>(<span class="hljs-params">self, **kwargs</span>):
    preprocess_kwargs = {}
    <span class="hljs-keyword">if</span> <span class="hljs-string">&quot;maybe_arg&quot;</span> <span class="hljs-keyword">in</span> kwargs:
        preprocess_kwargs[<span class="hljs-string">&quot;maybe_arg&quot;</span>] = kwargs[<span class="hljs-string">&quot;maybe_arg&quot;</span>]

    postprocess_kwargs = {}
    <span class="hljs-keyword">if</span> <span class="hljs-string">&quot;top_k&quot;</span> <span class="hljs-keyword">in</span> kwargs:
        postprocess_kwargs[<span class="hljs-string">&quot;top_k&quot;</span>] = kwargs[<span class="hljs-string">&quot;top_k&quot;</span>]
    <span class="hljs-keyword">return</span> preprocess_kwargs, {}, postprocess_kwargs`}}),fe=new Ka({}),_e=new L({props:{code:`from transformers.pipelines import PIPELINE_REGISTRY

PIPELINE_REGISTRY.register_pipeline(
    "new-task",
    pipeline_class=MyPipeline,
    pt_model=AutoModelForSequenceClassification,
)`,highlighted:`<span class="hljs-keyword">from</span> transformers.pipelines <span class="hljs-keyword">import</span> PIPELINE_REGISTRY

PIPELINE_REGISTRY.register_pipeline(
    <span class="hljs-string">&quot;new-task&quot;</span>,
    pipeline_class=MyPipeline,
    pt_model=AutoModelForSequenceClassification,
)`}}),he=new L({props:{code:`PIPELINE_REGISTRY.register_pipeline(
    "new-task",
    pipeline_class=MyPipeline,
    pt_model=AutoModelForSequenceClassification,
    default={"pt": ("user/awesome_model", "abcdef")},
    type="text",  # tipo de datos que maneja: texto, audio, imagen, multi-modalidad
)`,highlighted:`PIPELINE_REGISTRY.register_pipeline(
    <span class="hljs-string">&quot;new-task&quot;</span>,
    pipeline_class=MyPipeline,
    pt_model=AutoModelForSequenceClassification,
    default={<span class="hljs-string">&quot;pt&quot;</span>: (<span class="hljs-string">&quot;user/awesome_model&quot;</span>, <span class="hljs-string">&quot;abcdef&quot;</span>)},
    <span class="hljs-built_in">type</span>=<span class="hljs-string">&quot;text&quot;</span>,  <span class="hljs-comment"># tipo de datos que maneja: texto, audio, imagen, multi-modalidad</span>
)`}}),be=new Ka({}),Ee=new L({props:{code:`import numpy as np

from transformers import Pipeline


def softmax(outputs):
    maxes = np.max(outputs, axis=-1, keepdims=True)
    shifted_exp = np.exp(outputs - maxes)
    return shifted_exp / shifted_exp.sum(axis=-1, keepdims=True)


class PairClassificationPipeline(Pipeline):
    def _sanitize_parameters(self, **kwargs):
        preprocess_kwargs = {}
        if "second_text" in kwargs:
            preprocess_kwargs["second_text"] = kwargs["second_text"]
        return preprocess_kwargs, {}, {}

    def preprocess(self, text, second_text=None):
        return self.tokenizer(text, text_pair=second_text, return_tensors=self.framework)

    def _forward(self, model_inputs):
        return self.model(**model_inputs)

    def postprocess(self, model_outputs):
        logits = model_outputs.logits[0].numpy()
        probabilities = softmax(logits)

        best_class = np.argmax(probabilities)
        label = self.model.config.id2label[best_class]
        score = probabilities[best_class].item()
        logits = logits.tolist()
        return {"label": label, "score": score, "logits": logits}`,highlighted:`<span class="hljs-keyword">import</span> numpy <span class="hljs-keyword">as</span> np

<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> Pipeline


<span class="hljs-keyword">def</span> <span class="hljs-title function_">softmax</span>(<span class="hljs-params">outputs</span>):
    maxes = np.<span class="hljs-built_in">max</span>(outputs, axis=-<span class="hljs-number">1</span>, keepdims=<span class="hljs-literal">True</span>)
    shifted_exp = np.exp(outputs - maxes)
    <span class="hljs-keyword">return</span> shifted_exp / shifted_exp.<span class="hljs-built_in">sum</span>(axis=-<span class="hljs-number">1</span>, keepdims=<span class="hljs-literal">True</span>)


<span class="hljs-keyword">class</span> <span class="hljs-title class_">PairClassificationPipeline</span>(<span class="hljs-title class_ inherited__">Pipeline</span>):
    <span class="hljs-keyword">def</span> <span class="hljs-title function_">_sanitize_parameters</span>(<span class="hljs-params">self, **kwargs</span>):
        preprocess_kwargs = {}
        <span class="hljs-keyword">if</span> <span class="hljs-string">&quot;second_text&quot;</span> <span class="hljs-keyword">in</span> kwargs:
            preprocess_kwargs[<span class="hljs-string">&quot;second_text&quot;</span>] = kwargs[<span class="hljs-string">&quot;second_text&quot;</span>]
        <span class="hljs-keyword">return</span> preprocess_kwargs, {}, {}

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">preprocess</span>(<span class="hljs-params">self, text, second_text=<span class="hljs-literal">None</span></span>):
        <span class="hljs-keyword">return</span> self.tokenizer(text, text_pair=second_text, return_tensors=self.framework)

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">_forward</span>(<span class="hljs-params">self, model_inputs</span>):
        <span class="hljs-keyword">return</span> self.model(**model_inputs)

    <span class="hljs-keyword">def</span> <span class="hljs-title function_">postprocess</span>(<span class="hljs-params">self, model_outputs</span>):
        logits = model_outputs.logits[<span class="hljs-number">0</span>].numpy()
        probabilities = softmax(logits)

        best_class = np.argmax(probabilities)
        label = self.model.config.id2label[best_class]
        score = probabilities[best_class].item()
        logits = logits.tolist()
        <span class="hljs-keyword">return</span> {<span class="hljs-string">&quot;label&quot;</span>: label, <span class="hljs-string">&quot;score&quot;</span>: score, <span class="hljs-string">&quot;logits&quot;</span>: logits}`}}),ve=new L({props:{code:`from pair_classification import PairClassificationPipeline
from transformers.pipelines import PIPELINE_REGISTRY
from transformers import AutoModelForSequenceClassification, TFAutoModelForSequenceClassification

PIPELINE_REGISTRY.register_pipeline(
    "pair-classification",
    pipeline_class=PairClassificationPipeline,
    pt_model=AutoModelForSequenceClassification,
    tf_model=TFAutoModelForSequenceClassification,
)`,highlighted:`<span class="hljs-keyword">from</span> pair_classification <span class="hljs-keyword">import</span> PairClassificationPipeline
<span class="hljs-keyword">from</span> transformers.pipelines <span class="hljs-keyword">import</span> PIPELINE_REGISTRY
<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> AutoModelForSequenceClassification, TFAutoModelForSequenceClassification

PIPELINE_REGISTRY.register_pipeline(
    <span class="hljs-string">&quot;pair-classification&quot;</span>,
    pipeline_class=PairClassificationPipeline,
    pt_model=AutoModelForSequenceClassification,
    tf_model=TFAutoModelForSequenceClassification,
)`}}),qe=new L({props:{code:`from transformers import pipeline

classifier = pipeline("pair-classification", model="sgugger/finetuned-bert-mrpc")`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> pipeline

classifier = pipeline(<span class="hljs-string">&quot;pair-classification&quot;</span>, model=<span class="hljs-string">&quot;sgugger/finetuned-bert-mrpc&quot;</span>)`}}),ye=new L({props:{code:`from huggingface_hub import Repository

repo = Repository("test-dynamic-pipeline", clone_from="{your_username}/test-dynamic-pipeline")
classifier.save_pretrained("test-dynamic-pipeline")
repo.push_to_hub()`,highlighted:`<span class="hljs-keyword">from</span> huggingface_hub <span class="hljs-keyword">import</span> Repository

repo = Repository(<span class="hljs-string">&quot;test-dynamic-pipeline&quot;</span>, clone_from=<span class="hljs-string">&quot;{your_username}/test-dynamic-pipeline&quot;</span>)
classifier.save_pretrained(<span class="hljs-string">&quot;test-dynamic-pipeline&quot;</span>)
repo.push_to_hub()`}}),ge=new L({props:{code:`from transformers import pipeline

classifier = pipeline(model="{your_username}/test-dynamic-pipeline", trust_remote_code=True)`,highlighted:`<span class="hljs-keyword">from</span> transformers <span class="hljs-keyword">import</span> pipeline

classifier = pipeline(model=<span class="hljs-string">&quot;{your_username}/test-dynamic-pipeline&quot;</span>, trust_remote_code=<span class="hljs-literal">True</span>)`}}),je=new Ka({}),{c(){R=l("meta"),Vs=d(),N=l("h1"),U=l("a"),Ae=l("span"),h(de.$$.fragment),Va=d(),Se=l("span"),Wa=o("\xBFC\xF3mo puedo crear un pipeline personalizado?"),Ws=d(),H=l("p"),Za=o("En esta gu\xEDa, veremos c\xF3mo crear un pipeline personalizado y c\xF3mo compartirlo en el "),Pe=l("a"),eo=o("Hub"),so=o(` o a\xF1adirlo
a la biblioteca \u{1F917} Transformers.`),Zs=d(),D=l("p"),ao=o(`En primer lugar, debes decidir las entradas que tu pipeline podr\xE1 recibir. Pueden ser strings, bytes,
diccionarios o lo que te parezca que vaya a ser la entrada m\xE1s apropiada. Intenta mantener estas entradas en un
formato que sea tan Python puro como sea posible, puesto que esto facilita la compatibilidad (incluso con otros
lenguajes de programaci\xF3n por medio de JSON). Estos ser\xE1n los `),Le=l("code"),oo=o("inputs"),to=o(" (entradas) del pipeline ("),Re=l("code"),lo=o("preprocess"),ro=o(")."),ea=d(),g=l("p"),no=o("Ahora debes definir los "),Ne=l("code"),io=o("outputs"),po=o(" (salidas). Al igual que con los "),Me=l("code"),co=o("inputs"),uo=o(`, entre m\xE1s simple el formato, mejor.
Estas ser\xE1n las salidas del m\xE9todo `),Fe=l("code"),mo=o("postprocess"),fo=o(" (posprocesamiento)."),sa=d(),m=l("p"),_o=o("Empieza heredando la clase base "),Ye=l("code"),ho=o("Pipeline"),bo=o(" con los 4 m\xE9todos que debemos implementar: "),Ge=l("code"),Eo=o("preprocess"),vo=o(` (preprocesamiento),
`),Ue=l("code"),qo=o("_forward"),yo=o(" (ejecuci\xF3n), "),He=l("code"),go=o("postprocess"),jo=o(" (posprocesamiento) y "),Xe=l("code"),wo=o("_sanitize_parameters"),ko=o(" (verificar par\xE1metros)."),aa=d(),h(ce.$$.fragment),oa=d(),$e=l("p"),Po=o(`La estructura de este desglose es as\xED para garantizar una compatibilidad m\xE1s o menos transparente con el uso de
CPU/GPU y el pre/posprocesamiento en CPU en varios hilos.`),ta=d(),M=l("p"),Je=l("code"),$o=o("preprocess"),Co=o(` tomar\xE1 las entradas definidas originalmente y las convertir\xE1 en algo que se le pueda pasar al modelo.
Podr\xEDa contener m\xE1s informaci\xF3n y a menudo es un objeto `),Qe=l("code"),Do=o("Dict"),xo=o(" (diccionario)."),la=d(),$=l("p"),Be=l("code"),Oo=o("_forward"),zo=o(" contiene los detalles de la implementaci\xF3n y no deber\xEDa ser invocado de forma directa. "),Ke=l("code"),Io=o("forward"),To=o(` es el
m\xE9todo preferido a utilizar pues contiene verificaciones para asegurar que todo funcione en el dispositivo correcto.
Cualquier cosa que est\xE9 relacionada con un modelo real deber\xEDa ir en el m\xE9todo `),Ve=l("code"),Ao=o("_forward"),So=o(`, todo lo dem\xE1s va en
los m\xE9todos de preprocesamiento y posprocesamiento.`),ra=d(),x=l("p"),Lo=o("Los m\xE9todos "),We=l("code"),Ro=o("postprocess"),No=o(" reciben la salida "),Ze=l("code"),Mo=o("_forward"),Fo=o(` y la convierten en la salida final que decidimos
anteriormente.`),na=d(),C=l("p"),es=l("code"),Yo=o("_sanitize_parameters"),Go=o(` existe para permitir a los usuarios pasar cualesquiera par\xE1metros cuando lo deseen, ya
sea al momento de inicializar el pipeline `),ss=l("code"),Uo=o("pipeline(...., maybe_arg=4)"),Ho=o(` o al momento de invocarlo
`),as=l("code"),Xo=o("pipe = pipeline(...); output = pipe(...., maybe_arg=4)"),Jo=o("."),ia=d(),f=l("p"),Qo=o("El m\xE9todo "),os=l("code"),Bo=o("_sanitize_parameters"),Ko=o(" devuelve 3 diccionarios de kwargs que ser\xE1n pasados directamente a "),ts=l("code"),Vo=o("preprocess"),Wo=o(`,
`),ls=l("code"),Zo=o("_forward"),et=o(" y "),rs=l("code"),st=o("postprocess"),at=o(`. No ingreses nada si el caller no se va a invocar con par\xE1metros adicionales.
Esto permite mantener los par\xE1metros por defecto de la definici\xF3n de la funci\xF3n, lo que es m\xE1s \u201Cnatural\u201D.`),pa=d(),X=l("p"),ot=o("Un ejemplo cl\xE1sico ser\xEDa un argumento "),ns=l("code"),tt=o("top_k"),lt=o(" en el posprocesamiento de una tarea de clasificaci\xF3n."),da=d(),h(ue.$$.fragment),ca=d(),j=l("p"),rt=o("Para lograrlo, actualizaremos nuestro m\xE9todo "),is=l("code"),nt=o("postprocess"),it=o(" con un valor por defecto de "),ps=l("code"),pt=o("5"),dt=o(` y  modificaremos
`),ds=l("code"),ct=o("_sanitize_parameters"),ut=o(" para permitir este nuevo par\xE1metro."),ua=d(),h(me.$$.fragment),ma=d(),Ce=l("p"),mt=o(`Intenta que las entradas y salidas sean muy simples e, idealmente, que puedan serializarse como JSON, pues esto
hace el uso del pipeline muy sencillo sin que el usuario tenga que preocuparse por conocer nuevos tipos de objetos.
Tambi\xE9n es relativamente com\xFAn tener compatibilidad con muchos tipos diferentes de argumentos por facilidad de uso
(por ejemplo, los archivos de audio pueden ser nombres de archivo, URLs o bytes).`),fa=d(),F=l("h2"),J=l("a"),cs=l("span"),h(fe.$$.fragment),ft=d(),us=l("span"),_t=o("A\xF1adirlo a la lista de tareas"),_a=d(),O=l("p"),ht=o("Para registrar tu "),ms=l("code"),bt=o("new-task"),Et=o(` (nueva tarea) en la lista de tareas, debes a\xF1adirla al
`),fs=l("code"),vt=o("PIPELINE_REGISTRY"),qt=o(" (registro de pipelines):"),ha=d(),h(_e.$$.fragment),ba=d(),Q=l("p"),yt=o("Puedes especificar un modelo por defecto si lo deseas, en cuyo caso debe venir con una versi\xF3n espec\xEDfica (que puede ser el nombre de un branch o hash de commit, en este caso usamos "),_s=l("code"),gt=o('"abcdef"'),jt=o("), as\xED como el tipo:"),Ea=d(),h(he.$$.fragment),va=d(),Y=l("h2"),B=l("a"),hs=l("span"),h(be.$$.fragment),wt=d(),bs=l("span"),kt=o("Comparte tu pipeline en el Hub"),qa=d(),K=l("p"),Pt=o(`Para compartir tu pipeline personalizado en el Hub, solo tienes que guardar el c\xF3digo personalizado de tu sub-clase
`),Es=l("code"),$t=o("Pipeline"),Ct=o(` en un archivo de Python. Por ejemplo, digamos que queremos usar un pipeline personalizado para la
clasificaci\xF3n de duplas de oraciones de esta forma:`),ya=d(),h(Ee.$$.fragment),ga=d(),V=l("p"),Dt=o(`La implementaci\xF3n es independiente del framework y funcionar\xE1 con modelos de PyTorch y TensorFlow. Si guardamos
esto en un archivo llamado `),vs=l("code"),xt=o("pair_classification.py"),Ot=o(", podemos importarlo y registrarlo de la siguiente manera:"),ja=d(),h(ve.$$.fragment),wa=d(),W=l("p"),zt=o("Una vez hecho esto, podemos usarlo con un modelo pre-entrenado. Por ejemplo, al modelo "),qs=l("code"),It=o("sgugger/finetuned-bert-mrpc"),Tt=o(`
se le hizo fine-tuning con el dataset MRPC, en el cual se clasifican duplas de oraciones como par\xE1frasis o no.`),ka=d(),h(qe.$$.fragment),Pa=d(),z=l("p"),At=o("Ahora podemos compartirlo en el Hub usando el m\xE9todo "),ys=l("code"),St=o("save_pretrained"),Lt=o(" (guardar pre-entrenado) en un "),gs=l("code"),Rt=o("Repository"),Nt=o(":"),$a=d(),h(ye.$$.fragment),Ca=d(),_=l("p"),Mt=o("Esto copiar\xE1 el archivo donde definiste "),js=l("code"),Ft=o("PairClassificationPipeline"),Yt=o(" dentro de la carpeta "),ws=l("code"),Gt=o('"test-dynamic-pipeline"'),Ut=o(`,
y adem\xE1s guardar\xE1 el modelo y el tokenizer del pipeline, antes de enviar todo al repositorio
`),ks=l("code"),Ht=o("{your_username}/test-dynamic-pipeline"),Xt=o(`. Despu\xE9s de esto, cualquier persona puede usarlo siempre que usen la opci\xF3n
`),Ps=l("code"),Jt=o("trust_remote_code=True"),Qt=o(" (confiar en c\xF3digo remoto):"),Da=d(),h(ge.$$.fragment),xa=d(),G=l("h2"),Z=l("a"),$s=l("span"),h(je.$$.fragment),Bt=d(),Cs=l("span"),Kt=o("A\xF1adir el pipeline a \u{1F917} Transformers"),Oa=d(),I=l("p"),Vt=o(`Si quieres contribuir tu pipeline a la biblioteca \u{1F917} Transformers, tendr\xE1s que a\xF1adirlo a un nuevo m\xF3dulo en el
sub-m\xF3dulo `),Ds=l("code"),Wt=o("pipelines"),Zt=o(` con el c\xF3digo de tu pipeline. Luego, debes a\xF1adirlo a la lista de tareas definidas en
`),xs=l("code"),el=o("pipelines/__init__.py"),sl=o("."),za=d(),ee=l("p"),al=o("A continuaci\xF3n tienes que a\xF1adir las pruebas. Crea un nuevo archivo llamado "),Os=l("code"),ol=o("tests/test_pipelines_MY_PIPELINE.py"),tl=o(`
bas\xE1ndote en las pruebas existentes.`),Ia=d(),w=l("p"),ll=o("La funci\xF3n "),zs=l("code"),rl=o("run_pipeline_test"),nl=o(` ser\xE1 muy gen\xE9rica y se correr\xE1 sobre modelos peque\xF1os escogidos al azar sobre todas las
arquitecturas posibles definidas en `),Is=l("code"),il=o("model_mapping"),pl=o(" y "),Ts=l("code"),dl=o("tf_model_mapping"),cl=o("."),Ta=d(),T=l("p"),ul=o(`Esto es muy importante para probar compatibilidades a futuro, lo que significa que si alguien a\xF1ade un nuevo modelo
para `),As=l("code"),ml=o("XXXForQuestionAnswering"),fl=o(` entonces el pipeline intentar\xE1 ejecutarse con ese modelo. Ya que los modelos son aleatorios,
es imposible verificar los valores como tales, y es por eso que hay un helper `),Ss=l("code"),_l=o("ANY"),hl=o(` que simplemente intentar\xE1 que la
salida tenga el mismo tipo que la salida esperada del pipeline.`),Aa=d(),se=l("p"),bl=o("Tambi\xE9n "),Ls=l("em"),El=o("debes"),vl=o(" implementar 2 (preferiblemente 4) pruebas:"),Sa=d(),k=l("ul"),ae=l("li"),Rs=l("code"),ql=o("test_small_model_pt"),yl=o(` : Define un (1) modelo peque\xF1o para este pipeline (no importa si los resultados no tienen sentido)
y prueba las salidas del pipeline. Los resultados deber\xEDan ser los mismos que en `),Ns=l("code"),gl=o("test_small_model_tf"),jl=o("."),wl=d(),oe=l("li"),Ms=l("code"),kl=o("test_small_model_tf"),Pl=o(` : Define un (1) modelo peque\xF1o para este pipeline (no importa si los resultados no tienen sentido)
y prueba las salidas del pipeline. Los resultados deber\xEDan ser los mismos que en `),Fs=l("code"),$l=o("test_small_model_pt"),Cl=o("."),Dl=d(),te=l("li"),Ys=l("code"),xl=o("test_large_model_pt"),Ol=o(" ("),Gs=l("code"),zl=o("optional"),Il=o(`): Prueba el pipeline en una tarea real en la que los resultados deben tener sentido.
Estas pruebas son lentas y deben marcarse como tales. El objetivo de esto es ejemplificar el pipeline y asegurarse de que
no haya divergencias en versiones futuras.`),Tl=d(),le=l("li"),Us=l("code"),Al=o("test_large_model_tf"),Sl=o(" ("),Hs=l("code"),Ll=o("optional"),Rl=o(`): Prueba el pipeline en una tarea real en la que los resultados deben tener sentido.
Estas pruebas son lentas y deben marcarse como tales. El objetivo de esto es ejemplificar el pipeline y asegurarse de que
no haya divergencias en versiones futuras.`),this.h()},l(e){const i=nn('[data-svelte="svelte-1phssyn"]',document.head);R=r(i,"META",{name:!0,content:!0}),i.forEach(a),Vs=c(e),N=r(e,"H1",{class:!0});var Ra=n(N);U=r(Ra,"A",{id:!0,class:!0,href:!0});var Ml=n(U);Ae=r(Ml,"SPAN",{});var Fl=n(Ae);b(de.$$.fragment,Fl),Fl.forEach(a),Ml.forEach(a),Va=c(Ra),Se=r(Ra,"SPAN",{});var Yl=n(Se);Wa=t(Yl,"\xBFC\xF3mo puedo crear un pipeline personalizado?"),Yl.forEach(a),Ra.forEach(a),Ws=c(e),H=r(e,"P",{});var Na=n(H);Za=t(Na,"En esta gu\xEDa, veremos c\xF3mo crear un pipeline personalizado y c\xF3mo compartirlo en el "),Pe=r(Na,"A",{href:!0});var Gl=n(Pe);eo=t(Gl,"Hub"),Gl.forEach(a),so=t(Na,` o a\xF1adirlo
a la biblioteca \u{1F917} Transformers.`),Na.forEach(a),Zs=c(e),D=r(e,"P",{});var De=n(D);ao=t(De,`En primer lugar, debes decidir las entradas que tu pipeline podr\xE1 recibir. Pueden ser strings, bytes,
diccionarios o lo que te parezca que vaya a ser la entrada m\xE1s apropiada. Intenta mantener estas entradas en un
formato que sea tan Python puro como sea posible, puesto que esto facilita la compatibilidad (incluso con otros
lenguajes de programaci\xF3n por medio de JSON). Estos ser\xE1n los `),Le=r(De,"CODE",{});var Ul=n(Le);oo=t(Ul,"inputs"),Ul.forEach(a),to=t(De," (entradas) del pipeline ("),Re=r(De,"CODE",{});var Hl=n(Re);lo=t(Hl,"preprocess"),Hl.forEach(a),ro=t(De,")."),De.forEach(a),ea=c(e),g=r(e,"P",{});var re=n(g);no=t(re,"Ahora debes definir los "),Ne=r(re,"CODE",{});var Xl=n(Ne);io=t(Xl,"outputs"),Xl.forEach(a),po=t(re," (salidas). Al igual que con los "),Me=r(re,"CODE",{});var Jl=n(Me);co=t(Jl,"inputs"),Jl.forEach(a),uo=t(re,`, entre m\xE1s simple el formato, mejor.
Estas ser\xE1n las salidas del m\xE9todo `),Fe=r(re,"CODE",{});var Ql=n(Fe);mo=t(Ql,"postprocess"),Ql.forEach(a),fo=t(re," (posprocesamiento)."),re.forEach(a),sa=c(e),m=r(e,"P",{});var P=n(m);_o=t(P,"Empieza heredando la clase base "),Ye=r(P,"CODE",{});var Bl=n(Ye);ho=t(Bl,"Pipeline"),Bl.forEach(a),bo=t(P," con los 4 m\xE9todos que debemos implementar: "),Ge=r(P,"CODE",{});var Kl=n(Ge);Eo=t(Kl,"preprocess"),Kl.forEach(a),vo=t(P,` (preprocesamiento),
`),Ue=r(P,"CODE",{});var Vl=n(Ue);qo=t(Vl,"_forward"),Vl.forEach(a),yo=t(P," (ejecuci\xF3n), "),He=r(P,"CODE",{});var Wl=n(He);go=t(Wl,"postprocess"),Wl.forEach(a),jo=t(P," (posprocesamiento) y "),Xe=r(P,"CODE",{});var Zl=n(Xe);wo=t(Zl,"_sanitize_parameters"),Zl.forEach(a),ko=t(P," (verificar par\xE1metros)."),P.forEach(a),aa=c(e),b(ce.$$.fragment,e),oa=c(e),$e=r(e,"P",{});var er=n($e);Po=t(er,`La estructura de este desglose es as\xED para garantizar una compatibilidad m\xE1s o menos transparente con el uso de
CPU/GPU y el pre/posprocesamiento en CPU en varios hilos.`),er.forEach(a),ta=c(e),M=r(e,"P",{});var Xs=n(M);Je=r(Xs,"CODE",{});var sr=n(Je);$o=t(sr,"preprocess"),sr.forEach(a),Co=t(Xs,` tomar\xE1 las entradas definidas originalmente y las convertir\xE1 en algo que se le pueda pasar al modelo.
Podr\xEDa contener m\xE1s informaci\xF3n y a menudo es un objeto `),Qe=r(Xs,"CODE",{});var ar=n(Qe);Do=t(ar,"Dict"),ar.forEach(a),xo=t(Xs," (diccionario)."),Xs.forEach(a),la=c(e),$=r(e,"P",{});var we=n($);Be=r(we,"CODE",{});var or=n(Be);Oo=t(or,"_forward"),or.forEach(a),zo=t(we," contiene los detalles de la implementaci\xF3n y no deber\xEDa ser invocado de forma directa. "),Ke=r(we,"CODE",{});var tr=n(Ke);Io=t(tr,"forward"),tr.forEach(a),To=t(we,` es el
m\xE9todo preferido a utilizar pues contiene verificaciones para asegurar que todo funcione en el dispositivo correcto.
Cualquier cosa que est\xE9 relacionada con un modelo real deber\xEDa ir en el m\xE9todo `),Ve=r(we,"CODE",{});var lr=n(Ve);Ao=t(lr,"_forward"),lr.forEach(a),So=t(we,`, todo lo dem\xE1s va en
los m\xE9todos de preprocesamiento y posprocesamiento.`),we.forEach(a),ra=c(e),x=r(e,"P",{});var xe=n(x);Lo=t(xe,"Los m\xE9todos "),We=r(xe,"CODE",{});var rr=n(We);Ro=t(rr,"postprocess"),rr.forEach(a),No=t(xe," reciben la salida "),Ze=r(xe,"CODE",{});var nr=n(Ze);Mo=t(nr,"_forward"),nr.forEach(a),Fo=t(xe,` y la convierten en la salida final que decidimos
anteriormente.`),xe.forEach(a),na=c(e),C=r(e,"P",{});var ke=n(C);es=r(ke,"CODE",{});var ir=n(es);Yo=t(ir,"_sanitize_parameters"),ir.forEach(a),Go=t(ke,` existe para permitir a los usuarios pasar cualesquiera par\xE1metros cuando lo deseen, ya
sea al momento de inicializar el pipeline `),ss=r(ke,"CODE",{});var pr=n(ss);Uo=t(pr,"pipeline(...., maybe_arg=4)"),pr.forEach(a),Ho=t(ke,` o al momento de invocarlo
`),as=r(ke,"CODE",{});var dr=n(as);Xo=t(dr,"pipe = pipeline(...); output = pipe(...., maybe_arg=4)"),dr.forEach(a),Jo=t(ke,"."),ke.forEach(a),ia=c(e),f=r(e,"P",{});var A=n(f);Qo=t(A,"El m\xE9todo "),os=r(A,"CODE",{});var cr=n(os);Bo=t(cr,"_sanitize_parameters"),cr.forEach(a),Ko=t(A," devuelve 3 diccionarios de kwargs que ser\xE1n pasados directamente a "),ts=r(A,"CODE",{});var ur=n(ts);Vo=t(ur,"preprocess"),ur.forEach(a),Wo=t(A,`,
`),ls=r(A,"CODE",{});var mr=n(ls);Zo=t(mr,"_forward"),mr.forEach(a),et=t(A," y "),rs=r(A,"CODE",{});var fr=n(rs);st=t(fr,"postprocess"),fr.forEach(a),at=t(A,`. No ingreses nada si el caller no se va a invocar con par\xE1metros adicionales.
Esto permite mantener los par\xE1metros por defecto de la definici\xF3n de la funci\xF3n, lo que es m\xE1s \u201Cnatural\u201D.`),A.forEach(a),pa=c(e),X=r(e,"P",{});var Ma=n(X);ot=t(Ma,"Un ejemplo cl\xE1sico ser\xEDa un argumento "),ns=r(Ma,"CODE",{});var _r=n(ns);tt=t(_r,"top_k"),_r.forEach(a),lt=t(Ma," en el posprocesamiento de una tarea de clasificaci\xF3n."),Ma.forEach(a),da=c(e),b(ue.$$.fragment,e),ca=c(e),j=r(e,"P",{});var ne=n(j);rt=t(ne,"Para lograrlo, actualizaremos nuestro m\xE9todo "),is=r(ne,"CODE",{});var hr=n(is);nt=t(hr,"postprocess"),hr.forEach(a),it=t(ne," con un valor por defecto de "),ps=r(ne,"CODE",{});var br=n(ps);pt=t(br,"5"),br.forEach(a),dt=t(ne,` y  modificaremos
`),ds=r(ne,"CODE",{});var Er=n(ds);ct=t(Er,"_sanitize_parameters"),Er.forEach(a),ut=t(ne," para permitir este nuevo par\xE1metro."),ne.forEach(a),ua=c(e),b(me.$$.fragment,e),ma=c(e),Ce=r(e,"P",{});var vr=n(Ce);mt=t(vr,`Intenta que las entradas y salidas sean muy simples e, idealmente, que puedan serializarse como JSON, pues esto
hace el uso del pipeline muy sencillo sin que el usuario tenga que preocuparse por conocer nuevos tipos de objetos.
Tambi\xE9n es relativamente com\xFAn tener compatibilidad con muchos tipos diferentes de argumentos por facilidad de uso
(por ejemplo, los archivos de audio pueden ser nombres de archivo, URLs o bytes).`),vr.forEach(a),fa=c(e),F=r(e,"H2",{class:!0});var Fa=n(F);J=r(Fa,"A",{id:!0,class:!0,href:!0});var qr=n(J);cs=r(qr,"SPAN",{});var yr=n(cs);b(fe.$$.fragment,yr),yr.forEach(a),qr.forEach(a),ft=c(Fa),us=r(Fa,"SPAN",{});var gr=n(us);_t=t(gr,"A\xF1adirlo a la lista de tareas"),gr.forEach(a),Fa.forEach(a),_a=c(e),O=r(e,"P",{});var Oe=n(O);ht=t(Oe,"Para registrar tu "),ms=r(Oe,"CODE",{});var jr=n(ms);bt=t(jr,"new-task"),jr.forEach(a),Et=t(Oe,` (nueva tarea) en la lista de tareas, debes a\xF1adirla al
`),fs=r(Oe,"CODE",{});var wr=n(fs);vt=t(wr,"PIPELINE_REGISTRY"),wr.forEach(a),qt=t(Oe," (registro de pipelines):"),Oe.forEach(a),ha=c(e),b(_e.$$.fragment,e),ba=c(e),Q=r(e,"P",{});var Ya=n(Q);yt=t(Ya,"Puedes especificar un modelo por defecto si lo deseas, en cuyo caso debe venir con una versi\xF3n espec\xEDfica (que puede ser el nombre de un branch o hash de commit, en este caso usamos "),_s=r(Ya,"CODE",{});var kr=n(_s);gt=t(kr,'"abcdef"'),kr.forEach(a),jt=t(Ya,"), as\xED como el tipo:"),Ya.forEach(a),Ea=c(e),b(he.$$.fragment,e),va=c(e),Y=r(e,"H2",{class:!0});var Ga=n(Y);B=r(Ga,"A",{id:!0,class:!0,href:!0});var Pr=n(B);hs=r(Pr,"SPAN",{});var $r=n(hs);b(be.$$.fragment,$r),$r.forEach(a),Pr.forEach(a),wt=c(Ga),bs=r(Ga,"SPAN",{});var Cr=n(bs);kt=t(Cr,"Comparte tu pipeline en el Hub"),Cr.forEach(a),Ga.forEach(a),qa=c(e),K=r(e,"P",{});var Ua=n(K);Pt=t(Ua,`Para compartir tu pipeline personalizado en el Hub, solo tienes que guardar el c\xF3digo personalizado de tu sub-clase
`),Es=r(Ua,"CODE",{});var Dr=n(Es);$t=t(Dr,"Pipeline"),Dr.forEach(a),Ct=t(Ua,` en un archivo de Python. Por ejemplo, digamos que queremos usar un pipeline personalizado para la
clasificaci\xF3n de duplas de oraciones de esta forma:`),Ua.forEach(a),ya=c(e),b(Ee.$$.fragment,e),ga=c(e),V=r(e,"P",{});var Ha=n(V);Dt=t(Ha,`La implementaci\xF3n es independiente del framework y funcionar\xE1 con modelos de PyTorch y TensorFlow. Si guardamos
esto en un archivo llamado `),vs=r(Ha,"CODE",{});var xr=n(vs);xt=t(xr,"pair_classification.py"),xr.forEach(a),Ot=t(Ha,", podemos importarlo y registrarlo de la siguiente manera:"),Ha.forEach(a),ja=c(e),b(ve.$$.fragment,e),wa=c(e),W=r(e,"P",{});var Xa=n(W);zt=t(Xa,"Una vez hecho esto, podemos usarlo con un modelo pre-entrenado. Por ejemplo, al modelo "),qs=r(Xa,"CODE",{});var Or=n(qs);It=t(Or,"sgugger/finetuned-bert-mrpc"),Or.forEach(a),Tt=t(Xa,`
se le hizo fine-tuning con el dataset MRPC, en el cual se clasifican duplas de oraciones como par\xE1frasis o no.`),Xa.forEach(a),ka=c(e),b(qe.$$.fragment,e),Pa=c(e),z=r(e,"P",{});var ze=n(z);At=t(ze,"Ahora podemos compartirlo en el Hub usando el m\xE9todo "),ys=r(ze,"CODE",{});var zr=n(ys);St=t(zr,"save_pretrained"),zr.forEach(a),Lt=t(ze," (guardar pre-entrenado) en un "),gs=r(ze,"CODE",{});var Ir=n(gs);Rt=t(Ir,"Repository"),Ir.forEach(a),Nt=t(ze,":"),ze.forEach(a),$a=c(e),b(ye.$$.fragment,e),Ca=c(e),_=r(e,"P",{});var S=n(_);Mt=t(S,"Esto copiar\xE1 el archivo donde definiste "),js=r(S,"CODE",{});var Tr=n(js);Ft=t(Tr,"PairClassificationPipeline"),Tr.forEach(a),Yt=t(S," dentro de la carpeta "),ws=r(S,"CODE",{});var Ar=n(ws);Gt=t(Ar,'"test-dynamic-pipeline"'),Ar.forEach(a),Ut=t(S,`,
y adem\xE1s guardar\xE1 el modelo y el tokenizer del pipeline, antes de enviar todo al repositorio
`),ks=r(S,"CODE",{});var Sr=n(ks);Ht=t(Sr,"{your_username}/test-dynamic-pipeline"),Sr.forEach(a),Xt=t(S,`. Despu\xE9s de esto, cualquier persona puede usarlo siempre que usen la opci\xF3n
`),Ps=r(S,"CODE",{});var Lr=n(Ps);Jt=t(Lr,"trust_remote_code=True"),Lr.forEach(a),Qt=t(S," (confiar en c\xF3digo remoto):"),S.forEach(a),Da=c(e),b(ge.$$.fragment,e),xa=c(e),G=r(e,"H2",{class:!0});var Ja=n(G);Z=r(Ja,"A",{id:!0,class:!0,href:!0});var Rr=n(Z);$s=r(Rr,"SPAN",{});var Nr=n($s);b(je.$$.fragment,Nr),Nr.forEach(a),Rr.forEach(a),Bt=c(Ja),Cs=r(Ja,"SPAN",{});var Mr=n(Cs);Kt=t(Mr,"A\xF1adir el pipeline a \u{1F917} Transformers"),Mr.forEach(a),Ja.forEach(a),Oa=c(e),I=r(e,"P",{});var Ie=n(I);Vt=t(Ie,`Si quieres contribuir tu pipeline a la biblioteca \u{1F917} Transformers, tendr\xE1s que a\xF1adirlo a un nuevo m\xF3dulo en el
sub-m\xF3dulo `),Ds=r(Ie,"CODE",{});var Fr=n(Ds);Wt=t(Fr,"pipelines"),Fr.forEach(a),Zt=t(Ie,` con el c\xF3digo de tu pipeline. Luego, debes a\xF1adirlo a la lista de tareas definidas en
`),xs=r(Ie,"CODE",{});var Yr=n(xs);el=t(Yr,"pipelines/__init__.py"),Yr.forEach(a),sl=t(Ie,"."),Ie.forEach(a),za=c(e),ee=r(e,"P",{});var Qa=n(ee);al=t(Qa,"A continuaci\xF3n tienes que a\xF1adir las pruebas. Crea un nuevo archivo llamado "),Os=r(Qa,"CODE",{});var Gr=n(Os);ol=t(Gr,"tests/test_pipelines_MY_PIPELINE.py"),Gr.forEach(a),tl=t(Qa,`
bas\xE1ndote en las pruebas existentes.`),Qa.forEach(a),Ia=c(e),w=r(e,"P",{});var ie=n(w);ll=t(ie,"La funci\xF3n "),zs=r(ie,"CODE",{});var Ur=n(zs);rl=t(Ur,"run_pipeline_test"),Ur.forEach(a),nl=t(ie,` ser\xE1 muy gen\xE9rica y se correr\xE1 sobre modelos peque\xF1os escogidos al azar sobre todas las
arquitecturas posibles definidas en `),Is=r(ie,"CODE",{});var Hr=n(Is);il=t(Hr,"model_mapping"),Hr.forEach(a),pl=t(ie," y "),Ts=r(ie,"CODE",{});var Xr=n(Ts);dl=t(Xr,"tf_model_mapping"),Xr.forEach(a),cl=t(ie,"."),ie.forEach(a),Ta=c(e),T=r(e,"P",{});var Te=n(T);ul=t(Te,`Esto es muy importante para probar compatibilidades a futuro, lo que significa que si alguien a\xF1ade un nuevo modelo
para `),As=r(Te,"CODE",{});var Jr=n(As);ml=t(Jr,"XXXForQuestionAnswering"),Jr.forEach(a),fl=t(Te,` entonces el pipeline intentar\xE1 ejecutarse con ese modelo. Ya que los modelos son aleatorios,
es imposible verificar los valores como tales, y es por eso que hay un helper `),Ss=r(Te,"CODE",{});var Qr=n(Ss);_l=t(Qr,"ANY"),Qr.forEach(a),hl=t(Te,` que simplemente intentar\xE1 que la
salida tenga el mismo tipo que la salida esperada del pipeline.`),Te.forEach(a),Aa=c(e),se=r(e,"P",{});var Ba=n(se);bl=t(Ba,"Tambi\xE9n "),Ls=r(Ba,"EM",{});var Br=n(Ls);El=t(Br,"debes"),Br.forEach(a),vl=t(Ba," implementar 2 (preferiblemente 4) pruebas:"),Ba.forEach(a),Sa=c(e),k=r(e,"UL",{});var pe=n(k);ae=r(pe,"LI",{});var Js=n(ae);Rs=r(Js,"CODE",{});var Kr=n(Rs);ql=t(Kr,"test_small_model_pt"),Kr.forEach(a),yl=t(Js,` : Define un (1) modelo peque\xF1o para este pipeline (no importa si los resultados no tienen sentido)
y prueba las salidas del pipeline. Los resultados deber\xEDan ser los mismos que en `),Ns=r(Js,"CODE",{});var Vr=n(Ns);gl=t(Vr,"test_small_model_tf"),Vr.forEach(a),jl=t(Js,"."),Js.forEach(a),wl=c(pe),oe=r(pe,"LI",{});var Qs=n(oe);Ms=r(Qs,"CODE",{});var Wr=n(Ms);kl=t(Wr,"test_small_model_tf"),Wr.forEach(a),Pl=t(Qs,` : Define un (1) modelo peque\xF1o para este pipeline (no importa si los resultados no tienen sentido)
y prueba las salidas del pipeline. Los resultados deber\xEDan ser los mismos que en `),Fs=r(Qs,"CODE",{});var Zr=n(Fs);$l=t(Zr,"test_small_model_pt"),Zr.forEach(a),Cl=t(Qs,"."),Qs.forEach(a),Dl=c(pe),te=r(pe,"LI",{});var Bs=n(te);Ys=r(Bs,"CODE",{});var en=n(Ys);xl=t(en,"test_large_model_pt"),en.forEach(a),Ol=t(Bs," ("),Gs=r(Bs,"CODE",{});var sn=n(Gs);zl=t(sn,"optional"),sn.forEach(a),Il=t(Bs,`): Prueba el pipeline en una tarea real en la que los resultados deben tener sentido.
Estas pruebas son lentas y deben marcarse como tales. El objetivo de esto es ejemplificar el pipeline y asegurarse de que
no haya divergencias en versiones futuras.`),Bs.forEach(a),Tl=c(pe),le=r(pe,"LI",{});var Ks=n(le);Us=r(Ks,"CODE",{});var an=n(Us);Al=t(an,"test_large_model_tf"),an.forEach(a),Sl=t(Ks," ("),Hs=r(Ks,"CODE",{});var on=n(Hs);Ll=t(on,"optional"),on.forEach(a),Rl=t(Ks,`): Prueba el pipeline en una tarea real en la que los resultados deben tener sentido.
Estas pruebas son lentas y deben marcarse como tales. El objetivo de esto es ejemplificar el pipeline y asegurarse de que
no haya divergencias en versiones futuras.`),Ks.forEach(a),pe.forEach(a),this.h()},h(){u(R,"name","hf:doc:metadata"),u(R,"content",JSON.stringify(un)),u(U,"id","cmo-puedo-crear-un-pipeline-personalizado"),u(U,"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"),u(U,"href","#cmo-puedo-crear-un-pipeline-personalizado"),u(N,"class","relative group"),u(Pe,"href","hf.co/models"),u(J,"id","aadirlo-a-la-lista-de-tareas"),u(J,"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"),u(J,"href","#aadirlo-a-la-lista-de-tareas"),u(F,"class","relative group"),u(B,"id","comparte-tu-pipeline-en-el-hub"),u(B,"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"),u(B,"href","#comparte-tu-pipeline-en-el-hub"),u(Y,"class","relative group"),u(Z,"id","aadir-el-pipeline-a-transformers"),u(Z,"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"),u(Z,"href","#aadir-el-pipeline-a-transformers"),u(G,"class","relative group")},m(e,i){s(document.head,R),p(e,Vs,i),p(e,N,i),s(N,U),s(U,Ae),E(de,Ae,null),s(N,Va),s(N,Se),s(Se,Wa),p(e,Ws,i),p(e,H,i),s(H,Za),s(H,Pe),s(Pe,eo),s(H,so),p(e,Zs,i),p(e,D,i),s(D,ao),s(D,Le),s(Le,oo),s(D,to),s(D,Re),s(Re,lo),s(D,ro),p(e,ea,i),p(e,g,i),s(g,no),s(g,Ne),s(Ne,io),s(g,po),s(g,Me),s(Me,co),s(g,uo),s(g,Fe),s(Fe,mo),s(g,fo),p(e,sa,i),p(e,m,i),s(m,_o),s(m,Ye),s(Ye,ho),s(m,bo),s(m,Ge),s(Ge,Eo),s(m,vo),s(m,Ue),s(Ue,qo),s(m,yo),s(m,He),s(He,go),s(m,jo),s(m,Xe),s(Xe,wo),s(m,ko),p(e,aa,i),E(ce,e,i),p(e,oa,i),p(e,$e,i),s($e,Po),p(e,ta,i),p(e,M,i),s(M,Je),s(Je,$o),s(M,Co),s(M,Qe),s(Qe,Do),s(M,xo),p(e,la,i),p(e,$,i),s($,Be),s(Be,Oo),s($,zo),s($,Ke),s(Ke,Io),s($,To),s($,Ve),s(Ve,Ao),s($,So),p(e,ra,i),p(e,x,i),s(x,Lo),s(x,We),s(We,Ro),s(x,No),s(x,Ze),s(Ze,Mo),s(x,Fo),p(e,na,i),p(e,C,i),s(C,es),s(es,Yo),s(C,Go),s(C,ss),s(ss,Uo),s(C,Ho),s(C,as),s(as,Xo),s(C,Jo),p(e,ia,i),p(e,f,i),s(f,Qo),s(f,os),s(os,Bo),s(f,Ko),s(f,ts),s(ts,Vo),s(f,Wo),s(f,ls),s(ls,Zo),s(f,et),s(f,rs),s(rs,st),s(f,at),p(e,pa,i),p(e,X,i),s(X,ot),s(X,ns),s(ns,tt),s(X,lt),p(e,da,i),E(ue,e,i),p(e,ca,i),p(e,j,i),s(j,rt),s(j,is),s(is,nt),s(j,it),s(j,ps),s(ps,pt),s(j,dt),s(j,ds),s(ds,ct),s(j,ut),p(e,ua,i),E(me,e,i),p(e,ma,i),p(e,Ce,i),s(Ce,mt),p(e,fa,i),p(e,F,i),s(F,J),s(J,cs),E(fe,cs,null),s(F,ft),s(F,us),s(us,_t),p(e,_a,i),p(e,O,i),s(O,ht),s(O,ms),s(ms,bt),s(O,Et),s(O,fs),s(fs,vt),s(O,qt),p(e,ha,i),E(_e,e,i),p(e,ba,i),p(e,Q,i),s(Q,yt),s(Q,_s),s(_s,gt),s(Q,jt),p(e,Ea,i),E(he,e,i),p(e,va,i),p(e,Y,i),s(Y,B),s(B,hs),E(be,hs,null),s(Y,wt),s(Y,bs),s(bs,kt),p(e,qa,i),p(e,K,i),s(K,Pt),s(K,Es),s(Es,$t),s(K,Ct),p(e,ya,i),E(Ee,e,i),p(e,ga,i),p(e,V,i),s(V,Dt),s(V,vs),s(vs,xt),s(V,Ot),p(e,ja,i),E(ve,e,i),p(e,wa,i),p(e,W,i),s(W,zt),s(W,qs),s(qs,It),s(W,Tt),p(e,ka,i),E(qe,e,i),p(e,Pa,i),p(e,z,i),s(z,At),s(z,ys),s(ys,St),s(z,Lt),s(z,gs),s(gs,Rt),s(z,Nt),p(e,$a,i),E(ye,e,i),p(e,Ca,i),p(e,_,i),s(_,Mt),s(_,js),s(js,Ft),s(_,Yt),s(_,ws),s(ws,Gt),s(_,Ut),s(_,ks),s(ks,Ht),s(_,Xt),s(_,Ps),s(Ps,Jt),s(_,Qt),p(e,Da,i),E(ge,e,i),p(e,xa,i),p(e,G,i),s(G,Z),s(Z,$s),E(je,$s,null),s(G,Bt),s(G,Cs),s(Cs,Kt),p(e,Oa,i),p(e,I,i),s(I,Vt),s(I,Ds),s(Ds,Wt),s(I,Zt),s(I,xs),s(xs,el),s(I,sl),p(e,za,i),p(e,ee,i),s(ee,al),s(ee,Os),s(Os,ol),s(ee,tl),p(e,Ia,i),p(e,w,i),s(w,ll),s(w,zs),s(zs,rl),s(w,nl),s(w,Is),s(Is,il),s(w,pl),s(w,Ts),s(Ts,dl),s(w,cl),p(e,Ta,i),p(e,T,i),s(T,ul),s(T,As),s(As,ml),s(T,fl),s(T,Ss),s(Ss,_l),s(T,hl),p(e,Aa,i),p(e,se,i),s(se,bl),s(se,Ls),s(Ls,El),s(se,vl),p(e,Sa,i),p(e,k,i),s(k,ae),s(ae,Rs),s(Rs,ql),s(ae,yl),s(ae,Ns),s(Ns,gl),s(ae,jl),s(k,wl),s(k,oe),s(oe,Ms),s(Ms,kl),s(oe,Pl),s(oe,Fs),s(Fs,$l),s(oe,Cl),s(k,Dl),s(k,te),s(te,Ys),s(Ys,xl),s(te,Ol),s(te,Gs),s(Gs,zl),s(te,Il),s(k,Tl),s(k,le),s(le,Us),s(Us,Al),s(le,Sl),s(le,Hs),s(Hs,Ll),s(le,Rl),La=!0},p:pn,i(e){La||(v(de.$$.fragment,e),v(ce.$$.fragment,e),v(ue.$$.fragment,e),v(me.$$.fragment,e),v(fe.$$.fragment,e),v(_e.$$.fragment,e),v(he.$$.fragment,e),v(be.$$.fragment,e),v(Ee.$$.fragment,e),v(ve.$$.fragment,e),v(qe.$$.fragment,e),v(ye.$$.fragment,e),v(ge.$$.fragment,e),v(je.$$.fragment,e),La=!0)},o(e){q(de.$$.fragment,e),q(ce.$$.fragment,e),q(ue.$$.fragment,e),q(me.$$.fragment,e),q(fe.$$.fragment,e),q(_e.$$.fragment,e),q(he.$$.fragment,e),q(be.$$.fragment,e),q(Ee.$$.fragment,e),q(ve.$$.fragment,e),q(qe.$$.fragment,e),q(ye.$$.fragment,e),q(ge.$$.fragment,e),q(je.$$.fragment,e),La=!1},d(e){a(R),e&&a(Vs),e&&a(N),y(de),e&&a(Ws),e&&a(H),e&&a(Zs),e&&a(D),e&&a(ea),e&&a(g),e&&a(sa),e&&a(m),e&&a(aa),y(ce,e),e&&a(oa),e&&a($e),e&&a(ta),e&&a(M),e&&a(la),e&&a($),e&&a(ra),e&&a(x),e&&a(na),e&&a(C),e&&a(ia),e&&a(f),e&&a(pa),e&&a(X),e&&a(da),y(ue,e),e&&a(ca),e&&a(j),e&&a(ua),y(me,e),e&&a(ma),e&&a(Ce),e&&a(fa),e&&a(F),y(fe),e&&a(_a),e&&a(O),e&&a(ha),y(_e,e),e&&a(ba),e&&a(Q),e&&a(Ea),y(he,e),e&&a(va),e&&a(Y),y(be),e&&a(qa),e&&a(K),e&&a(ya),y(Ee,e),e&&a(ga),e&&a(V),e&&a(ja),y(ve,e),e&&a(wa),e&&a(W),e&&a(ka),y(qe,e),e&&a(Pa),e&&a(z),e&&a($a),y(ye,e),e&&a(Ca),e&&a(_),e&&a(Da),y(ge,e),e&&a(xa),e&&a(G),y(je),e&&a(Oa),e&&a(I),e&&a(za),e&&a(ee),e&&a(Ia),e&&a(w),e&&a(Ta),e&&a(T),e&&a(Aa),e&&a(se),e&&a(Sa),e&&a(k)}}}const un={local:"cmo-puedo-crear-un-pipeline-personalizado",sections:[{local:"aadirlo-a-la-lista-de-tareas",title:"A\xF1adirlo a la lista de tareas"},{local:"comparte-tu-pipeline-en-el-hub",title:"Comparte tu pipeline en el Hub"},{local:"aadir-el-pipeline-a-transformers",title:"A\xF1adir el pipeline a \u{1F917} Transformers"}],title:"\xBFC\xF3mo puedo crear un pipeline personalizado?"};function mn(Nl){return dn(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class bn extends tn{constructor(R){super();ln(this,R,mn,cn,rn,{})}}export{bn as default,un as metadata};
