import{s as In,o as qn,n as q}from"../chunks/scheduler.5f3e6389.js";import{S as En,i as Nn,e as d,s as n,c as u,h as Gn,a as p,d as r,b as l,f as j,g as m,j as T,k as $,l as o,m as b,n as g,t as h,o as f,p as v}from"../chunks/index.62df735e.js";import{C as Rn,H as W,E as Fn}from"../chunks/MermaidChart.svelte_svelte_type_style_lang.e306bd5b.js";import{D as x}from"../chunks/Docstring.88e8f8ba.js";import{C}from"../chunks/CodeBlock.dc1e8be0.js";import{E as I}from"../chunks/ExampleCodeBlock.7e3fcb1f.js";function Zn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBJTIzJTIwU2VudGltZW50JTIwYW5hbHlzaXMlMjBldmFsdWF0b3IlMEFldmFsdWF0b3IoJTIyc2VudGltZW50LWFuYWx5c2lzJTIyKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-comment"># Sentiment analysis evaluator</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>evaluator(<span class="hljs-string">&quot;sentiment-analysis&quot;</span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function zn(_){let a,w="Example:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJyb3R0ZW5fdG9tYXRvZXMnJTJDJTIwc3BsaXQlM0QlMjJ0cmFpbiUyMiklMEFldmFsdWF0b3IuY2hlY2tfcmVxdWlyZWRfY29sdW1ucyhkYXRhJTJDJTIwJTdCJTIyaW5wdXRfY29sdW1uJTIyJTNBJTIwJTIydGV4dCUyMiUyQyUyMCUyMmxhYmVsX2NvbHVtbiUyMiUzQSUyMCUyMmxhYmVsJTIyJTdEKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;rotten_tomatoes&#x27;, split=&quot;</span>train<span class="hljs-string">&quot;)
&gt;&gt;&gt; evaluator.check_required_columns(data, {&quot;</span>input_column<span class="hljs-string">&quot;: &quot;</span>text<span class="hljs-string">&quot;, &quot;</span>label_column<span class="hljs-string">&quot;: &quot;</span>label<span class="hljs-string">&quot;})</span>`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-11lpom8"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function An(_){let a,w="Example:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZXZhbHVhdG9yKCUyMnRleHQtY2xhc3NpZmljYXRpb24lMjIpLmdldF9kYXRhc2V0X3NwbGl0KGRhdGElM0QlMjJyb3R0ZW5fdG9tYXRvZXMlMjIp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span>evaluator(<span class="hljs-string">&quot;text-classification&quot;</span>).get_dataset_split(data=<span class="hljs-string">&quot;rotten_tomatoes&quot;</span>)
WARNING:evaluate.evaluator.base:Dataset split <span class="hljs-keyword">not</span> defined! Automatically evaluating <span class="hljs-keyword">with</span> split: TEST
<span class="hljs-string">&#x27;test&#x27;</span>`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-11lpom8"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Xn(_){let a,w="Example:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZXZhbHVhdG9yKCUyMnRleHQtY2xhc3NpZmljYXRpb24lMjIpLmxvYWRfZGF0YShkYXRhJTNEJTIycm90dGVuX3RvbWF0b2VzJTIyJTJDJTIwc3BsaXQlM0QlMjJ0cmFpbiUyMik=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span>evaluator(<span class="hljs-string">&quot;text-classification&quot;</span>).load_data(data=<span class="hljs-string">&quot;rotten_tomatoes&quot;</span>, split=<span class="hljs-string">&quot;train&quot;</span>)
Dataset({
    features: [<span class="hljs-string">&#x27;text&#x27;</span>, <span class="hljs-string">&#x27;label&#x27;</span>],
    num_rows: <span class="hljs-number">8530</span>
})`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-11lpom8"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Wn(_){let a,w="Example:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBJTBBZHMlMjAlM0QlMjBsb2FkX2RhdGFzZXQoJTIycm90dGVuX3RvbWF0b2VzJTIyJTJDJTIwc3BsaXQlM0QlMjJ0cmFpbiUyMiklMEFldmFsdWF0b3IoJTIydGV4dC1jbGFzc2lmaWNhdGlvbiUyMikucHJlcGFyZV9kYXRhKGRzJTJDJTIwaW5wdXRfY29sdW1uJTNEJTIydGV4dCUyMiUyQyUyMHNlY29uZF9pbnB1dF9jb2x1bW4lM0ROb25lJTJDJTIwbGFiZWxfY29sdW1uJTNEJTIybGFiZWwlMjIp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset

<span class="hljs-meta">&gt;&gt;&gt; </span>ds = load_dataset(<span class="hljs-string">&quot;rotten_tomatoes&quot;</span>, split=<span class="hljs-string">&quot;train&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>evaluator(<span class="hljs-string">&quot;text-classification&quot;</span>).prepare_data(ds, input_column=<span class="hljs-string">&quot;text&quot;</span>, second_input_column=<span class="hljs-literal">None</span>, label_column=<span class="hljs-string">&quot;label&quot;</span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-11lpom8"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Yn(_){let a,w="Example:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZXZhbHVhdG9yKCUyMnRleHQtY2xhc3NpZmljYXRpb24lMjIpLnByZXBhcmVfbWV0cmljKCUyMmFjY3VyYWN5JTIyKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span>evaluator(<span class="hljs-string">&quot;text-classification&quot;</span>).prepare_metric(<span class="hljs-string">&quot;accuracy&quot;</span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-11lpom8"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Bn(_){let a,w="Example:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZXZhbHVhdG9yKCUyMnRleHQtY2xhc3NpZmljYXRpb24lMjIpLnByZXBhcmVfcGlwZWxpbmUobW9kZWxfb3JfcGlwZWxpbmUlM0QlMjJkaXN0aWxiZXJ0LWJhc2UtdW5jYXNlZCUyMik=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span>evaluator(<span class="hljs-string">&quot;text-classification&quot;</span>).prepare_pipeline(model_or_pipeline=<span class="hljs-string">&quot;distilbert-base-uncased&quot;</span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-11lpom8"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Vn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIyaW1hZ2UtY2xhc3NpZmljYXRpb24lMjIpJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJiZWFucyUyMiUyQyUyMHNwbGl0JTNEJTIydGVzdCU1QiUzQTQwJTVEJTIyKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIybmF0ZXJhdyUyRnZpdC1iYXNlLWJlYW5zJTIyJTJDJTBBJTIwJTIwJTIwJTIwZGF0YSUzRGRhdGElMkMlMEElMjAlMjAlMjAlMjBsYWJlbF9jb2x1bW4lM0QlMjJsYWJlbHMlMjIlMkMlMEElMjAlMjAlMjAlMjBtZXRyaWMlM0QlMjJhY2N1cmFjeSUyMiUyQyUwQSUyMCUyMCUyMCUyMGxhYmVsX21hcHBpbmclM0QlN0InYW5ndWxhcl9sZWFmX3Nwb3QnJTNBJTIwMCUyQyUyMCdiZWFuX3J1c3QnJTNBJTIwMSUyQyUyMCdoZWFsdGh5JyUzQSUyMDIlN0QlMkMlMEElMjAlMjAlMjAlMjBzdHJhdGVneSUzRCUyMmJvb3RzdHJhcCUyMiUwQSk=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;image-classification&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;beans&quot;</span>, split=<span class="hljs-string">&quot;test[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;nateraw/vit-base-beans&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_column=<span class="hljs-string">&quot;labels&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;accuracy&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_mapping={<span class="hljs-string">&#x27;angular_leaf_spot&#x27;</span>: <span class="hljs-number">0</span>, <span class="hljs-string">&#x27;bean_rust&#x27;</span>: <span class="hljs-number">1</span>, <span class="hljs-string">&#x27;healthy&#x27;</span>: <span class="hljs-number">2</span>},
<span class="hljs-meta">&gt;&gt;&gt; </span>    strategy=<span class="hljs-string">&quot;bootstrap&quot;</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Dn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIycXVlc3Rpb24tYW5zd2VyaW5nJTIyKSUwQWRhdGElMjAlM0QlMjBsb2FkX2RhdGFzZXQoJTIyc3F1YWQlMjIlMkMlMjBzcGxpdCUzRCUyMnZhbGlkYXRpb24lNUIlM0EyJTVEJTIyKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIyc3NobGVpZmVyJTJGdGlueS1kaXN0aWxiZXJ0LWJhc2UtY2FzZWQtZGlzdGlsbGVkLXNxdWFkJTIyJTJDJTBBJTIwJTIwJTIwJTIwZGF0YSUzRGRhdGElMkMlMEElMjAlMjAlMjAlMjBtZXRyaWMlM0QlMjJzcXVhZCUyMiUyQyUwQSk=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;question-answering&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;squad&quot;</span>, split=<span class="hljs-string">&quot;validation[:2]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;sshleifer/tiny-distilbert-base-cased-distilled-squad&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;squad&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Qn(_){let a,w;return a=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIycXVlc3Rpb24tYW5zd2VyaW5nJTIyKSUwQWRhdGElMjAlM0QlMjBsb2FkX2RhdGFzZXQoJTIyc3F1YWRfdjIlMjIlMkMlMjBzcGxpdCUzRCUyMnZhbGlkYXRpb24lNUIlM0EyJTVEJTIyKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIybXJtODQ4OCUyRmJlcnQtdGlueS1maW5ldHVuZWQtc3F1YWR2MiUyMiUyQyUwQSUyMCUyMCUyMCUyMGRhdGElM0RkYXRhJTJDJTBBJTIwJTIwJTIwJTIwbWV0cmljJTNEJTIyc3F1YWRfdjIlMjIlMkMlMEElMjAlMjAlMjAlMjBzcXVhZF92Ml9mb3JtYXQlM0RUcnVlJTJDJTBBKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;question-answering&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;squad_v2&quot;</span>, split=<span class="hljs-string">&quot;validation[:2]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;mrm8488/bert-tiny-finetuned-squadv2&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;squad_v2&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    squad_v2_format=<span class="hljs-literal">True</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){u(a.$$.fragment)},l(i){m(a.$$.fragment,i)},m(i,s){g(a,i,s),w=!0},p:q,i(i){w||(h(a.$$.fragment,i),w=!0)},o(i){f(a.$$.fragment,i),w=!1},d(i){v(a,i)}}}function Sn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIydGV4dC1jbGFzc2lmaWNhdGlvbiUyMiklMEFkYXRhJTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMmltZGIlMjIlMkMlMjBzcGxpdCUzRCUyMnRlc3QlNUIlM0EyJTVEJTIyKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIyaHVnZ2luZ2ZhY2UlMkZwcnVuZWJlcnQtYmFzZS11bmNhc2VkLTYtZmluZXBydW5lZC13LWRpc3RpbC1tbmxpJTIyJTJDJTBBJTIwJTIwJTIwJTIwZGF0YSUzRGRhdGElMkMlMEElMjAlMjAlMjAlMjBtZXRyaWMlM0QlMjJhY2N1cmFjeSUyMiUyQyUwQSUyMCUyMCUyMCUyMGxhYmVsX21hcHBpbmclM0QlN0IlMjJMQUJFTF8wJTIyJTNBJTIwMC4wJTJDJTIwJTIyTEFCRUxfMSUyMiUzQSUyMDEuMCU3RCUyQyUwQSUyMCUyMCUyMCUyMHN0cmF0ZWd5JTNEJTIyYm9vdHN0cmFwJTIyJTJDJTBBJTIwJTIwJTIwJTIwbl9yZXNhbXBsZXMlM0QxMCUyQyUwQSUyMCUyMCUyMCUyMHJhbmRvbV9zdGF0ZSUzRDAlMEEp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;text-classification&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;imdb&quot;</span>, split=<span class="hljs-string">&quot;test[:2]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;huggingface/prunebert-base-uncased-6-finepruned-w-distil-mnli&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;accuracy&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_mapping={<span class="hljs-string">&quot;LABEL_0&quot;</span>: <span class="hljs-number">0.0</span>, <span class="hljs-string">&quot;LABEL_1&quot;</span>: <span class="hljs-number">1.0</span>},
<span class="hljs-meta">&gt;&gt;&gt; </span>    strategy=<span class="hljs-string">&quot;bootstrap&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    n_resamples=<span class="hljs-number">10</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    random_state=<span class="hljs-number">0</span>
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Pn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIydG9rZW4tY2xhc3NpZmljYXRpb24lMjIpJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJjb25sbDIwMDMlMjIlMkMlMjBzcGxpdCUzRCUyMnZhbGlkYXRpb24lNUIlM0EyJTVEJTIyKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIyZWxhc3RpYyUyRmRpc3RpbGJlcnQtYmFzZS11bmNhc2VkLWZpbmV0dW5lZC1jb25sbDAzLWVuZ2xpc2glMjIlMkMlMEElMjAlMjAlMjAlMjBkYXRhJTNEZGF0YSUyQyUwQSUyMCUyMCUyMCUyMG1ldHJpYyUzRCUyMnNlcWV2YWwlMjIlMkMlMEEp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;token-classification&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;conll2003&quot;</span>, split=<span class="hljs-string">&quot;validation[:2]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;elastic/distilbert-base-uncased-finetuned-conll03-english&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;seqeval&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Ln(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIydGV4dDJ0ZXh0LWdlbmVyYXRpb24lMjIpJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJjbm5fZGFpbHltYWlsJTIyJTJDJTIwJTIyMy4wLjAlMjIlMkMlMjBzcGxpdCUzRCUyMnZhbGlkYXRpb24lNUIlM0E0MCU1RCUyMiklMEFyZXN1bHRzJTIwJTNEJTIwdGFza19ldmFsdWF0b3IuY29tcHV0ZSglMEElMjAlMjAlMjAlMjBtb2RlbF9vcl9waXBlbGluZSUzRCUyMmZhY2Vib29rJTJGYmFydC1sYXJnZS1jbm4lMjIlMkMlMEElMjAlMjAlMjAlMjBkYXRhJTNEZGF0YSUyQyUwQSUyMCUyMCUyMCUyMGlucHV0X2NvbHVtbiUzRCUyMmFydGljbGUlMjIlMkMlMEElMjAlMjAlMjAlMjBsYWJlbF9jb2x1bW4lM0QlMjJoaWdobGlnaHRzJTIyJTJDJTBBJTIwJTIwJTIwJTIwbWV0cmljJTNEJTIycm91Z2UlMjIlMkMlMEEp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;text2text-generation&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;cnn_dailymail&quot;</span>, <span class="hljs-string">&quot;3.0.0&quot;</span>, split=<span class="hljs-string">&quot;validation[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;facebook/bart-large-cnn&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    input_column=<span class="hljs-string">&quot;article&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_column=<span class="hljs-string">&quot;highlights&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;rouge&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Hn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIyc3VtbWFyaXphdGlvbiUyMiklMEFkYXRhJTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMmNubl9kYWlseW1haWwlMjIlMkMlMjAlMjIzLjAuMCUyMiUyQyUyMHNwbGl0JTNEJTIydmFsaWRhdGlvbiU1QiUzQTQwJTVEJTIyKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIyZmFjZWJvb2slMkZiYXJ0LWxhcmdlLWNubiUyMiUyQyUwQSUyMCUyMCUyMCUyMGRhdGElM0RkYXRhJTJDJTBBJTIwJTIwJTIwJTIwaW5wdXRfY29sdW1uJTNEJTIyYXJ0aWNsZSUyMiUyQyUwQSUyMCUyMCUyMCUyMGxhYmVsX2NvbHVtbiUzRCUyMmhpZ2hsaWdodHMlMjIlMkMlMEEp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;summarization&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;cnn_dailymail&quot;</span>, <span class="hljs-string">&quot;3.0.0&quot;</span>, split=<span class="hljs-string">&quot;validation[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;facebook/bart-large-cnn&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    input_column=<span class="hljs-string">&quot;article&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_column=<span class="hljs-string">&quot;highlights&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function On(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIydHJhbnNsYXRpb24lMjIpJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJ3bXQxOSUyMiUyQyUyMCUyMmZyLWRlJTIyJTJDJTIwc3BsaXQlM0QlMjJ2YWxpZGF0aW9uJTVCJTNBNDAlNUQlMjIpJTBBZGF0YSUyMCUzRCUyMGRhdGEubWFwKGxhbWJkYSUyMHglM0ElMjAlN0IlMjJ0ZXh0JTIyJTNBJTIweCU1QiUyMnRyYW5zbGF0aW9uJTIyJTVEJTVCJTIyZGUlMjIlNUQlMkMlMjAlMjJsYWJlbCUyMiUzQSUyMHglNUIlMjJ0cmFuc2xhdGlvbiUyMiU1RCU1QiUyMmZyJTIyJTVEJTdEKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIySGVsc2lua2ktTkxQJTJGb3B1cy1tdC1kZS1mciUyMiUyQyUwQSUyMCUyMCUyMCUyMGRhdGElM0RkYXRhJTJDJTBBKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;translation&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;wmt19&quot;</span>, <span class="hljs-string">&quot;fr-de&quot;</span>, split=<span class="hljs-string">&quot;validation[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = data.<span class="hljs-built_in">map</span>(<span class="hljs-keyword">lambda</span> x: {<span class="hljs-string">&quot;text&quot;</span>: x[<span class="hljs-string">&quot;translation&quot;</span>][<span class="hljs-string">&quot;de&quot;</span>], <span class="hljs-string">&quot;label&quot;</span>: x[<span class="hljs-string">&quot;translation&quot;</span>][<span class="hljs-string">&quot;fr&quot;</span>]})
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;Helsinki-NLP/opus-mt-de-fr&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function Kn(_){let a,w="Examples:",i,s,y;return s=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIyYXV0b21hdGljLXNwZWVjaC1yZWNvZ25pdGlvbiUyMiklMEFkYXRhJTIwJTNEJTIwbG9hZF9kYXRhc2V0KCUyMm1vemlsbGEtZm91bmRhdGlvbiUyRmNvbW1vbl92b2ljZV8xMV8wJTIyJTJDJTIwJTIyZW4lMjIlMkMlMjBzcGxpdCUzRCUyMnZhbGlkYXRpb24lNUIlM0E0MCU1RCUyMiklMEFyZXN1bHRzJTIwJTNEJTIwdGFza19ldmFsdWF0b3IuY29tcHV0ZSglMEElMjAlMjAlMjAlMjBtb2RlbF9vcl9waXBlbGluZSUzRCUyMmh0dHBzJTNBJTJGJTJGaHVnZ2luZ2ZhY2UuY28lMkZvcGVuYWklMkZ3aGlzcGVyLXRpbnkuZW4lMjIlMkMlMEElMjAlMjAlMjAlMjBkYXRhJTNEZGF0YSUyQyUwQSUyMCUyMCUyMCUyMGlucHV0X2NvbHVtbiUzRCUyMnBhdGglMjIlMkMlMEElMjAlMjAlMjAlMjBsYWJlbF9jb2x1bW4lM0QlMjJzZW50ZW5jZSUyMiUyQyUwQSUyMCUyMCUyMCUyMG1ldHJpYyUzRCUyMndlciUyMiUyQyUwQSk=",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset
<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;automatic-speech-recognition&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;mozilla-foundation/common_voice_11_0&quot;</span>, <span class="hljs-string">&quot;en&quot;</span>, split=<span class="hljs-string">&quot;validation[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;https://huggingface.co/openai/whisper-tiny.en&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    input_column=<span class="hljs-string">&quot;path&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_column=<span class="hljs-string">&quot;sentence&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;wer&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){a=d("p"),a.textContent=w,i=n(),u(s.$$.fragment)},l(t){a=p(t,"P",{"data-svelte-h":!0}),T(a)!=="svelte-kvfsh7"&&(a.textContent=w),i=l(t),m(s.$$.fragment,t)},m(t,M){b(t,a,M),b(t,i,M),g(s,t,M),y=!0},p:q,i(t){y||(h(s.$$.fragment,t),y=!0)},o(t){f(s.$$.fragment,t),y=!1},d(t){t&&(r(a),r(i)),v(s,t)}}}function el(_){let a,w;return a=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBJTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIyYXVkaW8tY2xhc3NpZmljYXRpb24lMjIpJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJzdXBlcmIlMjIlMkMlMjAna3MnJTJDJTIwc3BsaXQlM0QlMjJ0ZXN0JTVCJTNBNDAlNUQlMjIpJTBBcmVzdWx0cyUyMCUzRCUyMHRhc2tfZXZhbHVhdG9yLmNvbXB1dGUoJTBBJTIwJTIwJTIwJTIwbW9kZWxfb3JfcGlwZWxpbmUlM0QlMjIlMjJzdXBlcmIlMkZ3YXYydmVjMi1iYXNlLXN1cGVyYi1rcyUyMiUyMiUyQyUwQSUyMCUyMCUyMCUyMGRhdGElM0RkYXRhJTJDJTBBJTIwJTIwJTIwJTIwbGFiZWxfY29sdW1uJTNEJTIybGFiZWwlMjIlMkMlMEElMjAlMjAlMjAlMjBpbnB1dF9jb2x1bW4lM0QlMjJmaWxlJTIyJTJDJTBBJTIwJTIwJTIwJTIwbWV0cmljJTNEJTIyYWNjdXJhY3klMjIlMkMlMEElMjAlMjAlMjAlMjBsYWJlbF9tYXBwaW5nJTNEJTdCMCUzQSUyMCUyMnllcyUyMiUyQyUyMDElM0ElMjAlMjJubyUyMiUyQyUyMDIlM0ElMjAlMjJ1cCUyMiUyQyUyMDMlM0ElMjAlMjJkb3duJTIyJTdEJTBBKQ==",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset

<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;audio-classification&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;superb&quot;</span>, <span class="hljs-string">&#x27;ks&#x27;</span>, split=<span class="hljs-string">&quot;test[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;&quot;</span>superb/wav2vec2-base-superb-ks<span class="hljs-string">&quot;&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_column=<span class="hljs-string">&quot;label&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    input_column=<span class="hljs-string">&quot;file&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;accuracy&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_mapping={<span class="hljs-number">0</span>: <span class="hljs-string">&quot;yes&quot;</span>, <span class="hljs-number">1</span>: <span class="hljs-string">&quot;no&quot;</span>, <span class="hljs-number">2</span>: <span class="hljs-string">&quot;up&quot;</span>, <span class="hljs-number">3</span>: <span class="hljs-string">&quot;down&quot;</span>}
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){u(a.$$.fragment)},l(i){m(a.$$.fragment,i)},m(i,s){g(a,i,s),w=!0},p:q,i(i){w||(h(a.$$.fragment,i),w=!0)},o(i){f(a.$$.fragment,i),w=!1},d(i){v(a,i)}}}function tl(_){let a,w;return a=new C({props:{code:"ZnJvbSUyMGV2YWx1YXRlJTIwaW1wb3J0JTIwZXZhbHVhdG9yJTBBZnJvbSUyMGRhdGFzZXRzJTIwaW1wb3J0JTIwbG9hZF9kYXRhc2V0JTBBJTBBdGFza19ldmFsdWF0b3IlMjAlM0QlMjBldmFsdWF0b3IoJTIyYXVkaW8tY2xhc3NpZmljYXRpb24lMjIpJTBBZGF0YSUyMCUzRCUyMGxvYWRfZGF0YXNldCglMjJzdXBlcmIlMjIlMkMlMjAna3MnJTJDJTIwc3BsaXQlM0QlMjJ0ZXN0JTVCJTNBNDAlNUQlMjIpJTBBZGF0YSUyMCUzRCUyMGRhdGEubWFwKGxhbWJkYSUyMGV4YW1wbGUlM0ElMjAlN0IlMjJhdWRpbyUyMiUzQSUyMGV4YW1wbGUlNUIlMjJhdWRpbyUyMiU1RCU1QiUyMmFycmF5JTIyJTVEJTdEKSUwQXJlc3VsdHMlMjAlM0QlMjB0YXNrX2V2YWx1YXRvci5jb21wdXRlKCUwQSUyMCUyMCUyMCUyMG1vZGVsX29yX3BpcGVsaW5lJTNEJTIyJTIyc3VwZXJiJTJGd2F2MnZlYzItYmFzZS1zdXBlcmIta3MlMjIlMjIlMkMlMEElMjAlMjAlMjAlMjBkYXRhJTNEZGF0YSUyQyUwQSUyMCUyMCUyMCUyMGxhYmVsX2NvbHVtbiUzRCUyMmxhYmVsJTIyJTJDJTBBJTIwJTIwJTIwJTIwaW5wdXRfY29sdW1uJTNEJTIyYXVkaW8lMjIlMkMlMEElMjAlMjAlMjAlMjBtZXRyaWMlM0QlMjJhY2N1cmFjeSUyMiUyQyUwQSUyMCUyMCUyMCUyMGxhYmVsX21hcHBpbmclM0QlN0IwJTNBJTIwJTIyeWVzJTIyJTJDJTIwMSUzQSUyMCUyMm5vJTIyJTJDJTIwMiUzQSUyMCUyMnVwJTIyJTJDJTIwMyUzQSUyMCUyMmRvd24lMjIlN0QlMEEp",highlighted:`<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> evaluate <span class="hljs-keyword">import</span> evaluator
<span class="hljs-meta">&gt;&gt;&gt; </span><span class="hljs-keyword">from</span> datasets <span class="hljs-keyword">import</span> load_dataset

<span class="hljs-meta">&gt;&gt;&gt; </span>task_evaluator = evaluator(<span class="hljs-string">&quot;audio-classification&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = load_dataset(<span class="hljs-string">&quot;superb&quot;</span>, <span class="hljs-string">&#x27;ks&#x27;</span>, split=<span class="hljs-string">&quot;test[:40]&quot;</span>)
<span class="hljs-meta">&gt;&gt;&gt; </span>data = data.<span class="hljs-built_in">map</span>(<span class="hljs-keyword">lambda</span> example: {<span class="hljs-string">&quot;audio&quot;</span>: example[<span class="hljs-string">&quot;audio&quot;</span>][<span class="hljs-string">&quot;array&quot;</span>]})
<span class="hljs-meta">&gt;&gt;&gt; </span>results = task_evaluator.compute(
<span class="hljs-meta">&gt;&gt;&gt; </span>    model_or_pipeline=<span class="hljs-string">&quot;&quot;</span>superb/wav2vec2-base-superb-ks<span class="hljs-string">&quot;&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    data=data,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_column=<span class="hljs-string">&quot;label&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    input_column=<span class="hljs-string">&quot;audio&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    metric=<span class="hljs-string">&quot;accuracy&quot;</span>,
<span class="hljs-meta">&gt;&gt;&gt; </span>    label_mapping={<span class="hljs-number">0</span>: <span class="hljs-string">&quot;yes&quot;</span>, <span class="hljs-number">1</span>: <span class="hljs-string">&quot;no&quot;</span>, <span class="hljs-number">2</span>: <span class="hljs-string">&quot;up&quot;</span>, <span class="hljs-number">3</span>: <span class="hljs-string">&quot;down&quot;</span>}
<span class="hljs-meta">&gt;&gt;&gt; </span>)`,wrap:!1}}),{c(){u(a.$$.fragment)},l(i){m(a.$$.fragment,i)},m(i,s){g(a,i,s),w=!0},p:q,i(i){w||(h(a.$$.fragment,i),w=!0)},o(i){f(a.$$.fragment,i),w=!1},d(i){v(a,i)}}}function al(_){let a,w,i,s,y,t,M,Fa,Ye,As="The evaluator classes for automatic evaluation.",Za,Be,za,Ve,Xs="The main entry point for using the evaluator:",Aa,Y,De,fo,Wt,Ws=`Utility factory method to build an <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.Evaluator">Evaluator</a>.
Evaluators encapsulate a task and a default metric name. They leverage <code>pipeline</code> functionality from <code>transformers</code>
to simplify the evaluation of multiple combinations of models, datasets and metrics for a given task.`,vo,we,Xa,Qe,Ys="The base class for all evaluator classes:",Wa,J,Se,yo,Yt,Bs=`The <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.Evaluator">Evaluator</a> class is the class from which all evaluators inherit. Refer to this class for methods shared across
different evaluators.
Base class implementing evaluator operations.`,bo,O,Pe,Mo,Bt,Vs="Ensure the columns required for the evaluation are present in the dataset.",wo,Te,To,_e,Le,_o,Vt,Ds="Compute and return metrics.",$o,K,He,jo,Dt,Qs="Infers which split to use if <code>None</code> is given.",xo,$e,Jo,ee,Oe,Uo,Qt,Ss="Load dataset with given subset and split.",Co,je,ko,xe,Ke,Io,St,Ps="A core method of the <code>Evaluator</code> class, which processes the pipeline outputs for compatibility with the metric.",qo,te,et,Eo,Pt,Ls="Prepare data.",No,Je,Go,ae,tt,Ro,Lt,Hs="Prepare metric.",Fo,Ue,Zo,oe,at,zo,Ht,Os="Prepare pipeline.",Ao,Ce,Ya,ot,Ba,st,Va,B,nt,Xo,Ot,Ks=`Image classification evaluator.
This image classification evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>image-classification</code>.
Methods in this class assume a data format compatible with the <code>ImageClassificationPipeline</code>.`,Wo,se,lt,Yo,Kt,en="Compute the metric for a given pipeline and dataset combination.",Bo,ke,Da,rt,Qa,N,it,Vo,ea,tn=`Question answering evaluator. This evaluator handles
<a href="https://huggingface.co/docs/transformers/task_summary#extractive-question-answering" rel="nofollow"><strong>extractive</strong> question answering</a>,
where the answer to the question is extracted from a context.`,Do,ta,an=`This question answering evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>question-answering</code>.`,Qo,aa,on=`Methods in this class assume a data format compatible with the
<code>QuestionAnsweringPipeline</code>.`,So,F,ct,Po,oa,sn="Compute the metric for a given pipeline and dataset combination.",Lo,Ie,Ho,dt,nn=`<p>Datasets where the answer may be missing in the context are supported, for example SQuAD v2 dataset. In this case, it is safer to pass <code>squad_v2_format=True</code> to
the compute() call.</p>`,Oo,qe,Sa,pt,Pa,V,ut,Ko,sa,ln=`Text classification evaluator.
This text classification evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>text-classification</code> or with a <code>&quot;sentiment-analysis&quot;</code> alias.
Methods in this class assume a data format compatible with the <a href="https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.TextClassificationPipeline" rel="nofollow">TextClassificationPipeline</a> - a single textual
feature as input and a categorical label as output.`,es,ne,mt,ts,na,rn="Compute the metric for a given pipeline and dataset combination.",as,Ee,La,gt,Ha,G,ht,os,la,cn="Token classification evaluator.",ss,ra,dn=`This token classification evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>token-classification</code>.`,ns,ia,pn='Methods in this class assume a data format compatible with the <a href="https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.TokenClassificationPipeline" rel="nofollow">TokenClassificationPipeline</a>.',ls,E,ft,rs,ca,un="Compute the metric for a given pipeline and dataset combination.",is,da,mn='The dataset input and label columns are expected to be formatted as a list of words and a list of labels respectively, following <a href="https://huggingface.co/datasets/conll2003" rel="nofollow">conll2003 dataset</a>. Datasets whose inputs are single strings, and labels are a list of offset are not supported.',cs,Ne,ds,Ge,pa,gn="For example, the following dataset format is accepted by the evaluator:",ps,vt,us,Re,ua,hn="For example, the following dataset format is <strong>not</strong> accepted by the evaluator:",ms,yt,Oa,bt,Ka,D,Mt,gs,ma,fn=`Text generation evaluator.
This Text generation evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>text-generation</code>.
Methods in this class assume a data format compatible with the <a href="https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.TextGenerationPipeline" rel="nofollow">TextGenerationPipeline</a>.`,hs,ga,wt,eo,Tt,to,Q,_t,fs,ha,vn=`Text2Text generation evaluator.
This Text2Text generation evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>text2text-generation</code>.
Methods in this class assume a data format compatible with the <code>Text2TextGenerationPipeline</code>.`,vs,le,$t,ys,fa,yn="Compute the metric for a given pipeline and dataset combination.",bs,Fe,ao,jt,oo,S,xt,Ms,va,bn=`Text summarization evaluator.
This text summarization evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>summarization</code>.
Methods in this class assume a data format compatible with the <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.SummarizationEvaluator">SummarizationEvaluator</a>.`,ws,re,Jt,Ts,ya,Mn="Compute the metric for a given pipeline and dataset combination.",_s,Ze,so,Ut,no,P,Ct,$s,ba,wn=`Translation evaluator.
This translation generation evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>translation</code>.
Methods in this class assume a data format compatible with the <code>TranslationPipeline</code>.`,js,ie,kt,xs,Ma,Tn="Compute the metric for a given pipeline and dataset combination.",Js,ze,lo,It,ro,L,qt,Us,wa,_n=`Automatic speech recognition evaluator.
This automatic speech recognition evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>automatic-speech-recognition</code>.
Methods in this class assume a data format compatible with the <code>AutomaticSpeechRecognitionPipeline</code>.`,Cs,ce,Et,ks,Ta,$n="Compute the metric for a given pipeline and dataset combination.",Is,Ae,io,Nt,co,H,Gt,qs,_a,jn=`Audio classification evaluator.
This audio classification evaluator can currently be loaded from <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.evaluator">evaluator()</a> using the default task name
<code>audio-classification</code>.
Methods in this class assume a data format compatible with the <a href="https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.AudioClassificationPipeline" rel="nofollow">transformers.AudioClassificationPipeline</a>.`,Es,k,Rt,Ns,$a,xn="Compute the metric for a given pipeline and dataset combination.",Gs,ja,Jn="Examples:",Rs,Ft,Un='<p>Remember that, in order to process audio files, you need ffmpeg installed (<a href="https://ffmpeg.org/download.html" rel="nofollow">https://ffmpeg.org/download.html</a>)</p>',Fs,Xe,Zs,Zt,Cn=`<p>The evaluator supports raw audio data as well, in the form of a numpy array. However, be aware that calling
the audio column automatically decodes and resamples the audio files, which can be slow for large datasets.</p>`,zs,We,po,zt,uo,Ra,mo;return y=new Rn({props:{containerStyle:"float: right; margin-left: 10px; display: inline-flex; position: relative; z-index: 10;"}}),M=new W({props:{title:"Evaluator",local:"evaluator",headingTag:"h1"}}),Be=new W({props:{title:"Evaluator classes",local:"evaluate.evaluator",headingTag:"h2"}}),De=new x({props:{name:"evaluate.evaluator",anchor:"evaluate.evaluator",parameters:[{name:"task",val:": str = None"}],parametersDescription:[{anchor:"evaluate.evaluator.task",description:`<strong>task</strong> (<code>str</code>) &#x2014;
The task defining which evaluator will be returned. Currently accepted tasks are:
<ul>
<li><code>&quot;image-classification&quot;</code>: will return a <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.ImageClassificationEvaluator">ImageClassificationEvaluator</a>.</li>
<li><code>&quot;question-answering&quot;</code>: will return a <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.QuestionAnsweringEvaluator">QuestionAnsweringEvaluator</a>.</li>
<li><code>&quot;text-classification&quot;</code> (alias <code>&quot;sentiment-analysis&quot;</code> available): will return a <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.TextClassificationEvaluator">TextClassificationEvaluator</a>.</li>
<li><code>&quot;token-classification&quot;</code>: will return a <a href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.TokenClassificationEvaluator">TokenClassificationEvaluator</a>.</li>
</ul>`,name:"task"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/__init__.py#L113",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>An evaluator suitable for the task.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><a
  href="/docs/evaluate/main/en/package_reference/evaluator_classes#evaluate.Evaluator"
>Evaluator</a></p>
`}}),we=new I({props:{anchor:"evaluate.evaluator.example",$$slots:{default:[Zn]},$$scope:{ctx:_}}}),Se=new x({props:{name:"class evaluate.Evaluator",anchor:"evaluate.Evaluator",parameters:[{name:"task",val:": str"},{name:"default_metric_name",val:": str = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L102"}}),Pe=new x({props:{name:"check_required_columns",anchor:"evaluate.Evaluator.check_required_columns",parameters:[{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset]"},{name:"columns_names",val:": typing.Dict[str, str]"}],parametersDescription:[{anchor:"evaluate.Evaluator.check_required_columns.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>) &#x2014;
Specifies the dataset we will run evaluation on.`,name:"data"},{anchor:"evaluate.Evaluator.check_required_columns.columns_names",description:`<strong>columns_names</strong> (<code>List[str]</code>) &#x2014;
List of column names to check in the dataset. The keys are the arguments to the <a href="/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule.compute">evaluate.EvaluationModule.compute()</a> method,
while the values are the column names to check.`,name:"columns_names"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L295"}}),Te=new I({props:{anchor:"evaluate.Evaluator.check_required_columns.example",$$slots:{default:[zn]},$$scope:{ctx:_}}}),Le=new x({props:{name:"compute_metric",anchor:"evaluate.Evaluator.compute_metric",parameters:[{name:"metric",val:": EvaluationModule"},{name:"metric_inputs",val:": typing.Dict"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"random_state",val:": typing.Optional[int] = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L517"}}),He=new x({props:{name:"get_dataset_split",anchor:"evaluate.Evaluator.get_dataset_split",parameters:[{name:"data",val:""},{name:"subset",val:" = None"},{name:"split",val:" = None"}],parametersDescription:[{anchor:"evaluate.Evaluator.get_dataset_split.data",description:`<strong>data</strong> (<code>str</code>) &#x2014;
Name of dataset.`,name:"data"},{anchor:"evaluate.Evaluator.get_dataset_split.subset",description:`<strong>subset</strong> (<code>str</code>) &#x2014;
Name of config for datasets with multiple configurations (e.g. &#x2018;glue/cola&#x2019;).`,name:"subset"},{anchor:"evaluate.Evaluator.get_dataset_split.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Split to use.`,name:"split"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L321",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>str</code> containing which split to use</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>split</code></p>
`}}),$e=new I({props:{anchor:"evaluate.Evaluator.get_dataset_split.example",$$slots:{default:[An]},$$scope:{ctx:_}}}),Oe=new x({props:{name:"load_data",anchor:"evaluate.Evaluator.load_data",parameters:[{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset]"},{name:"subset",val:": str = None"},{name:"split",val:": str = None"}],parametersDescription:[{anchor:"evaluate.Evaluator.load_data.data",description:`<strong>data</strong> (<code>Dataset</code> or <code>str</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of
type <code>str</code>, we treat it as the dataset name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.Evaluator.load_data.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Specifies dataset subset to be passed to <code>name</code> in <code>load_dataset</code>. To be
used with datasets with several configurations (e.g. glue/sst2).`,name:"subset"},{anchor:"evaluate.Evaluator.load_data.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
User-defined dataset split by name (e.g. train, validation, test). Supports slice-split (<code>test[:n]</code>).
If not defined and data is a <code>str</code> type, will automatically select the best one via <code>choose_split()</code>.`,name:"split"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L350",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>Loaded dataset which will be used for evaluation.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p>data (<code>Dataset</code>)</p>
`}}),je=new I({props:{anchor:"evaluate.Evaluator.load_data.example",$$slots:{default:[Xn]},$$scope:{ctx:_}}}),Ke=new x({props:{name:"predictions_processor",anchor:"evaluate.Evaluator.predictions_processor",parameters:[{name:"*args",val:""},{name:"**kwargs",val:""}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L211"}}),et=new x({props:{name:"prepare_data",anchor:"evaluate.Evaluator.prepare_data",parameters:[{name:"data",val:": Dataset"},{name:"input_column",val:": str"},{name:"label_column",val:": str"},{name:"*args",val:""},{name:"**kwargs",val:""}],parametersDescription:[{anchor:"evaluate.Evaluator.prepare_data.data",description:`<strong>data</strong> (<code>Dataset</code>) &#x2014;
Specifies the dataset we will run evaluation on.`,name:"data"},{anchor:"evaluate.Evaluator.prepare_data.input_column",description:`<strong>input_column</strong> (<code>str</code>, defaults to <code>&quot;text&quot;</code>) &#x2014;
The name of the column containing the text feature in the dataset specified by <code>data</code>.`,name:"input_column"},{anchor:"evaluate.Evaluator.prepare_data.second_input_column(str,",description:`<strong>second_input_column(<code>str</code>,</strong> <em>optional</em>) &#x2014;
The name of the column containing the second text feature if there is one. Otherwise, set to <code>None</code>.`,name:"second_input_column(str,"},{anchor:"evaluate.Evaluator.prepare_data.label_column",description:`<strong>label_column</strong> (<code>str</code>, defaults to <code>&quot;label&quot;</code>) &#x2014;
The name of the column containing the labels in the dataset specified by <code>data</code>.`,name:"label_column"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L390",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>metric inputs.
<code>list</code>:  pipeline inputs.</p>
`,returnType:`<script context="module">export const metadata = 'undefined';<\/script>


<p><code>dict</code></p>
`}}),Je=new I({props:{anchor:"evaluate.Evaluator.prepare_data.example",$$slots:{default:[Wn]},$$scope:{ctx:_}}}),tt=new x({props:{name:"prepare_metric",anchor:"evaluate.Evaluator.prepare_metric",parameters:[{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule]"}],parametersDescription:[{anchor:"evaluate.Evaluator.prepare_metric.metric",description:`<strong>metric</strong> (<code>str</code> or <a href="/docs/evaluate/main/en/package_reference/main_classes#evaluate.EvaluationModule">EvaluationModule</a>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L480",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The loaded metric.</p>
`}}),Ue=new I({props:{anchor:"evaluate.Evaluator.prepare_metric.example",$$slots:{default:[Yn]},$$scope:{ctx:_}}}),at=new x({props:{name:"prepare_pipeline",anchor:"evaluate.Evaluator.prepare_pipeline",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')]"},{name:"tokenizer",val:": typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('FeatureExtractionMixin')] = None"},{name:"feature_extractor",val:": typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('FeatureExtractionMixin')] = None"},{name:"device",val:": int = None"}],parametersDescription:[{anchor:"evaluate.Evaluator.prepare_pipeline.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <a href="https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.Pipeline" rel="nofollow">Pipeline</a> or <code>Callable</code> or <a href="https://huggingface.co/docs/transformers/main/en/main_classes/model#transformers.PreTrainedModel" rel="nofollow">PreTrainedModel</a> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task. If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <a href="https://huggingface.co/docs/transformers/main/en/main_classes/pipelines#transformers.Pipeline" rel="nofollow">Pipeline</a> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.Evaluator.prepare_pipeline.preprocessor",description:`<strong>preprocessor</strong> (<a href="https://huggingface.co/docs/transformers/main/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase" rel="nofollow">PreTrainedTokenizerBase</a> or <a href="https://huggingface.co/docs/transformers/main/en/main_classes/feature_extractor#transformers.FeatureExtractionMixin" rel="nofollow">FeatureExtractionMixin</a>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default preprocessor if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"preprocessor"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L422",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>The initialized pipeline.</p>
`}}),Ce=new I({props:{anchor:"evaluate.Evaluator.prepare_pipeline.example",$$slots:{default:[Bn]},$$scope:{ctx:_}}}),ot=new W({props:{title:"The task specific evaluators",local:"the-task-specific-evaluators",headingTag:"h2"}}),st=new W({props:{title:"ImageClassificationEvaluator",local:"evaluate.ImageClassificationEvaluator",headingTag:"h3"}}),nt=new x({props:{name:"class evaluate.ImageClassificationEvaluator",anchor:"evaluate.ImageClassificationEvaluator",parameters:[{name:"task",val:" = 'image-classification'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/image_classification.py#L49"}}),lt=new x({props:{name:"compute",anchor:"evaluate.ImageClassificationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"feature_extractor",val:": typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'image'"},{name:"label_column",val:": str = 'label'"},{name:"label_mapping",val:": typing.Optional[typing.Dict[str, numbers.Number]] = None"}],parametersDescription:[{anchor:"evaluate.ImageClassificationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.ImageClassificationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.ImageClassificationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.ImageClassificationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.ImageClassificationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.ImageClassificationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.ImageClassificationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.ImageClassificationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.ImageClassificationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.ImageClassificationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.ImageClassificationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/image_classification.py#L68",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),ke=new I({props:{anchor:"evaluate.ImageClassificationEvaluator.compute.example",$$slots:{default:[Vn]},$$scope:{ctx:_}}}),rt=new W({props:{title:"QuestionAnsweringEvaluator",local:"evaluate.QuestionAnsweringEvaluator",headingTag:"h3"}}),it=new x({props:{name:"class evaluate.QuestionAnsweringEvaluator",anchor:"evaluate.QuestionAnsweringEvaluator",parameters:[{name:"task",val:" = 'question-answering'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/question_answering.py#L75"}}),ct=new x({props:{name:"compute",anchor:"evaluate.QuestionAnsweringEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"question_column",val:": str = 'question'"},{name:"context_column",val:": str = 'context'"},{name:"id_column",val:": str = 'id'"},{name:"label_column",val:": str = 'answers'"},{name:"squad_v2_format",val:": typing.Optional[bool] = None"}],parametersDescription:[{anchor:"evaluate.QuestionAnsweringEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.QuestionAnsweringEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/question_answering.py#L144",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Ie=new I({props:{anchor:"evaluate.QuestionAnsweringEvaluator.compute.example",$$slots:{default:[Dn]},$$scope:{ctx:_}}}),qe=new I({props:{anchor:"evaluate.QuestionAnsweringEvaluator.compute.example-2",$$slots:{default:[Qn]},$$scope:{ctx:_}}}),pt=new W({props:{title:"TextClassificationEvaluator",local:"evaluate.TextClassificationEvaluator",headingTag:"h3"}}),ut=new x({props:{name:"class evaluate.TextClassificationEvaluator",anchor:"evaluate.TextClassificationEvaluator",parameters:[{name:"task",val:" = 'text-classification'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text_classification.py#L51"}}),mt=new x({props:{name:"compute",anchor:"evaluate.TextClassificationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"feature_extractor",val:": typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'text'"},{name:"second_input_column",val:": typing.Optional[str] = None"},{name:"label_column",val:": str = 'label'"},{name:"label_mapping",val:": typing.Optional[typing.Dict[str, numbers.Number]] = None"}],parametersDescription:[{anchor:"evaluate.TextClassificationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.TextClassificationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.TextClassificationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.TextClassificationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.TextClassificationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.TextClassificationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.TextClassificationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.TextClassificationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.TextClassificationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.TextClassificationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.TextClassificationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text_classification.py#L89",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Ee=new I({props:{anchor:"evaluate.TextClassificationEvaluator.compute.example",$$slots:{default:[Sn]},$$scope:{ctx:_}}}),gt=new W({props:{title:"TokenClassificationEvaluator",local:"evaluate.TokenClassificationEvaluator",headingTag:"h3"}}),ht=new x({props:{name:"class evaluate.TokenClassificationEvaluator",anchor:"evaluate.TokenClassificationEvaluator",parameters:[{name:"task",val:" = 'token-classification'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/token_classification.py#L84"}}),ft=new x({props:{name:"compute",anchor:"evaluate.TokenClassificationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": str = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": typing.Optional[int] = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'tokens'"},{name:"label_column",val:": str = 'ner_tags'"},{name:"join_by",val:": typing.Optional[str] = ' '"}],parametersDescription:[{anchor:"evaluate.TokenClassificationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.TokenClassificationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.TokenClassificationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.TokenClassificationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.TokenClassificationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.TokenClassificationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.TokenClassificationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.TokenClassificationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.TokenClassificationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.TokenClassificationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.TokenClassificationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/token_classification.py#L212",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Ne=new I({props:{anchor:"evaluate.TokenClassificationEvaluator.compute.example",$$slots:{default:[Pn]},$$scope:{ctx:_}}}),vt=new C({props:{code:"ZGF0YXNldCUyMCUzRCUyMERhdGFzZXQuZnJvbV9kaWN0KCUwQSUyMCUyMCUyMCUyMG1hcHBpbmclM0QlN0IlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJ0b2tlbnMlMjIlM0ElMjAlNUIlNUIlMjJOZXclMjIlMkMlMjAlMjJZb3JrJTIyJTJDJTIwJTIyaXMlMjIlMkMlMjAlMjJhJTIyJTJDJTIwJTIyY2l0eSUyMiUyQyUyMCUyMmFuZCUyMiUyQyUyMCUyMkZlbGl4JTIyJTJDJTIwJTIyYSUyMiUyQyUyMCUyMnBlcnNvbiUyMiUyQyUyMCUyMi4lMjIlNUQlNUQlMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJuZXJfdGFncyUyMiUzQSUyMCU1QiU1QjElMkMlMjAyJTJDJTIwMCUyQyUyMDAlMkMlMjAwJTJDJTIwMCUyQyUyMDMlMkMlMjAwJTJDJTIwMCUyQyUyMDAlNUQlNUQlMkMlMEElMjAlMjAlMjAlMjAlN0QlMkMlMEElMjAlMjAlMjAlMjBmZWF0dXJlcyUzREZlYXR1cmVzKCU3QiUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMnRva2VucyUyMiUzQSUyMFNlcXVlbmNlKGZlYXR1cmUlM0RWYWx1ZShkdHlwZSUzRCUyMnN0cmluZyUyMikpJTJDJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIybmVyX3RhZ3MlMjIlM0ElMjBTZXF1ZW5jZShmZWF0dXJlJTNEQ2xhc3NMYWJlbChuYW1lcyUzRCU1QiUyMk8lMjIlMkMlMjAlMjJCLUxPQyUyMiUyQyUyMCUyMkktTE9DJTIyJTJDJTIwJTIyQi1QRVIlMjIlMkMlMjAlMjJJLVBFUiUyMiU1RCkpJTJDJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTdEKSUyQyUwQSk=",highlighted:`dataset = Dataset.from_dict(
    mapping={
        <span class="hljs-string">&quot;tokens&quot;</span>: [[<span class="hljs-string">&quot;New&quot;</span>, <span class="hljs-string">&quot;York&quot;</span>, <span class="hljs-string">&quot;is&quot;</span>, <span class="hljs-string">&quot;a&quot;</span>, <span class="hljs-string">&quot;city&quot;</span>, <span class="hljs-string">&quot;and&quot;</span>, <span class="hljs-string">&quot;Felix&quot;</span>, <span class="hljs-string">&quot;a&quot;</span>, <span class="hljs-string">&quot;person&quot;</span>, <span class="hljs-string">&quot;.&quot;</span>]],
        <span class="hljs-string">&quot;ner_tags&quot;</span>: [[<span class="hljs-number">1</span>, <span class="hljs-number">2</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">3</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>]],
    },
    features=Features({
        <span class="hljs-string">&quot;tokens&quot;</span>: <span class="hljs-type">Sequence</span>(feature=Value(dtype=<span class="hljs-string">&quot;string&quot;</span>)),
        <span class="hljs-string">&quot;ner_tags&quot;</span>: <span class="hljs-type">Sequence</span>(feature=ClassLabel(names=[<span class="hljs-string">&quot;O&quot;</span>, <span class="hljs-string">&quot;B-LOC&quot;</span>, <span class="hljs-string">&quot;I-LOC&quot;</span>, <span class="hljs-string">&quot;B-PER&quot;</span>, <span class="hljs-string">&quot;I-PER&quot;</span>])),
        }),
)`,wrap:!1}}),yt=new C({props:{code:"ZGF0YXNldCUyMCUzRCUyMERhdGFzZXQuZnJvbV9kaWN0KCUwQSUyMCUyMCUyMCUyMG1hcHBpbmclM0QlN0IlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJ0b2tlbnMlMjIlM0ElMjAlNUIlNUIlMjJOZXclMjBZb3JrJTIwaXMlMjBhJTIwY2l0eSUyMGFuZCUyMEZlbGl4JTIwYSUyMHBlcnNvbi4lMjIlNUQlNUQlMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJzdGFydHMlMjIlM0ElMjAlNUIlNUIwJTJDJTIwMjMlNUQlNUQlMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJlbmRzJTIyJTNBJTIwJTVCJTVCNyUyQyUyMDI3JTVEJTVEJTJDJTBBJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIwJTIybmVyX3RhZ3MlMjIlM0ElMjAlNUIlNUIlMjJMT0MlMjIlMkMlMjAlMjJQRVIlMjIlNUQlNUQlMkMlMEElMjAlMjAlMjAlMjAlN0QlMkMlMEElMjAlMjAlMjAlMjBmZWF0dXJlcyUzREZlYXR1cmVzKCU3QiUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMnRva2VucyUyMiUzQSUyMFZhbHVlKGR0eXBlJTNEJTIyc3RyaW5nJTIyKSUyQyUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMnN0YXJ0cyUyMiUzQSUyMFNlcXVlbmNlKGZlYXR1cmUlM0RWYWx1ZShkdHlwZSUzRCUyMmludDMyJTIyKSklMkMlMEElMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjAlMjJlbmRzJTIyJTNBJTIwU2VxdWVuY2UoZmVhdHVyZSUzRFZhbHVlKGR0eXBlJTNEJTIyaW50MzIlMjIpKSUyQyUwQSUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMCUyMm5lcl90YWdzJTIyJTNBJTIwU2VxdWVuY2UoZmVhdHVyZSUzRFZhbHVlKGR0eXBlJTNEJTIyc3RyaW5nJTIyKSklMkMlMEElMjAlMjAlMjAlMjAlN0QpJTJDJTBBKQ==",highlighted:`dataset = Dataset.from_dict(
    mapping={
        <span class="hljs-string">&quot;tokens&quot;</span>: [[<span class="hljs-string">&quot;New York is a city and Felix a person.&quot;</span>]],
        <span class="hljs-string">&quot;starts&quot;</span>: [[<span class="hljs-number">0</span>, <span class="hljs-number">23</span>]],
        <span class="hljs-string">&quot;ends&quot;</span>: [[<span class="hljs-number">7</span>, <span class="hljs-number">27</span>]],
        <span class="hljs-string">&quot;ner_tags&quot;</span>: [[<span class="hljs-string">&quot;LOC&quot;</span>, <span class="hljs-string">&quot;PER&quot;</span>]],
    },
    features=Features({
        <span class="hljs-string">&quot;tokens&quot;</span>: Value(dtype=<span class="hljs-string">&quot;string&quot;</span>),
        <span class="hljs-string">&quot;starts&quot;</span>: <span class="hljs-type">Sequence</span>(feature=Value(dtype=<span class="hljs-string">&quot;int32&quot;</span>)),
        <span class="hljs-string">&quot;ends&quot;</span>: <span class="hljs-type">Sequence</span>(feature=Value(dtype=<span class="hljs-string">&quot;int32&quot;</span>)),
        <span class="hljs-string">&quot;ner_tags&quot;</span>: <span class="hljs-type">Sequence</span>(feature=Value(dtype=<span class="hljs-string">&quot;string&quot;</span>)),
    }),
)`,wrap:!1}}),bt=new W({props:{title:"TextGenerationEvaluator",local:"evaluate.TextGenerationEvaluator",headingTag:"h3"}}),Mt=new x({props:{name:"class evaluate.TextGenerationEvaluator",anchor:"evaluate.TextGenerationEvaluator",parameters:[{name:"task",val:" = 'text-generation'"},{name:"default_metric_name",val:" = None"},{name:"predictions_prefix",val:": str = 'generated'"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text_generation.py#L31"}}),wt=new x({props:{name:"compute",anchor:"evaluate.TextGenerationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"feature_extractor",val:": typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'text'"},{name:"label_column",val:": str = 'label'"},{name:"label_mapping",val:": typing.Optional[typing.Dict[str, numbers.Number]] = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/base.py#L218"}}),Tt=new W({props:{title:"Text2TextGenerationEvaluator",local:"evaluate.Text2TextGenerationEvaluator",headingTag:"h3"}}),_t=new x({props:{name:"class evaluate.Text2TextGenerationEvaluator",anchor:"evaluate.Text2TextGenerationEvaluator",parameters:[{name:"task",val:" = 'text2text-generation'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text2text_generation.py#L88"}}),$t=new x({props:{name:"compute",anchor:"evaluate.Text2TextGenerationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'text'"},{name:"label_column",val:": str = 'label'"},{name:"generation_kwargs",val:": dict = None"}],parametersDescription:[{anchor:"evaluate.Text2TextGenerationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:</p>
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.input_column",description:`<strong>input_column</strong> (<code>str</code>, defaults to <code>&quot;text&quot;</code>) &#x2014;
the name of the column containing the input text in the dataset specified by <code>data</code>.`,name:"input_column"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.label_column",description:`<strong>label_column</strong> (<code>str</code>, defaults to <code>&quot;label&quot;</code>) &#x2014;
the name of the column containing the labels in the dataset specified by <code>data</code>.`,name:"label_column"},{anchor:"evaluate.Text2TextGenerationEvaluator.compute.generation_kwargs",description:`<strong>generation_kwargs</strong> (<code>Dict</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The generation kwargs are passed to the pipeline and set the text generation strategy.`,name:"generation_kwargs"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text2text_generation.py#L105",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Fe=new I({props:{anchor:"evaluate.Text2TextGenerationEvaluator.compute.example",$$slots:{default:[Ln]},$$scope:{ctx:_}}}),jt=new W({props:{title:"SummarizationEvaluator",local:"evaluate.SummarizationEvaluator",headingTag:"h3"}}),xt=new x({props:{name:"class evaluate.SummarizationEvaluator",anchor:"evaluate.SummarizationEvaluator",parameters:[{name:"task",val:" = 'summarization'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text2text_generation.py#L152"}}),Jt=new x({props:{name:"compute",anchor:"evaluate.SummarizationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'text'"},{name:"label_column",val:": str = 'label'"},{name:"generation_kwargs",val:": dict = None"}],parametersDescription:[{anchor:"evaluate.SummarizationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.SummarizationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.SummarizationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.SummarizationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.SummarizationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.SummarizationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.SummarizationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:</p>
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.SummarizationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.SummarizationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.SummarizationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.SummarizationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"},{anchor:"evaluate.SummarizationEvaluator.compute.input_column",description:`<strong>input_column</strong> (<code>str</code>, defaults to <code>&quot;text&quot;</code>) &#x2014;
the name of the column containing the input text in the dataset specified by <code>data</code>.`,name:"input_column"},{anchor:"evaluate.SummarizationEvaluator.compute.label_column",description:`<strong>label_column</strong> (<code>str</code>, defaults to <code>&quot;label&quot;</code>) &#x2014;
the name of the column containing the labels in the dataset specified by <code>data</code>.`,name:"label_column"},{anchor:"evaluate.SummarizationEvaluator.compute.generation_kwargs",description:`<strong>generation_kwargs</strong> (<code>Dict</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The generation kwargs are passed to the pipeline and set the text generation strategy.`,name:"generation_kwargs"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text2text_generation.py#L166",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Ze=new I({props:{anchor:"evaluate.SummarizationEvaluator.compute.example",$$slots:{default:[Hn]},$$scope:{ctx:_}}}),Ut=new W({props:{title:"TranslationEvaluator",local:"evaluate.TranslationEvaluator",headingTag:"h3"}}),Ct=new x({props:{name:"class evaluate.TranslationEvaluator",anchor:"evaluate.TranslationEvaluator",parameters:[{name:"task",val:" = 'translation'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text2text_generation.py#L211"}}),kt=new x({props:{name:"compute",anchor:"evaluate.TranslationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'text'"},{name:"label_column",val:": str = 'label'"},{name:"generation_kwargs",val:": dict = None"}],parametersDescription:[{anchor:"evaluate.TranslationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.TranslationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.TranslationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.TranslationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.TranslationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.TranslationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.TranslationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:</p>
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.TranslationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.TranslationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.TranslationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.TranslationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"},{anchor:"evaluate.TranslationEvaluator.compute.input_column",description:`<strong>input_column</strong> (<code>str</code>, defaults to <code>&quot;text&quot;</code>) &#x2014;
the name of the column containing the input text in the dataset specified by <code>data</code>.`,name:"input_column"},{anchor:"evaluate.TranslationEvaluator.compute.label_column",description:`<strong>label_column</strong> (<code>str</code>, defaults to <code>&quot;label&quot;</code>) &#x2014;
the name of the column containing the labels in the dataset specified by <code>data</code>.`,name:"label_column"},{anchor:"evaluate.TranslationEvaluator.compute.generation_kwargs",description:`<strong>generation_kwargs</strong> (<code>Dict</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The generation kwargs are passed to the pipeline and set the text generation strategy.`,name:"generation_kwargs"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/text2text_generation.py#L225",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),ze=new I({props:{anchor:"evaluate.TranslationEvaluator.compute.example",$$slots:{default:[On]},$$scope:{ctx:_}}}),It=new W({props:{title:"AutomaticSpeechRecognitionEvaluator",local:"evaluate.AutomaticSpeechRecognitionEvaluator",headingTag:"h3"}}),qt=new x({props:{name:"class evaluate.AutomaticSpeechRecognitionEvaluator",anchor:"evaluate.AutomaticSpeechRecognitionEvaluator",parameters:[{name:"task",val:" = 'automatic-speech-recognition'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/automatic_speech_recognition.py#L47"}}),Et=new x({props:{name:"compute",anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'path'"},{name:"label_column",val:": str = 'sentence'"},{name:"generation_kwargs",val:": dict = None"}],parametersDescription:[{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/automatic_speech_recognition.py#L63",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Ae=new I({props:{anchor:"evaluate.AutomaticSpeechRecognitionEvaluator.compute.example",$$slots:{default:[Kn]},$$scope:{ctx:_}}}),Nt=new W({props:{title:"AudioClassificationEvaluator",local:"evaluate.AudioClassificationEvaluator",headingTag:"h3"}}),Gt=new x({props:{name:"class evaluate.AudioClassificationEvaluator",anchor:"evaluate.AudioClassificationEvaluator",parameters:[{name:"task",val:" = 'audio-classification'"},{name:"default_metric_name",val:" = None"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/audio_classification.py#L75"}}),Rt=new x({props:{name:"compute",anchor:"evaluate.AudioClassificationEvaluator.compute",parameters:[{name:"model_or_pipeline",val:": typing.Union[str, ForwardRef('Pipeline'), typing.Callable, ForwardRef('PreTrainedModel'), ForwardRef('TFPreTrainedModel')] = None"},{name:"data",val:": typing.Union[str, datasets.arrow_dataset.Dataset] = None"},{name:"subset",val:": typing.Optional[str] = None"},{name:"split",val:": typing.Optional[str] = None"},{name:"metric",val:": typing.Union[str, evaluate.module.EvaluationModule] = None"},{name:"tokenizer",val:": typing.Union[str, ForwardRef('PreTrainedTokenizer'), NoneType] = None"},{name:"feature_extractor",val:": typing.Union[str, ForwardRef('FeatureExtractionMixin'), NoneType] = None"},{name:"strategy",val:": typing.Literal['simple', 'bootstrap'] = 'simple'"},{name:"confidence_level",val:": float = 0.95"},{name:"n_resamples",val:": int = 9999"},{name:"device",val:": int = None"},{name:"random_state",val:": typing.Optional[int] = None"},{name:"input_column",val:": str = 'file'"},{name:"label_column",val:": str = 'label'"},{name:"label_mapping",val:": typing.Optional[typing.Dict[str, numbers.Number]] = None"}],parametersDescription:[{anchor:"evaluate.AudioClassificationEvaluator.compute.model_or_pipeline",description:`<strong>model_or_pipeline</strong> (<code>str</code> or <code>Pipeline</code> or <code>Callable</code> or <code>PreTrainedModel</code> or <code>TFPreTrainedModel</code>, defaults to <code>None</code>) &#x2014;
If the argument in not specified, we initialize the default pipeline for the task (in this case
<code>text-classification</code> or its alias - <code>sentiment-analysis</code>). If the argument is of the type <code>str</code> or
is a model instance, we use it to initialize a new <code>Pipeline</code> with the given model. Otherwise we assume the
argument specifies a pre-initialized pipeline.`,name:"model_or_pipeline"},{anchor:"evaluate.AudioClassificationEvaluator.compute.data",description:`<strong>data</strong> (<code>str</code> or <code>Dataset</code>, defaults to <code>None</code>) &#x2014;
Specifies the dataset we will run evaluation on. If it is of type <code>str</code>, we treat it as the dataset
name, and load it. Otherwise we assume it represents a pre-loaded dataset.`,name:"data"},{anchor:"evaluate.AudioClassificationEvaluator.compute.subset",description:`<strong>subset</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset subset to load. If <code>None</code> is passed the default subset is loaded.`,name:"subset"},{anchor:"evaluate.AudioClassificationEvaluator.compute.split",description:`<strong>split</strong> (<code>str</code>, defaults to <code>None</code>) &#x2014;
Defines which dataset split to load. If <code>None</code> is passed, infers based on the <code>choose_split</code> function.`,name:"split"},{anchor:"evaluate.AudioClassificationEvaluator.compute.metric",description:`<strong>metric</strong> (<code>str</code> or <code>EvaluationModule</code>, defaults to <code>None</code>) &#x2014;
Specifies the metric we use in evaluator. If it is of type <code>str</code>, we treat it as the metric name, and
load it. Otherwise we assume it represents a pre-loaded metric.`,name:"metric"},{anchor:"evaluate.AudioClassificationEvaluator.compute.tokenizer",description:`<strong>tokenizer</strong> (<code>str</code> or <code>PreTrainedTokenizer</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
Argument can be used to overwrite a default tokenizer if <code>model_or_pipeline</code> represents a model for
which we build a pipeline. If <code>model_or_pipeline</code> is <code>None</code> or a pre-initialized pipeline, we ignore
this argument.`,name:"tokenizer"},{anchor:"evaluate.AudioClassificationEvaluator.compute.strategy",description:`<strong>strategy</strong> (<code>Literal[&quot;simple&quot;, &quot;bootstrap&quot;]</code>, defaults to &#x201C;simple&#x201D;) &#x2014;
specifies the evaluation strategy. Possible values are:
<ul>
<li><code>&quot;simple&quot;</code> - we evaluate the metric and return the scores.</li>
<li><code>&quot;bootstrap&quot;</code> - on top of computing the metric scores, we calculate the confidence interval for each
of the returned metric keys, using <code>scipy</code>&#x2019;s <code>bootstrap</code> method
<a href="https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html" rel="nofollow">https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bootstrap.html</a>.</li>
</ul>`,name:"strategy"},{anchor:"evaluate.AudioClassificationEvaluator.compute.confidence_level",description:`<strong>confidence_level</strong> (<code>float</code>, defaults to <code>0.95</code>) &#x2014;
The <code>confidence_level</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"confidence_level"},{anchor:"evaluate.AudioClassificationEvaluator.compute.n_resamples",description:`<strong>n_resamples</strong> (<code>int</code>, defaults to <code>9999</code>) &#x2014;
The <code>n_resamples</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen.`,name:"n_resamples"},{anchor:"evaluate.AudioClassificationEvaluator.compute.device",description:`<strong>device</strong> (<code>int</code>, defaults to <code>None</code>) &#x2014;
Device ordinal for CPU/GPU support of the pipeline. Setting this to -1 will leverage CPU, a positive
integer will run the model on the associated CUDA device ID. If <code>None</code> is provided it will be inferred and
CUDA:0 used if available, CPU otherwise.`,name:"device"},{anchor:"evaluate.AudioClassificationEvaluator.compute.random_state",description:`<strong>random_state</strong> (<code>int</code>, <em>optional</em>, defaults to <code>None</code>) &#x2014;
The <code>random_state</code> value passed to <code>bootstrap</code> if <code>&quot;bootstrap&quot;</code> strategy is chosen. Useful for
debugging.`,name:"random_state"}],source:"https://github.com/huggingface/evaluate/blob/main/src/evaluate/evaluator/audio_classification.py#L94",returnDescription:`<script context="module">export const metadata = 'undefined';<\/script>


<p>A <code>Dict</code>. The keys represent metric keys calculated for the <code>metric</code> spefied in function arguments. For the
<code>"simple"</code> strategy, the value is the metric score. For the <code>"bootstrap"</code> strategy, the value is a <code>Dict</code>
containing the score, the confidence interval and the standard error calculated for each metric key.</p>
`}}),Xe=new I({props:{anchor:"evaluate.AudioClassificationEvaluator.compute.example",$$slots:{default:[el]},$$scope:{ctx:_}}}),We=new I({props:{anchor:"evaluate.AudioClassificationEvaluator.compute.example-2",$$slots:{default:[tl]},$$scope:{ctx:_}}}),zt=new Fn({props:{source:"https://github.com/huggingface/evaluate/blob/main/docs/source/package_reference/evaluator_classes.mdx"}}),{c(){a=d("meta"),w=n(),i=d("p"),s=n(),u(y.$$.fragment),t=n(),u(M.$$.fragment),Fa=n(),Ye=d("p"),Ye.textContent=As,Za=n(),u(Be.$$.fragment),za=n(),Ve=d("p"),Ve.textContent=Xs,Aa=n(),Y=d("div"),u(De.$$.fragment),fo=n(),Wt=d("p"),Wt.innerHTML=Ws,vo=n(),u(we.$$.fragment),Xa=n(),Qe=d("p"),Qe.textContent=Ys,Wa=n(),J=d("div"),u(Se.$$.fragment),yo=n(),Yt=d("p"),Yt.innerHTML=Bs,bo=n(),O=d("div"),u(Pe.$$.fragment),Mo=n(),Bt=d("p"),Bt.textContent=Vs,wo=n(),u(Te.$$.fragment),To=n(),_e=d("div"),u(Le.$$.fragment),_o=n(),Vt=d("p"),Vt.textContent=Ds,$o=n(),K=d("div"),u(He.$$.fragment),jo=n(),Dt=d("p"),Dt.innerHTML=Qs,xo=n(),u($e.$$.fragment),Jo=n(),ee=d("div"),u(Oe.$$.fragment),Uo=n(),Qt=d("p"),Qt.textContent=Ss,Co=n(),u(je.$$.fragment),ko=n(),xe=d("div"),u(Ke.$$.fragment),Io=n(),St=d("p"),St.innerHTML=Ps,qo=n(),te=d("div"),u(et.$$.fragment),Eo=n(),Pt=d("p"),Pt.textContent=Ls,No=n(),u(Je.$$.fragment),Go=n(),ae=d("div"),u(tt.$$.fragment),Ro=n(),Lt=d("p"),Lt.textContent=Hs,Fo=n(),u(Ue.$$.fragment),Zo=n(),oe=d("div"),u(at.$$.fragment),zo=n(),Ht=d("p"),Ht.textContent=Os,Ao=n(),u(Ce.$$.fragment),Ya=n(),u(ot.$$.fragment),Ba=n(),u(st.$$.fragment),Va=n(),B=d("div"),u(nt.$$.fragment),Xo=n(),Ot=d("p"),Ot.innerHTML=Ks,Wo=n(),se=d("div"),u(lt.$$.fragment),Yo=n(),Kt=d("p"),Kt.textContent=en,Bo=n(),u(ke.$$.fragment),Da=n(),u(rt.$$.fragment),Qa=n(),N=d("div"),u(it.$$.fragment),Vo=n(),ea=d("p"),ea.innerHTML=tn,Do=n(),ta=d("p"),ta.innerHTML=an,Qo=n(),aa=d("p"),aa.innerHTML=on,So=n(),F=d("div"),u(ct.$$.fragment),Po=n(),oa=d("p"),oa.textContent=sn,Lo=n(),u(Ie.$$.fragment),Ho=n(),dt=d("blockquote"),dt.innerHTML=nn,Oo=n(),u(qe.$$.fragment),Sa=n(),u(pt.$$.fragment),Pa=n(),V=d("div"),u(ut.$$.fragment),Ko=n(),sa=d("p"),sa.innerHTML=ln,es=n(),ne=d("div"),u(mt.$$.fragment),ts=n(),na=d("p"),na.textContent=rn,as=n(),u(Ee.$$.fragment),La=n(),u(gt.$$.fragment),Ha=n(),G=d("div"),u(ht.$$.fragment),os=n(),la=d("p"),la.textContent=cn,ss=n(),ra=d("p"),ra.innerHTML=dn,ns=n(),ia=d("p"),ia.innerHTML=pn,ls=n(),E=d("div"),u(ft.$$.fragment),rs=n(),ca=d("p"),ca.textContent=un,is=n(),da=d("p"),da.innerHTML=mn,cs=n(),u(Ne.$$.fragment),ds=n(),Ge=d("blockquote"),pa=d("p"),pa.textContent=gn,ps=n(),u(vt.$$.fragment),us=n(),Re=d("blockquote"),ua=d("p"),ua.innerHTML=hn,ms=n(),u(yt.$$.fragment),Oa=n(),u(bt.$$.fragment),Ka=n(),D=d("div"),u(Mt.$$.fragment),gs=n(),ma=d("p"),ma.innerHTML=fn,hs=n(),ga=d("div"),u(wt.$$.fragment),eo=n(),u(Tt.$$.fragment),to=n(),Q=d("div"),u(_t.$$.fragment),fs=n(),ha=d("p"),ha.innerHTML=vn,vs=n(),le=d("div"),u($t.$$.fragment),ys=n(),fa=d("p"),fa.textContent=yn,bs=n(),u(Fe.$$.fragment),ao=n(),u(jt.$$.fragment),oo=n(),S=d("div"),u(xt.$$.fragment),Ms=n(),va=d("p"),va.innerHTML=bn,ws=n(),re=d("div"),u(Jt.$$.fragment),Ts=n(),ya=d("p"),ya.textContent=Mn,_s=n(),u(Ze.$$.fragment),so=n(),u(Ut.$$.fragment),no=n(),P=d("div"),u(Ct.$$.fragment),$s=n(),ba=d("p"),ba.innerHTML=wn,js=n(),ie=d("div"),u(kt.$$.fragment),xs=n(),Ma=d("p"),Ma.textContent=Tn,Js=n(),u(ze.$$.fragment),lo=n(),u(It.$$.fragment),ro=n(),L=d("div"),u(qt.$$.fragment),Us=n(),wa=d("p"),wa.innerHTML=_n,Cs=n(),ce=d("div"),u(Et.$$.fragment),ks=n(),Ta=d("p"),Ta.textContent=$n,Is=n(),u(Ae.$$.fragment),io=n(),u(Nt.$$.fragment),co=n(),H=d("div"),u(Gt.$$.fragment),qs=n(),_a=d("p"),_a.innerHTML=jn,Es=n(),k=d("div"),u(Rt.$$.fragment),Ns=n(),$a=d("p"),$a.textContent=xn,Gs=n(),ja=d("p"),ja.textContent=Jn,Rs=n(),Ft=d("blockquote"),Ft.innerHTML=Un,Fs=n(),u(Xe.$$.fragment),Zs=n(),Zt=d("blockquote"),Zt.innerHTML=Cn,zs=n(),u(We.$$.fragment),po=n(),u(zt.$$.fragment),uo=n(),Ra=d("p"),this.h()},l(e){const c=Gn("svelte-u9bgzb",document.head);a=p(c,"META",{name:!0,content:!0}),c.forEach(r),w=l(e),i=p(e,"P",{}),j(i).forEach(r),s=l(e),m(y.$$.fragment,e),t=l(e),m(M.$$.fragment,e),Fa=l(e),Ye=p(e,"P",{"data-svelte-h":!0}),T(Ye)!=="svelte-31hh3m"&&(Ye.textContent=As),Za=l(e),m(Be.$$.fragment,e),za=l(e),Ve=p(e,"P",{"data-svelte-h":!0}),T(Ve)!=="svelte-9ny2j3"&&(Ve.textContent=Xs),Aa=l(e),Y=p(e,"DIV",{class:!0});var de=j(Y);m(De.$$.fragment,de),fo=l(de),Wt=p(de,"P",{"data-svelte-h":!0}),T(Wt)!=="svelte-th2t11"&&(Wt.innerHTML=Ws),vo=l(de),m(we.$$.fragment,de),de.forEach(r),Xa=l(e),Qe=p(e,"P",{"data-svelte-h":!0}),T(Qe)!=="svelte-1kp6zkh"&&(Qe.textContent=Ys),Wa=l(e),J=p(e,"DIV",{class:!0});var U=j(J);m(Se.$$.fragment,U),yo=l(U),Yt=p(U,"P",{"data-svelte-h":!0}),T(Yt)!=="svelte-6g2f1k"&&(Yt.innerHTML=Bs),bo=l(U),O=p(U,"DIV",{class:!0});var pe=j(O);m(Pe.$$.fragment,pe),Mo=l(pe),Bt=p(pe,"P",{"data-svelte-h":!0}),T(Bt)!=="svelte-1pkxhfo"&&(Bt.textContent=Vs),wo=l(pe),m(Te.$$.fragment,pe),pe.forEach(r),To=l(U),_e=p(U,"DIV",{class:!0});var At=j(_e);m(Le.$$.fragment,At),_o=l(At),Vt=p(At,"P",{"data-svelte-h":!0}),T(Vt)!=="svelte-1tg2h9j"&&(Vt.textContent=Ds),At.forEach(r),$o=l(U),K=p(U,"DIV",{class:!0});var ue=j(K);m(He.$$.fragment,ue),jo=l(ue),Dt=p(ue,"P",{"data-svelte-h":!0}),T(Dt)!=="svelte-1pb5z6h"&&(Dt.innerHTML=Qs),xo=l(ue),m($e.$$.fragment,ue),ue.forEach(r),Jo=l(U),ee=p(U,"DIV",{class:!0});var me=j(ee);m(Oe.$$.fragment,me),Uo=l(me),Qt=p(me,"P",{"data-svelte-h":!0}),T(Qt)!=="svelte-1yhb0zq"&&(Qt.textContent=Ss),Co=l(me),m(je.$$.fragment,me),me.forEach(r),ko=l(U),xe=p(U,"DIV",{class:!0});var Xt=j(xe);m(Ke.$$.fragment,Xt),Io=l(Xt),St=p(Xt,"P",{"data-svelte-h":!0}),T(St)!=="svelte-aaxv8o"&&(St.innerHTML=Ps),Xt.forEach(r),qo=l(U),te=p(U,"DIV",{class:!0});var ge=j(te);m(et.$$.fragment,ge),Eo=l(ge),Pt=p(ge,"P",{"data-svelte-h":!0}),T(Pt)!=="svelte-or8pod"&&(Pt.textContent=Ls),No=l(ge),m(Je.$$.fragment,ge),ge.forEach(r),Go=l(U),ae=p(U,"DIV",{class:!0});var he=j(ae);m(tt.$$.fragment,he),Ro=l(he),Lt=p(he,"P",{"data-svelte-h":!0}),T(Lt)!=="svelte-14zepih"&&(Lt.textContent=Hs),Fo=l(he),m(Ue.$$.fragment,he),he.forEach(r),Zo=l(U),oe=p(U,"DIV",{class:!0});var fe=j(oe);m(at.$$.fragment,fe),zo=l(fe),Ht=p(fe,"P",{"data-svelte-h":!0}),T(Ht)!=="svelte-w1f26j"&&(Ht.textContent=Os),Ao=l(fe),m(Ce.$$.fragment,fe),fe.forEach(r),U.forEach(r),Ya=l(e),m(ot.$$.fragment,e),Ba=l(e),m(st.$$.fragment,e),Va=l(e),B=p(e,"DIV",{class:!0});var ve=j(B);m(nt.$$.fragment,ve),Xo=l(ve),Ot=p(ve,"P",{"data-svelte-h":!0}),T(Ot)!=="svelte-qoqvhv"&&(Ot.innerHTML=Ks),Wo=l(ve),se=p(ve,"DIV",{class:!0});var ye=j(se);m(lt.$$.fragment,ye),Yo=l(ye),Kt=p(ye,"P",{"data-svelte-h":!0}),T(Kt)!=="svelte-1q37rir"&&(Kt.textContent=en),Bo=l(ye),m(ke.$$.fragment,ye),ye.forEach(r),ve.forEach(r),Da=l(e),m(rt.$$.fragment,e),Qa=l(e),N=p(e,"DIV",{class:!0});var z=j(N);m(it.$$.fragment,z),Vo=l(z),ea=p(z,"P",{"data-svelte-h":!0}),T(ea)!=="svelte-1kyvqur"&&(ea.innerHTML=tn),Do=l(z),ta=p(z,"P",{"data-svelte-h":!0}),T(ta)!=="svelte-sr74ch"&&(ta.innerHTML=an),Qo=l(z),aa=p(z,"P",{"data-svelte-h":!0}),T(aa)!=="svelte-dbyhe1"&&(aa.innerHTML=on),So=l(z),F=p(z,"DIV",{class:!0});var A=j(F);m(ct.$$.fragment,A),Po=l(A),oa=p(A,"P",{"data-svelte-h":!0}),T(oa)!=="svelte-1q37rir"&&(oa.textContent=sn),Lo=l(A),m(Ie.$$.fragment,A),Ho=l(A),dt=p(A,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),T(dt)!=="svelte-i3r8a"&&(dt.innerHTML=nn),Oo=l(A),m(qe.$$.fragment,A),A.forEach(r),z.forEach(r),Sa=l(e),m(pt.$$.fragment,e),Pa=l(e),V=p(e,"DIV",{class:!0});var be=j(V);m(ut.$$.fragment,be),Ko=l(be),sa=p(be,"P",{"data-svelte-h":!0}),T(sa)!=="svelte-1v0gbup"&&(sa.innerHTML=ln),es=l(be),ne=p(be,"DIV",{class:!0});var Me=j(ne);m(mt.$$.fragment,Me),ts=l(Me),na=p(Me,"P",{"data-svelte-h":!0}),T(na)!=="svelte-1q37rir"&&(na.textContent=rn),as=l(Me),m(Ee.$$.fragment,Me),Me.forEach(r),be.forEach(r),La=l(e),m(gt.$$.fragment,e),Ha=l(e),G=p(e,"DIV",{class:!0});var X=j(G);m(ht.$$.fragment,X),os=l(X),la=p(X,"P",{"data-svelte-h":!0}),T(la)!=="svelte-13pxad0"&&(la.textContent=cn),ss=l(X),ra=p(X,"P",{"data-svelte-h":!0}),T(ra)!=="svelte-tl6x5h"&&(ra.innerHTML=dn),ns=l(X),ia=p(X,"P",{"data-svelte-h":!0}),T(ia)!=="svelte-mny0dx"&&(ia.innerHTML=pn),ls=l(X),E=p(X,"DIV",{class:!0});var R=j(E);m(ft.$$.fragment,R),rs=l(R),ca=p(R,"P",{"data-svelte-h":!0}),T(ca)!=="svelte-1q37rir"&&(ca.textContent=un),is=l(R),da=p(R,"P",{"data-svelte-h":!0}),T(da)!=="svelte-1g2iegv"&&(da.innerHTML=mn),cs=l(R),m(Ne.$$.fragment,R),ds=l(R),Ge=p(R,"BLOCKQUOTE",{class:!0});var go=j(Ge);pa=p(go,"P",{"data-svelte-h":!0}),T(pa)!=="svelte-n4qt64"&&(pa.textContent=gn),ps=l(go),m(vt.$$.fragment,go),go.forEach(r),us=l(R),Re=p(R,"BLOCKQUOTE",{class:!0});var ho=j(Re);ua=p(ho,"P",{"data-svelte-h":!0}),T(ua)!=="svelte-sh5geg"&&(ua.innerHTML=hn),ms=l(ho),m(yt.$$.fragment,ho),ho.forEach(r),R.forEach(r),X.forEach(r),Oa=l(e),m(bt.$$.fragment,e),Ka=l(e),D=p(e,"DIV",{class:!0});var xa=j(D);m(Mt.$$.fragment,xa),gs=l(xa),ma=p(xa,"P",{"data-svelte-h":!0}),T(ma)!=="svelte-188n28u"&&(ma.innerHTML=fn),hs=l(xa),ga=p(xa,"DIV",{class:!0});var kn=j(ga);m(wt.$$.fragment,kn),kn.forEach(r),xa.forEach(r),eo=l(e),m(Tt.$$.fragment,e),to=l(e),Q=p(e,"DIV",{class:!0});var Ja=j(Q);m(_t.$$.fragment,Ja),fs=l(Ja),ha=p(Ja,"P",{"data-svelte-h":!0}),T(ha)!=="svelte-2x05hh"&&(ha.innerHTML=vn),vs=l(Ja),le=p(Ja,"DIV",{class:!0});var Ua=j(le);m($t.$$.fragment,Ua),ys=l(Ua),fa=p(Ua,"P",{"data-svelte-h":!0}),T(fa)!=="svelte-1q37rir"&&(fa.textContent=yn),bs=l(Ua),m(Fe.$$.fragment,Ua),Ua.forEach(r),Ja.forEach(r),ao=l(e),m(jt.$$.fragment,e),oo=l(e),S=p(e,"DIV",{class:!0});var Ca=j(S);m(xt.$$.fragment,Ca),Ms=l(Ca),va=p(Ca,"P",{"data-svelte-h":!0}),T(va)!=="svelte-k90omx"&&(va.innerHTML=bn),ws=l(Ca),re=p(Ca,"DIV",{class:!0});var ka=j(re);m(Jt.$$.fragment,ka),Ts=l(ka),ya=p(ka,"P",{"data-svelte-h":!0}),T(ya)!=="svelte-1q37rir"&&(ya.textContent=Mn),_s=l(ka),m(Ze.$$.fragment,ka),ka.forEach(r),Ca.forEach(r),so=l(e),m(Ut.$$.fragment,e),no=l(e),P=p(e,"DIV",{class:!0});var Ia=j(P);m(Ct.$$.fragment,Ia),$s=l(Ia),ba=p(Ia,"P",{"data-svelte-h":!0}),T(ba)!=="svelte-fxepne"&&(ba.innerHTML=wn),js=l(Ia),ie=p(Ia,"DIV",{class:!0});var qa=j(ie);m(kt.$$.fragment,qa),xs=l(qa),Ma=p(qa,"P",{"data-svelte-h":!0}),T(Ma)!=="svelte-1q37rir"&&(Ma.textContent=Tn),Js=l(qa),m(ze.$$.fragment,qa),qa.forEach(r),Ia.forEach(r),lo=l(e),m(It.$$.fragment,e),ro=l(e),L=p(e,"DIV",{class:!0});var Ea=j(L);m(qt.$$.fragment,Ea),Us=l(Ea),wa=p(Ea,"P",{"data-svelte-h":!0}),T(wa)!=="svelte-1cphoma"&&(wa.innerHTML=_n),Cs=l(Ea),ce=p(Ea,"DIV",{class:!0});var Na=j(ce);m(Et.$$.fragment,Na),ks=l(Na),Ta=p(Na,"P",{"data-svelte-h":!0}),T(Ta)!=="svelte-1q37rir"&&(Ta.textContent=$n),Is=l(Na),m(Ae.$$.fragment,Na),Na.forEach(r),Ea.forEach(r),io=l(e),m(Nt.$$.fragment,e),co=l(e),H=p(e,"DIV",{class:!0});var Ga=j(H);m(Gt.$$.fragment,Ga),qs=l(Ga),_a=p(Ga,"P",{"data-svelte-h":!0}),T(_a)!=="svelte-qaodd3"&&(_a.innerHTML=jn),Es=l(Ga),k=p(Ga,"DIV",{class:!0});var Z=j(k);m(Rt.$$.fragment,Z),Ns=l(Z),$a=p(Z,"P",{"data-svelte-h":!0}),T($a)!=="svelte-1q37rir"&&($a.textContent=xn),Gs=l(Z),ja=p(Z,"P",{"data-svelte-h":!0}),T(ja)!=="svelte-kvfsh7"&&(ja.textContent=Jn),Rs=l(Z),Ft=p(Z,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),T(Ft)!=="svelte-1nk49df"&&(Ft.innerHTML=Un),Fs=l(Z),m(Xe.$$.fragment,Z),Zs=l(Z),Zt=p(Z,"BLOCKQUOTE",{class:!0,"data-svelte-h":!0}),T(Zt)!=="svelte-tatdlj"&&(Zt.innerHTML=Cn),zs=l(Z),m(We.$$.fragment,Z),Z.forEach(r),Ga.forEach(r),po=l(e),m(zt.$$.fragment,e),uo=l(e),Ra=p(e,"P",{}),j(Ra).forEach(r),this.h()},h(){$(a,"name","hf:doc:metadata"),$(a,"content",ol),$(Y,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(O,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(_e,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(K,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ee,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(xe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(te,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ae,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(oe,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(J,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(se,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(B,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(dt,"class","tip"),$(F,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(N,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ne,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(V,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ge,"class","tip"),$(Re,"class","warning"),$(E,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(G,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ga,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(D,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(le,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Q,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(re,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(S,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ie,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(P,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(ce,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(L,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(Ft,"class","tip"),$(Zt,"class","tip"),$(k,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8"),$(H,"class","docstring border-l-2 border-t-2 pl-4 pt-3.5 border-gray-100 rounded-tl-xl mb-6 mt-8")},m(e,c){o(document.head,a),b(e,w,c),b(e,i,c),b(e,s,c),g(y,e,c),b(e,t,c),g(M,e,c),b(e,Fa,c),b(e,Ye,c),b(e,Za,c),g(Be,e,c),b(e,za,c),b(e,Ve,c),b(e,Aa,c),b(e,Y,c),g(De,Y,null),o(Y,fo),o(Y,Wt),o(Y,vo),g(we,Y,null),b(e,Xa,c),b(e,Qe,c),b(e,Wa,c),b(e,J,c),g(Se,J,null),o(J,yo),o(J,Yt),o(J,bo),o(J,O),g(Pe,O,null),o(O,Mo),o(O,Bt),o(O,wo),g(Te,O,null),o(J,To),o(J,_e),g(Le,_e,null),o(_e,_o),o(_e,Vt),o(J,$o),o(J,K),g(He,K,null),o(K,jo),o(K,Dt),o(K,xo),g($e,K,null),o(J,Jo),o(J,ee),g(Oe,ee,null),o(ee,Uo),o(ee,Qt),o(ee,Co),g(je,ee,null),o(J,ko),o(J,xe),g(Ke,xe,null),o(xe,Io),o(xe,St),o(J,qo),o(J,te),g(et,te,null),o(te,Eo),o(te,Pt),o(te,No),g(Je,te,null),o(J,Go),o(J,ae),g(tt,ae,null),o(ae,Ro),o(ae,Lt),o(ae,Fo),g(Ue,ae,null),o(J,Zo),o(J,oe),g(at,oe,null),o(oe,zo),o(oe,Ht),o(oe,Ao),g(Ce,oe,null),b(e,Ya,c),g(ot,e,c),b(e,Ba,c),g(st,e,c),b(e,Va,c),b(e,B,c),g(nt,B,null),o(B,Xo),o(B,Ot),o(B,Wo),o(B,se),g(lt,se,null),o(se,Yo),o(se,Kt),o(se,Bo),g(ke,se,null),b(e,Da,c),g(rt,e,c),b(e,Qa,c),b(e,N,c),g(it,N,null),o(N,Vo),o(N,ea),o(N,Do),o(N,ta),o(N,Qo),o(N,aa),o(N,So),o(N,F),g(ct,F,null),o(F,Po),o(F,oa),o(F,Lo),g(Ie,F,null),o(F,Ho),o(F,dt),o(F,Oo),g(qe,F,null),b(e,Sa,c),g(pt,e,c),b(e,Pa,c),b(e,V,c),g(ut,V,null),o(V,Ko),o(V,sa),o(V,es),o(V,ne),g(mt,ne,null),o(ne,ts),o(ne,na),o(ne,as),g(Ee,ne,null),b(e,La,c),g(gt,e,c),b(e,Ha,c),b(e,G,c),g(ht,G,null),o(G,os),o(G,la),o(G,ss),o(G,ra),o(G,ns),o(G,ia),o(G,ls),o(G,E),g(ft,E,null),o(E,rs),o(E,ca),o(E,is),o(E,da),o(E,cs),g(Ne,E,null),o(E,ds),o(E,Ge),o(Ge,pa),o(Ge,ps),g(vt,Ge,null),o(E,us),o(E,Re),o(Re,ua),o(Re,ms),g(yt,Re,null),b(e,Oa,c),g(bt,e,c),b(e,Ka,c),b(e,D,c),g(Mt,D,null),o(D,gs),o(D,ma),o(D,hs),o(D,ga),g(wt,ga,null),b(e,eo,c),g(Tt,e,c),b(e,to,c),b(e,Q,c),g(_t,Q,null),o(Q,fs),o(Q,ha),o(Q,vs),o(Q,le),g($t,le,null),o(le,ys),o(le,fa),o(le,bs),g(Fe,le,null),b(e,ao,c),g(jt,e,c),b(e,oo,c),b(e,S,c),g(xt,S,null),o(S,Ms),o(S,va),o(S,ws),o(S,re),g(Jt,re,null),o(re,Ts),o(re,ya),o(re,_s),g(Ze,re,null),b(e,so,c),g(Ut,e,c),b(e,no,c),b(e,P,c),g(Ct,P,null),o(P,$s),o(P,ba),o(P,js),o(P,ie),g(kt,ie,null),o(ie,xs),o(ie,Ma),o(ie,Js),g(ze,ie,null),b(e,lo,c),g(It,e,c),b(e,ro,c),b(e,L,c),g(qt,L,null),o(L,Us),o(L,wa),o(L,Cs),o(L,ce),g(Et,ce,null),o(ce,ks),o(ce,Ta),o(ce,Is),g(Ae,ce,null),b(e,io,c),g(Nt,e,c),b(e,co,c),b(e,H,c),g(Gt,H,null),o(H,qs),o(H,_a),o(H,Es),o(H,k),g(Rt,k,null),o(k,Ns),o(k,$a),o(k,Gs),o(k,ja),o(k,Rs),o(k,Ft),o(k,Fs),g(Xe,k,null),o(k,Zs),o(k,Zt),o(k,zs),g(We,k,null),b(e,po,c),g(zt,e,c),b(e,uo,c),b(e,Ra,c),mo=!0},p(e,[c]){const de={};c&2&&(de.$$scope={dirty:c,ctx:e}),we.$set(de);const U={};c&2&&(U.$$scope={dirty:c,ctx:e}),Te.$set(U);const pe={};c&2&&(pe.$$scope={dirty:c,ctx:e}),$e.$set(pe);const At={};c&2&&(At.$$scope={dirty:c,ctx:e}),je.$set(At);const ue={};c&2&&(ue.$$scope={dirty:c,ctx:e}),Je.$set(ue);const me={};c&2&&(me.$$scope={dirty:c,ctx:e}),Ue.$set(me);const Xt={};c&2&&(Xt.$$scope={dirty:c,ctx:e}),Ce.$set(Xt);const ge={};c&2&&(ge.$$scope={dirty:c,ctx:e}),ke.$set(ge);const he={};c&2&&(he.$$scope={dirty:c,ctx:e}),Ie.$set(he);const fe={};c&2&&(fe.$$scope={dirty:c,ctx:e}),qe.$set(fe);const ve={};c&2&&(ve.$$scope={dirty:c,ctx:e}),Ee.$set(ve);const ye={};c&2&&(ye.$$scope={dirty:c,ctx:e}),Ne.$set(ye);const z={};c&2&&(z.$$scope={dirty:c,ctx:e}),Fe.$set(z);const A={};c&2&&(A.$$scope={dirty:c,ctx:e}),Ze.$set(A);const be={};c&2&&(be.$$scope={dirty:c,ctx:e}),ze.$set(be);const Me={};c&2&&(Me.$$scope={dirty:c,ctx:e}),Ae.$set(Me);const X={};c&2&&(X.$$scope={dirty:c,ctx:e}),Xe.$set(X);const R={};c&2&&(R.$$scope={dirty:c,ctx:e}),We.$set(R)},i(e){mo||(h(y.$$.fragment,e),h(M.$$.fragment,e),h(Be.$$.fragment,e),h(De.$$.fragment,e),h(we.$$.fragment,e),h(Se.$$.fragment,e),h(Pe.$$.fragment,e),h(Te.$$.fragment,e),h(Le.$$.fragment,e),h(He.$$.fragment,e),h($e.$$.fragment,e),h(Oe.$$.fragment,e),h(je.$$.fragment,e),h(Ke.$$.fragment,e),h(et.$$.fragment,e),h(Je.$$.fragment,e),h(tt.$$.fragment,e),h(Ue.$$.fragment,e),h(at.$$.fragment,e),h(Ce.$$.fragment,e),h(ot.$$.fragment,e),h(st.$$.fragment,e),h(nt.$$.fragment,e),h(lt.$$.fragment,e),h(ke.$$.fragment,e),h(rt.$$.fragment,e),h(it.$$.fragment,e),h(ct.$$.fragment,e),h(Ie.$$.fragment,e),h(qe.$$.fragment,e),h(pt.$$.fragment,e),h(ut.$$.fragment,e),h(mt.$$.fragment,e),h(Ee.$$.fragment,e),h(gt.$$.fragment,e),h(ht.$$.fragment,e),h(ft.$$.fragment,e),h(Ne.$$.fragment,e),h(vt.$$.fragment,e),h(yt.$$.fragment,e),h(bt.$$.fragment,e),h(Mt.$$.fragment,e),h(wt.$$.fragment,e),h(Tt.$$.fragment,e),h(_t.$$.fragment,e),h($t.$$.fragment,e),h(Fe.$$.fragment,e),h(jt.$$.fragment,e),h(xt.$$.fragment,e),h(Jt.$$.fragment,e),h(Ze.$$.fragment,e),h(Ut.$$.fragment,e),h(Ct.$$.fragment,e),h(kt.$$.fragment,e),h(ze.$$.fragment,e),h(It.$$.fragment,e),h(qt.$$.fragment,e),h(Et.$$.fragment,e),h(Ae.$$.fragment,e),h(Nt.$$.fragment,e),h(Gt.$$.fragment,e),h(Rt.$$.fragment,e),h(Xe.$$.fragment,e),h(We.$$.fragment,e),h(zt.$$.fragment,e),mo=!0)},o(e){f(y.$$.fragment,e),f(M.$$.fragment,e),f(Be.$$.fragment,e),f(De.$$.fragment,e),f(we.$$.fragment,e),f(Se.$$.fragment,e),f(Pe.$$.fragment,e),f(Te.$$.fragment,e),f(Le.$$.fragment,e),f(He.$$.fragment,e),f($e.$$.fragment,e),f(Oe.$$.fragment,e),f(je.$$.fragment,e),f(Ke.$$.fragment,e),f(et.$$.fragment,e),f(Je.$$.fragment,e),f(tt.$$.fragment,e),f(Ue.$$.fragment,e),f(at.$$.fragment,e),f(Ce.$$.fragment,e),f(ot.$$.fragment,e),f(st.$$.fragment,e),f(nt.$$.fragment,e),f(lt.$$.fragment,e),f(ke.$$.fragment,e),f(rt.$$.fragment,e),f(it.$$.fragment,e),f(ct.$$.fragment,e),f(Ie.$$.fragment,e),f(qe.$$.fragment,e),f(pt.$$.fragment,e),f(ut.$$.fragment,e),f(mt.$$.fragment,e),f(Ee.$$.fragment,e),f(gt.$$.fragment,e),f(ht.$$.fragment,e),f(ft.$$.fragment,e),f(Ne.$$.fragment,e),f(vt.$$.fragment,e),f(yt.$$.fragment,e),f(bt.$$.fragment,e),f(Mt.$$.fragment,e),f(wt.$$.fragment,e),f(Tt.$$.fragment,e),f(_t.$$.fragment,e),f($t.$$.fragment,e),f(Fe.$$.fragment,e),f(jt.$$.fragment,e),f(xt.$$.fragment,e),f(Jt.$$.fragment,e),f(Ze.$$.fragment,e),f(Ut.$$.fragment,e),f(Ct.$$.fragment,e),f(kt.$$.fragment,e),f(ze.$$.fragment,e),f(It.$$.fragment,e),f(qt.$$.fragment,e),f(Et.$$.fragment,e),f(Ae.$$.fragment,e),f(Nt.$$.fragment,e),f(Gt.$$.fragment,e),f(Rt.$$.fragment,e),f(Xe.$$.fragment,e),f(We.$$.fragment,e),f(zt.$$.fragment,e),mo=!1},d(e){e&&(r(w),r(i),r(s),r(t),r(Fa),r(Ye),r(Za),r(za),r(Ve),r(Aa),r(Y),r(Xa),r(Qe),r(Wa),r(J),r(Ya),r(Ba),r(Va),r(B),r(Da),r(Qa),r(N),r(Sa),r(Pa),r(V),r(La),r(Ha),r(G),r(Oa),r(Ka),r(D),r(eo),r(to),r(Q),r(ao),r(oo),r(S),r(so),r(no),r(P),r(lo),r(ro),r(L),r(io),r(co),r(H),r(po),r(uo),r(Ra)),r(a),v(y,e),v(M,e),v(Be,e),v(De),v(we),v(Se),v(Pe),v(Te),v(Le),v(He),v($e),v(Oe),v(je),v(Ke),v(et),v(Je),v(tt),v(Ue),v(at),v(Ce),v(ot,e),v(st,e),v(nt),v(lt),v(ke),v(rt,e),v(it),v(ct),v(Ie),v(qe),v(pt,e),v(ut),v(mt),v(Ee),v(gt,e),v(ht),v(ft),v(Ne),v(vt),v(yt),v(bt,e),v(Mt),v(wt),v(Tt,e),v(_t),v($t),v(Fe),v(jt,e),v(xt),v(Jt),v(Ze),v(Ut,e),v(Ct),v(kt),v(ze),v(It,e),v(qt),v(Et),v(Ae),v(Nt,e),v(Gt),v(Rt),v(Xe),v(We),v(zt,e)}}}const ol='{"title":"Evaluator","local":"evaluator","sections":[{"title":"Evaluator classes","local":"evaluate.evaluator","sections":[],"depth":2},{"title":"The task specific evaluators","local":"the-task-specific-evaluators","sections":[{"title":"ImageClassificationEvaluator","local":"evaluate.ImageClassificationEvaluator","sections":[],"depth":3},{"title":"QuestionAnsweringEvaluator","local":"evaluate.QuestionAnsweringEvaluator","sections":[],"depth":3},{"title":"TextClassificationEvaluator","local":"evaluate.TextClassificationEvaluator","sections":[],"depth":3},{"title":"TokenClassificationEvaluator","local":"evaluate.TokenClassificationEvaluator","sections":[],"depth":3},{"title":"TextGenerationEvaluator","local":"evaluate.TextGenerationEvaluator","sections":[],"depth":3},{"title":"Text2TextGenerationEvaluator","local":"evaluate.Text2TextGenerationEvaluator","sections":[],"depth":3},{"title":"SummarizationEvaluator","local":"evaluate.SummarizationEvaluator","sections":[],"depth":3},{"title":"TranslationEvaluator","local":"evaluate.TranslationEvaluator","sections":[],"depth":3},{"title":"AutomaticSpeechRecognitionEvaluator","local":"evaluate.AutomaticSpeechRecognitionEvaluator","sections":[],"depth":3},{"title":"AudioClassificationEvaluator","local":"evaluate.AudioClassificationEvaluator","sections":[],"depth":3}],"depth":2}],"depth":1}';function sl(_){return qn(()=>{new URLSearchParams(window.location.search).get("fw")}),[]}class pl extends En{constructor(a){super(),Nn(this,a,sl,al,In,{})}}export{pl as component};
