github.com/instill-ai/component@v0.16.0-beta/pkg/connector/huggingface/v0/config/tasks.json (about)

     1  {
     2    "$defs": {
     3      "model": {
     4        "description": "The Hugging Face model to be used",
     5        "instillAcceptFormats": [
     6          "string"
     7        ],
     8        "instillUpstreamTypes": [
     9          "value",
    10          "reference",
    11          "template"
    12        ],
    13        "title": "Model",
    14        "type": "string"
    15      },
    16      "options": {
    17        "properties": {
    18          "use_cache": {
    19            "description": "There is a cache layer on the inference API to speedup requests we have already seen. Most models can use those results as is as models are deterministic (meaning the results will be the same anyway). However if you use a non deterministic model, you can set this parameter to prevent the caching mechanism from being used resulting in a real new query.",
    20            "instillAcceptFormats": [
    21              "boolean"
    22            ],
    23            "instillShortDescription": "Enable the cache of inference API",
    24            "instillUIOrder": 1,
    25            "instillUpstreamTypes": [
    26              "value",
    27              "reference"
    28            ],
    29            "title": "Use Cache",
    30            "type": "boolean"
    31          },
    32          "wait_for_model": {
    33            "description": "If the model is not ready, wait for it instead of receiving 503. It limits the number of requests required to get your inference done. It is advised to only set this flag to true after receiving a 503 error as it will limit hanging in your application to known places.",
    34            "instillAcceptFormats": [
    35              "boolean"
    36            ],
    37            "instillShortDescription": "Wait for model ready",
    38            "instillUIOrder": 0,
    39            "instillUpstreamTypes": [
    40              "value",
    41              "reference"
    42            ],
    43            "title": "Wait For Model",
    44            "type": "boolean"
    45          }
    46        },
    47        "required": [],
    48        "description": "Options for the model",
    49        "title": "Options",
    50        "type": "object"
    51      },
    52      "string_input": {
    53        "description": "String input",
    54        "instillAcceptFormats": [
    55          "string"
    56        ],
    57        "instillUIOrder": 0,
    58        "instillUpstreamTypes": [
    59          "value",
    60          "reference",
    61          "template"
    62        ],
    63        "title": "String Input",
    64        "type": "string"
    65      }
    66    },
    67    "TASK_AUDIO_CLASSIFICATION": {
    68      "instillShortDescription": "Audio classification is the task of assigning a label or class to a given audio.",
    69      "description": "Audio classification is the task of assigning a label or class to a given audio. It can be used for recognizing which command a user is giving or the emotion of a statement, as well as identifying a speaker.",
    70      "input": {
    71        "instillUIOrder": 0,
    72        "properties": {
    73          "audio": {
    74            "description": "The audio file",
    75            "instillAcceptFormats": [
    76              "audio/*"
    77            ],
    78            "instillUIOrder": 1,
    79            "instillUpstreamTypes": [
    80              "reference"
    81            ],
    82            "title": "Audio",
    83            "type": "string"
    84          },
    85          "model": {
    86            "$ref": "#/$defs/model",
    87            "instillUIOrder": 0
    88          }
    89        },
    90        "required": [
    91          "audio",
    92          "model"
    93        ],
    94        "title": "Input",
    95        "type": "object"
    96      },
    97      "output": {
    98        "instillUIOrder": 0,
    99        "properties": {
   100          "classes": {
   101            "instillUIOrder": 0,
   102            "items": {
   103              "properties": {
   104                "label": {
   105                  "description": "The label for the class (model specific)",
   106                  "instillFormat": "string",
   107                  "instillUIOrder": 0,
   108                  "title": "Label",
   109                  "type": "string"
   110                },
   111                "score": {
   112                  "description": "A float that represents how likely it is that the audio file belongs to this class.",
   113                  "instillFormat": "number",
   114                  "instillUIOrder": 1,
   115                  "title": "Score",
   116                  "type": "number"
   117                }
   118              },
   119              "required": [
   120                "label",
   121                "score"
   122              ],
   123              "description": "Class",
   124              "title": "Class",
   125              "type": "object"
   126            },
   127            "description": "Classes",
   128            "title": "Classes",
   129            "type": "array"
   130          }
   131        },
   132        "required": [
   133          "classes"
   134        ],
   135        "title": "Output",
   136        "type": "object"
   137      }
   138    },
   139    "TASK_CONVERSATIONAL": {
   140      "instillShortDescription": "Conversational response modelling is the task of generating conversational text that is relevant, coherent and knowledgable given a prompt.",
   141      "description": "Conversational response modelling is the task of generating conversational text that is relevant, coherent and knowledgable given a prompt. These models have applications in chatbots, and as a part of voice assistants",
   142      "input": {
   143        "instillUIOrder": 0,
   144        "properties": {
   145          "inputs": {
   146            "instillUIOrder": 1,
   147            "properties": {
   148              "generated_responses": {
   149                "description": "A list of strings corresponding to the earlier replies from the model.",
   150                "instillAcceptFormats": [
   151                  "array:string"
   152                ],
   153                "instillUIOrder": 0,
   154                "instillUpstreamTypes": [
   155                  "value",
   156                  "reference"
   157                ],
   158                "items": {
   159                  "instillUIMultiline": true,
   160                  "description": "Items",
   161                  "type": "string"
   162                },
   163                "title": "Generated Responses",
   164                "type": "array"
   165              },
   166              "past_user_inputs": {
   167                "description": "A list of strings corresponding to the earlier replies from the user. Should be of the same length of generated_responses.",
   168                "instillAcceptFormats": [
   169                  "array:string"
   170                ],
   171                "instillShortDescription": "A list of strings corresponding to the earlier replies from the user.",
   172                "instillUIOrder": 1,
   173                "instillUpstreamTypes": [
   174                  "value",
   175                  "reference"
   176                ],
   177                "items": {
   178                  "instillUIMultiline": true,
   179                  "description": "Items",
   180                  "type": "string"
   181                },
   182                "title": "Past User Inputs",
   183                "type": "array"
   184              },
   185              "text": {
   186                "description": "The last input from the user in the conversation.",
   187                "instillAcceptFormats": [
   188                  "string"
   189                ],
   190                "instillUIMultiline": true,
   191                "instillUIOrder": 2,
   192                "instillUpstreamTypes": [
   193                  "value",
   194                  "reference",
   195                  "template"
   196                ],
   197                "title": "Text",
   198                "type": "string"
   199              }
   200            },
   201            "required": [
   202              "text"
   203            ],
   204            "description": "Inputs",
   205            "title": "Inputs",
   206            "type": "object"
   207          },
   208          "model": {
   209            "$ref": "#/$defs/model",
   210            "instillUIOrder": 0
   211          },
   212          "options": {
   213            "$ref": "#/$defs/options",
   214            "instillUIOrder": 3
   215          },
   216          "parameters": {
   217            "instillUIOrder": 2,
   218            "properties": {
   219              "max_length": {
   220                "description": "Integer to define the maximum length in tokens of the output summary.",
   221                "instillAcceptFormats": [
   222                  "integer"
   223                ],
   224                "instillUIOrder": 0,
   225                "instillUpstreamTypes": [
   226                  "value",
   227                  "reference"
   228                ],
   229                "title": "Max Length",
   230                "type": "integer"
   231              },
   232              "max_time": {
   233                "description": "The amount of time in seconds that the query should take maximum. Network can cause some overhead so it will be a soft limit.",
   234                "instillAcceptFormats": [
   235                  "number",
   236                  "integer"
   237                ],
   238                "instillShortDescription": "The amount of time in seconds that the query should take maximum.",
   239                "instillUIOrder": 1,
   240                "instillUpstreamTypes": [
   241                  "value",
   242                  "reference"
   243                ],
   244                "maximum": 120.0,
   245                "minimum": 0.0,
   246                "title": "Max Time",
   247                "type": "number"
   248              },
   249              "min_length": {
   250                "description": "Integer to define the minimum length in tokens of the output summary.",
   251                "instillAcceptFormats": [
   252                  "integer"
   253                ],
   254                "instillUIOrder": 2,
   255                "instillUpstreamTypes": [
   256                  "value",
   257                  "reference"
   258                ],
   259                "title": "Min Length",
   260                "type": "integer"
   261              },
   262              "repetition_penalty": {
   263                "description": "The more a token is used within generation the more it is penalized to not be picked in successive generation passes.",
   264                "instillAcceptFormats": [
   265                  "number",
   266                  "integer"
   267                ],
   268                "instillUIOrder": 3,
   269                "instillUpstreamTypes": [
   270                  "value",
   271                  "reference"
   272                ],
   273                "maximum": 100.0,
   274                "minimum": 0.0,
   275                "title": "Repetition Penalty",
   276                "type": "number"
   277              },
   278              "temperature": {
   279                "default": 1.0,
   280                "description": "The temperature of the sampling operation. 1 means regular sampling, 0 means always take the highest score, 100.0 is getting closer to uniform probability.",
   281                "instillAcceptFormats": [
   282                  "number",
   283                  "integer"
   284                ],
   285                "instillShortDescription": "The temperature of the sampling operation.",
   286                "instillUIOrder": 4,
   287                "instillUpstreamTypes": [
   288                  "value",
   289                  "reference"
   290                ],
   291                "maximum": 100.0,
   292                "minimum": 0.0,
   293                "title": "Temperature",
   294                "type": "number"
   295              },
   296              "top_k": {
   297                "description": "Integer to define the top tokens considered within the sample operation to create new text.",
   298                "instillAcceptFormats": [
   299                  "integer"
   300                ],
   301                "instillUIOrder": 5,
   302                "instillUpstreamTypes": [
   303                  "value",
   304                  "reference"
   305                ],
   306                "title": "Top K",
   307                "type": "integer"
   308              },
   309              "top_p": {
   310                "description": "Float to define the tokens that are within the sample operation of text generation. Add tokens in the sample for more probable to least probable until the sum of the probabilities is greater than top_p.",
   311                "instillAcceptFormats": [
   312                  "number",
   313                  "integer"
   314                ],
   315                "instillShortDescription": "Float to define the tokens that are within the sample operation of text generation.",
   316                "instillUIOrder": 6,
   317                "instillUpstreamTypes": [
   318                  "value",
   319                  "reference"
   320                ],
   321                "title": "Top P",
   322                "type": "number"
   323              }
   324            },
   325            "required": [],
   326            "description": "Parameters",
   327            "title": "Parameters",
   328            "type": "object"
   329          }
   330        },
   331        "required": [
   332          "inputs",
   333          "model"
   334        ],
   335        "title": "Input",
   336        "type": "object"
   337      },
   338      "output": {
   339        "instillUIOrder": 0,
   340        "properties": {
   341          "conversation": {
   342            "description": "A facility dictionnary to send back for the next input (with the new user input addition).",
   343            "instillUIOrder": 0,
   344            "properties": {
   345              "generated_responses": {
   346                "description": "List of strings. The last outputs from the model in the conversation, after the model has run.",
   347                "instillUIOrder": 0,
   348                "instillFormat": "array:string",
   349                "items": {
   350                  "title": "Generated Response",
   351                  "instillFormat": "string",
   352                  "instillUIMultiline": true,
   353                  "description": "Generated Response",
   354                  "type": "string"
   355                },
   356                "title": "Generated Responses",
   357                "type": "array"
   358              },
   359              "past_user_inputs": {
   360                "description": "List of strings. The last inputs from the user in the conversation, after the model has run.",
   361                "instillUIOrder": 1,
   362                "instillFormat": "array:string",
   363                "items": {
   364                  "instillFormat": "string",
   365                  "instillUIMultiline": true,
   366                  "title": "Past User Input",
   367                  "description": "Past User Input",
   368                  "type": "string"
   369                },
   370                "title": "Past User Inputs",
   371                "type": "array"
   372              }
   373            },
   374            "required": [
   375              "generated_responses",
   376              "past_user_inputs"
   377            ],
   378            "title": "Conversation",
   379            "type": "object"
   380          },
   381          "generated_text": {
   382            "description": "The answer of the bot",
   383            "instillFormat": "string",
   384            "instillUIMultiline": true,
   385            "instillUIOrder": 1,
   386            "title": "Generated Text",
   387            "type": "string"
   388          }
   389        },
   390        "required": [
   391          "generated_text"
   392        ],
   393        "title": "Output",
   394        "type": "object"
   395      }
   396    },
   397    "TASK_FILL_MASK": {
   398      "instillShortDescription": "Masked language modeling is the task of masking some of the words in a sentence and predicting which words should replace those masks.",
   399      "description": "Masked language modeling is the task of masking some of the words in a sentence and predicting which words should replace those masks. These models are useful when we want to get a statistical understanding of the language in which the model is trained in.",
   400      "input": {
   401        "instillUIOrder": 0,
   402        "properties": {
   403          "inputs": {
   404            "$ref": "#/$defs/string_input",
   405            "description": "a string to be filled from, must contain the [MASK] token (check model card for exact name of the mask)",
   406            "instillUIOrder": 1
   407          },
   408          "model": {
   409            "$ref": "#/$defs/model",
   410            "instillUIOrder": 0
   411          },
   412          "options": {
   413            "$ref": "#/$defs/options",
   414            "instillUIOrder": 2
   415          }
   416        },
   417        "required": [
   418          "inputs",
   419          "model"
   420        ],
   421        "title": "Input",
   422        "type": "object"
   423      },
   424      "output": {
   425        "instillUIOrder": 0,
   426        "properties": {
   427          "results": {
   428            "instillUIOrder": 0,
   429            "items": {
   430              "properties": {
   431                "score": {
   432                  "description": "The probability for this token.",
   433                  "instillFormat": "number",
   434                  "instillUIOrder": 0,
   435                  "title": "Score",
   436                  "type": "number"
   437                },
   438                "sequence": {
   439                  "description": "The actual sequence of tokens that ran against the model (may contain special tokens)",
   440                  "instillFormat": "string",
   441                  "instillUIMultiline": true,
   442                  "instillUIOrder": 1,
   443                  "title": "Sequence",
   444                  "type": "string"
   445                },
   446                "token": {
   447                  "description": "The id of the token",
   448                  "instillFormat": "integer",
   449                  "instillUIOrder": 2,
   450                  "title": "Token",
   451                  "type": "integer"
   452                },
   453                "token_str": {
   454                  "description": "The string representation of the token",
   455                  "instillFormat": "string",
   456                  "instillUIOrder": 3,
   457                  "title": "Token Str",
   458                  "type": "string"
   459                }
   460              },
   461              "description": "Result",
   462              "title": "Result",
   463              "required": [],
   464              "type": "object"
   465            },
   466            "description": "Results",
   467            "title": "Results",
   468            "type": "array"
   469          }
   470        },
   471        "required": [
   472          "results"
   473        ],
   474        "title": "Output",
   475        "type": "object"
   476      }
   477    },
   478    "TASK_IMAGE_CLASSIFICATION": {
   479      "instillShortDescription": "Image classification is the task of assigning a label or class to an entire image.",
   480      "description": "Image classification is the task of assigning a label or class to an entire image. Images are expected to have only one class for each image. Image classification models take an image as input and return a prediction about which class the image belongs to.",
   481      "input": {
   482        "instillUIOrder": 0,
   483        "properties": {
   484          "image": {
   485            "description": "The image file",
   486            "instillAcceptFormats": [
   487              "image/*"
   488            ],
   489            "instillUIOrder": 1,
   490            "instillUpstreamTypes": [
   491              "reference"
   492            ],
   493            "title": "Image",
   494            "type": "string"
   495          },
   496          "model": {
   497            "$ref": "#/$defs/model",
   498            "instillUIOrder": 0
   499          }
   500        },
   501        "required": [
   502          "image",
   503          "model"
   504        ],
   505        "title": "Input",
   506        "type": "object"
   507      },
   508      "output": {
   509        "instillUIOrder": 0,
   510        "properties": {
   511          "classes": {
   512            "instillUIOrder": 0,
   513            "items": {
   514              "properties": {
   515                "label": {
   516                  "description": "The label for the class (model specific)",
   517                  "instillFormat": "string",
   518                  "instillUIOrder": 0,
   519                  "title": "Label",
   520                  "type": "string"
   521                },
   522                "score": {
   523                  "description": "A float that represents how likely it is that the image file belongs to this class.",
   524                  "instillFormat": "number",
   525                  "instillUIOrder": 0,
   526                  "title": "Score",
   527                  "type": "number"
   528                }
   529              },
   530              "required": [
   531                "label",
   532                "score"
   533              ],
   534              "description": "Class",
   535              "title": "Class",
   536              "type": "object"
   537            },
   538            "description": "Classes",
   539            "title": "Classes",
   540            "type": "array"
   541          }
   542        },
   543        "required": [
   544          "classes"
   545        ],
   546        "title": "Output",
   547        "type": "object"
   548      }
   549    },
   550    "TASK_IMAGE_SEGMENTATION": {
   551      "instillShortDescription": "Image Segmentation divides an image into segments where each pixel in the image is mapped to an object.",
   552      "description": "Image Segmentation divides an image into segments where each pixel in the image is mapped to an object. This task has multiple variants such as instance segmentation, panoptic segmentation and semantic segmentation.",
   553      "input": {
   554        "instillUIOrder": 0,
   555        "properties": {
   556          "image": {
   557            "description": "The image file",
   558            "instillAcceptFormats": [
   559              "image/*"
   560            ],
   561            "instillUIOrder": 1,
   562            "instillUpstreamTypes": [
   563              "reference"
   564            ],
   565            "title": "Image",
   566            "type": "string"
   567          },
   568          "model": {
   569            "$ref": "#/$defs/model",
   570            "instillUIOrder": 0
   571          }
   572        },
   573        "required": [
   574          "image",
   575          "model"
   576        ],
   577        "title": "Input",
   578        "type": "object"
   579      },
   580      "output": {
   581        "instillUIOrder": 0,
   582        "properties": {
   583          "segments": {
   584            "instillUIOrder": 0,
   585            "items": {
   586              "properties": {
   587                "label": {
   588                  "description": "The label for the class (model specific) of a segment.",
   589                  "instillFormat": "string",
   590                  "instillUIOrder": 0,
   591                  "title": "Label",
   592                  "type": "string"
   593                },
   594                "mask": {
   595                  "description": "A str (base64 str of a single channel black-and-white img) representing the mask of a segment.",
   596                  "instillFormat": "image/png",
   597                  "instillUIOrder": 1,
   598                  "title": "Mask",
   599                  "type": "string"
   600                },
   601                "score": {
   602                  "description": "A float that represents how likely it is that the segment belongs to the given class.",
   603                  "instillFormat": "number",
   604                  "instillUIOrder": 2,
   605                  "title": "Score",
   606                  "type": "number"
   607                }
   608              },
   609              "required": [
   610                "label",
   611                "mask",
   612                "score"
   613              ],
   614              "description": "Segment",
   615              "title": "Segment",
   616              "type": "object"
   617            },
   618            "description": "Segments",
   619            "title": "Segments",
   620            "type": "array"
   621          }
   622        },
   623        "required": [
   624          "segments"
   625        ],
   626        "title": "Output",
   627        "type": "object"
   628      }
   629    },
   630    "TASK_IMAGE_TO_TEXT": {
   631      "instillShortDescription": "Image to text models output a text from a given image.",
   632      "description": "Image to text models output a text from a given image. Image captioning or optical character recognition can be considered as the most common applications of image to text.",
   633      "input": {
   634        "instillUIOrder": 0,
   635        "properties": {
   636          "image": {
   637            "description": "The image file",
   638            "instillAcceptFormats": [
   639              "image/*"
   640            ],
   641            "instillUIOrder": 1,
   642            "instillUpstreamTypes": [
   643              "reference"
   644            ],
   645            "title": "Image",
   646            "type": "string"
   647          },
   648          "model": {
   649            "$ref": "#/$defs/model",
   650            "instillUIOrder": 0
   651          }
   652        },
   653        "required": [
   654          "image",
   655          "model"
   656        ],
   657        "title": "Input",
   658        "type": "object"
   659      },
   660      "output": {
   661        "instillUIOrder": 0,
   662        "properties": {
   663          "text": {
   664            "description": "Generated text",
   665            "instillFormat": "string",
   666            "instillUIMultiline": true,
   667            "instillUIOrder": 0,
   668            "title": "Text",
   669            "type": "string"
   670          }
   671        },
   672        "required": [
   673          "text"
   674        ],
   675        "title": "Output",
   676        "type": "object"
   677      }
   678    },
   679    "TASK_OBJECT_DETECTION": {
   680      "instillShortDescription": "Object Detection models allow users to identify objects of certain defined classes.",
   681      "description": "Object Detection models allow users to identify objects of certain defined classes. Object detection models receive an image as input and output the images with bounding boxes and labels on detected objects.",
   682      "input": {
   683        "instillUIOrder": 0,
   684        "properties": {
   685          "image": {
   686            "description": "The image file",
   687            "instillAcceptFormats": [
   688              "image/*"
   689            ],
   690            "instillUIOrder": 1,
   691            "instillUpstreamTypes": [
   692              "reference"
   693            ],
   694            "title": "Image",
   695            "type": "string"
   696          },
   697          "model": {
   698            "$ref": "#/$defs/model",
   699            "instillUIOrder": 0
   700          }
   701        },
   702        "required": [
   703          "image",
   704          "model"
   705        ],
   706        "title": "Input",
   707        "type": "object"
   708      },
   709      "output": {
   710        "instillUIOrder": 0,
   711        "properties": {
   712          "objects": {
   713            "instillUIOrder": 0,
   714            "items": {
   715              "properties": {
   716                "box": {
   717                  "description": "A dict (with keys [xmin,ymin,xmax,ymax]) representing the bounding box of a detected object.",
   718                  "instillUIOrder": 0,
   719                  "properties": {
   720                    "xmax": {
   721                      "description": "X max",
   722                      "instillFormat": "number",
   723                      "instillUIOrder": 0,
   724                      "title": "X Max",
   725                      "type": "number"
   726                    },
   727                    "xmin": {
   728                      "description": "X min",
   729                      "instillFormat": "number",
   730                      "instillUIOrder": 1,
   731                      "title": "X Min",
   732                      "type": "number"
   733                    },
   734                    "ymax": {
   735                      "description": "Y Max",
   736                      "instillFormat": "number",
   737                      "instillUIOrder": 2,
   738                      "title": "Y Max",
   739                      "type": "number"
   740                    },
   741                    "ymin": {
   742                      "description": "Y min",
   743                      "instillFormat": "number",
   744                      "instillUIOrder": 3,
   745                      "title": "Y min",
   746                      "type": "number"
   747                    }
   748                  },
   749                  "required": [
   750                    "xmax",
   751                    "xmin",
   752                    "ymax",
   753                    "ymin"
   754                  ],
   755                  "title": "Box",
   756                  "type": "object"
   757                },
   758                "label": {
   759                  "description": "The label for the class (model specific) of a detected object.",
   760                  "instillFormat": "string",
   761                  "instillUIOrder": 1,
   762                  "title": "Label",
   763                  "type": "string"
   764                },
   765                "score": {
   766                  "description": "A float that represents how likely it is that the detected object belongs to the given class.",
   767                  "instillFormat": "number",
   768                  "instillUIOrder": 2,
   769                  "title": "Score",
   770                  "type": "number"
   771                }
   772              },
   773              "required": [
   774                "box",
   775                "label",
   776                "score"
   777              ],
   778              "description": "Object",
   779              "title": "Object",
   780              "type": "object"
   781            },
   782            "description": "Objects",
   783            "title": "Objects",
   784            "type": "array"
   785          }
   786        },
   787        "required": [
   788          "objects"
   789        ],
   790        "title": "Output",
   791        "type": "object"
   792      }
   793    },
   794    "TASK_QUESTION_ANSWERING": {
   795      "instillShortDescription": "Question Answering models can retrieve the answer to a question from a given text, which is useful for searching for an answer in a document.",
   796      "description": "Question Answering models can retrieve the answer to a question from a given text, which is useful for searching for an answer in a document. Some question answering models can generate answers without context!",
   797      "input": {
   798        "instillUIOrder": 0,
   799        "properties": {
   800          "inputs": {
   801            "instillUIOrder": 1,
   802            "properties": {
   803              "context": {
   804                "description": "The context for answering the question.",
   805                "instillAcceptFormats": [
   806                  "string"
   807                ],
   808                "instillUIMultiline": true,
   809                "instillUIOrder": 0,
   810                "instillUpstreamTypes": [
   811                  "value",
   812                  "reference",
   813                  "template"
   814                ],
   815                "title": "Context",
   816                "type": "string"
   817              },
   818              "question": {
   819                "description": "The question",
   820                "instillAcceptFormats": [
   821                  "string"
   822                ],
   823                "instillUIMultiline": true,
   824                "instillUIOrder": 1,
   825                "instillUpstreamTypes": [
   826                  "value",
   827                  "reference",
   828                  "template"
   829                ],
   830                "title": "Question",
   831                "type": "string"
   832              }
   833            },
   834            "required": [
   835              "question",
   836              "context"
   837            ],
   838            "description": "Inputs",
   839            "title": "Inputs",
   840            "type": "object"
   841          },
   842          "model": {
   843            "$ref": "#/$defs/model",
   844            "instillUIOrder": 0
   845          },
   846          "options": {
   847            "$ref": "#/$defs/options",
   848            "instillUIOrder": 2
   849          }
   850        },
   851        "required": [
   852          "inputs",
   853          "model"
   854        ],
   855        "title": "Input",
   856        "type": "object"
   857      },
   858      "output": {
   859        "instillUIOrder": 0,
   860        "properties": {
   861          "answer": {
   862            "description": "A string that\u2019s the answer within the text.",
   863            "instillFormat": "string",
   864            "instillUIMultiline": true,
   865            "instillUIOrder": 0,
   866            "title": "Answer",
   867            "type": "string"
   868          },
   869          "score": {
   870            "description": "A float that represents how likely that the answer is correct",
   871            "instillFormat": "number",
   872            "instillUIOrder": 2,
   873            "title": "Score",
   874            "type": "number"
   875          },
   876          "start": {
   877            "description": "The index (string wise) of the start of the answer within context.",
   878            "instillFormat": "integer",
   879            "instillUIOrder": 3,
   880            "title": "Start",
   881            "type": "integer"
   882          },
   883          "stop": {
   884            "description": "The index (string wise) of the stop of the answer within context.",
   885            "instillFormat": "integer",
   886            "instillUIOrder": 1,
   887            "title": "Stop",
   888            "type": "integer"
   889          }
   890        },
   891        "required": [
   892          "answer"
   893        ],
   894        "title": "Output",
   895        "type": "object"
   896      }
   897    },
   898    "TASK_SENTENCE_SIMILARITY": {
   899      "instillShortDescription": "Sentence Similarity is the task of determining how similar two texts are.",
   900      "description": "Sentence Similarity is the task of determining how similar two texts are. Sentence similarity models convert input texts into vectors (embeddings) that capture semantic information and calculate how close (similar) they are between them. This task is particularly useful for information retrieval and clustering/grouping.",
   901      "input": {
   902        "instillUIOrder": 0,
   903        "properties": {
   904          "inputs": {
   905            "instillUIOrder": 1,
   906            "properties": {
   907              "sentences": {
   908                "description": "A list of strings which will be compared against the source_sentence.",
   909                "instillAcceptFormats": [
   910                  "array:string"
   911                ],
   912                "instillUIOrder": 0,
   913                "instillUpstreamTypes": [
   914                  "value",
   915                  "reference"
   916                ],
   917                "items": {
   918                  "description": "Items",
   919                  "instillUIMultiline": true,
   920                  "type": "string"
   921                },
   922                "title": "Sentences",
   923                "type": "array"
   924              },
   925              "source_sentence": {
   926                "description": "The string that you wish to compare the other strings with. This can be a phrase, sentence, or longer passage, depending on the model being used.",
   927                "instillAcceptFormats": [
   928                  "string"
   929                ],
   930                "instillShortDescription": "The string that you wish to compare the other strings with.",
   931                "instillUIMultiline": true,
   932                "instillUIOrder": 1,
   933                "instillUpstreamTypes": [
   934                  "value",
   935                  "reference"
   936                ],
   937                "title": "Source Sentence",
   938                "type": "string"
   939              }
   940            },
   941            "required": [
   942              "source_sentence",
   943              "sentences"
   944            ],
   945            "description": "Inputs",
   946            "title": "Inputs",
   947            "type": "object"
   948          },
   949          "model": {
   950            "$ref": "#/$defs/model",
   951            "instillUIOrder": 0
   952          },
   953          "options": {
   954            "$ref": "#/$defs/options",
   955            "instillUIOrder": 2
   956          }
   957        },
   958        "required": [
   959          "inputs",
   960          "model"
   961        ],
   962        "title": "Input",
   963        "type": "object"
   964      },
   965      "output": {
   966        "instillUIOrder": 0,
   967        "properties": {
   968          "scores": {
   969            "description": "The associated similarity score for each of the given strings",
   970            "instillUIOrder": 0,
   971            "instillFormat": "array:number",
   972            "items": {
   973              "instillFormat": "number",
   974              "description": "The associated similarity score for of the given string",
   975              "title": "Score",
   976              "type": "number"
   977            },
   978            "title": "Scores",
   979            "type": "array"
   980          }
   981        },
   982        "required": [
   983          "scores"
   984        ],
   985        "title": "Output",
   986        "type": "object"
   987      }
   988    },
   989    "TASK_SPEECH_RECOGNITION": {
   990      "instillShortDescription": "Automatic Speech Recognition (ASR), also known as Speech to Text (STT), is the task of transcribing a given audio to text.",
   991      "description": "Automatic Speech Recognition (ASR), also known as Speech to Text (STT), is the task of transcribing a given audio to text. It has many applications, such as voice user interfaces.",
   992      "input": {
   993        "instillUIOrder": 0,
   994        "properties": {
   995          "audio": {
   996            "description": "The audio file",
   997            "instillAcceptFormats": [
   998              "audio/*"
   999            ],
  1000            "instillUIOrder": 1,
  1001            "instillUpstreamTypes": [
  1002              "reference"
  1003            ],
  1004            "title": "Audio",
  1005            "type": "string"
  1006          },
  1007          "model": {
  1008            "$ref": "#/$defs/model",
  1009            "instillUIOrder": 0
  1010          }
  1011        },
  1012        "required": [
  1013          "audio",
  1014          "model"
  1015        ],
  1016        "title": "Input",
  1017        "type": "object"
  1018      },
  1019      "output": {
  1020        "instillUIOrder": 0,
  1021        "properties": {
  1022          "text": {
  1023            "description": "The string that was recognized within the audio file.",
  1024            "instillFormat": "string",
  1025            "instillUIMultiline": true,
  1026            "instillUIOrder": 0,
  1027            "title": "Text",
  1028            "type": "string"
  1029          }
  1030        },
  1031        "required": [
  1032          "text"
  1033        ],
  1034        "title": "Output",
  1035        "type": "object"
  1036      }
  1037    },
  1038    "TASK_SUMMARIZATION": {
  1039      "instillShortDescription": "Summarization is the task of producing a shorter version of a document while preserving its important information.",
  1040      "description": "Summarization is the task of producing a shorter version of a document while preserving its important information. Some models can extract text from the original input, while other models can generate entirely new text.",
  1041      "input": {
  1042        "instillUIOrder": 0,
  1043        "properties": {
  1044          "inputs": {
  1045            "$ref": "#/$defs/string_input",
  1046            "instillUIOrder": 1
  1047          },
  1048          "model": {
  1049            "$ref": "#/$defs/model",
  1050            "instillUIOrder": 0
  1051          },
  1052          "options": {
  1053            "$ref": "#/$defs/options",
  1054            "instillUIOrder": 3
  1055          },
  1056          "parameters": {
  1057            "instillUIOrder": 2,
  1058            "properties": {
  1059              "max_length": {
  1060                "description": "Integer to define the maximum length in tokens of the output summary.",
  1061                "instillAcceptFormats": [
  1062                  "integer"
  1063                ],
  1064                "instillUIOrder": 0,
  1065                "instillUpstreamTypes": [
  1066                  "value",
  1067                  "reference"
  1068                ],
  1069                "title": "Max Length",
  1070                "type": "integer"
  1071              },
  1072              "max_time": {
  1073                "instillAcceptFormats": [
  1074                  "number",
  1075                  "integer"
  1076                ],
  1077                "instillUIOrder": 1,
  1078                "instillUpstreamTypes": [
  1079                  "value",
  1080                  "reference"
  1081                ],
  1082                "maximum": 120.0,
  1083                "minimum": 0.0,
  1084                "title": "Max Time",
  1085                "type": "number"
  1086              },
  1087              "min_length": {
  1088                "description": "Integer to define the minimum length in tokens of the output summary.",
  1089                "instillAcceptFormats": [
  1090                  "integer"
  1091                ],
  1092                "instillUIOrder": 2,
  1093                "instillUpstreamTypes": [
  1094                  "value",
  1095                  "reference"
  1096                ],
  1097                "title": "Min Length",
  1098                "type": "integer"
  1099              },
  1100              "repetition_penalty": {
  1101                "description": "The more a token is used within generation the more it is penalized to not be picked in successive generation passes.",
  1102                "instillAcceptFormats": [
  1103                  "number",
  1104                  "integer"
  1105                ],
  1106                "instillUIOrder": 3,
  1107                "instillUpstreamTypes": [
  1108                  "value",
  1109                  "reference"
  1110                ],
  1111                "maximum": 100.0,
  1112                "minimum": 0.0,
  1113                "title": "Repetition Penalty",
  1114                "type": "number"
  1115              },
  1116              "temperature": {
  1117                "default": 1.0,
  1118                "description": "The temperature of the sampling operation. 1 means regular sampling, 0 means always take the highest score, 100.0 is getting closer to uniform probability.",
  1119                "instillAcceptFormats": [
  1120                  "number",
  1121                  "integer"
  1122                ],
  1123                "instillShortDescription": "The temperature of the sampling operation.",
  1124                "instillUIOrder": 4,
  1125                "instillUpstreamTypes": [
  1126                  "value",
  1127                  "reference"
  1128                ],
  1129                "maximum": 100.0,
  1130                "minimum": 0.0,
  1131                "title": "Temperature",
  1132                "type": "number"
  1133              },
  1134              "top_k": {
  1135                "description": "Integer to define the top tokens considered within the sample operation to create new text.",
  1136                "instillAcceptFormats": [
  1137                  "integer"
  1138                ],
  1139                "instillUIOrder": 5,
  1140                "instillUpstreamTypes": [
  1141                  "value",
  1142                  "reference"
  1143                ],
  1144                "title": "Top K",
  1145                "type": "integer"
  1146              },
  1147              "top_p": {
  1148                "description": "Float to define the tokens that are within the sample operation of text generation. Add tokens in the sample for more probable to least probable until the sum of the probabilities is greater than top_p.",
  1149                "instillAcceptFormats": [
  1150                  "number",
  1151                  "integer"
  1152                ],
  1153                "instillShortDescription": "Float to define the tokens that are within the sample operation of text generation.",
  1154                "instillUIOrder": 6,
  1155                "instillUpstreamTypes": [
  1156                  "value",
  1157                  "reference"
  1158                ],
  1159                "title": "Top P",
  1160                "type": "number"
  1161              }
  1162            },
  1163            "required": [],
  1164            "description": "Parameters",
  1165            "title": "Parameters",
  1166            "type": "object"
  1167          }
  1168        },
  1169        "required": [
  1170          "inputs",
  1171          "model"
  1172        ],
  1173        "title": "Input",
  1174        "type": "object"
  1175      },
  1176      "output": {
  1177        "instillUIOrder": 0,
  1178        "properties": {
  1179          "summary_text": {
  1180            "description": "The string after summarization",
  1181            "instillFormat": "string",
  1182            "instillUIMultiline": true,
  1183            "instillUIOrder": 0,
  1184            "title": "Summary Text",
  1185            "type": "string"
  1186          }
  1187        },
  1188        "required": [
  1189          "summary_text"
  1190        ],
  1191        "title": "Output",
  1192        "type": "object"
  1193      }
  1194    },
  1195    "TASK_TABLE_QUESTION_ANSWERING": {
  1196      "instillShortDescription": "Table Question Answering (Table QA) is the answering a question about an information on a given table.",
  1197      "input": {
  1198        "instillUIOrder": 0,
  1199        "properties": {
  1200          "inputs": {
  1201            "instillUIOrder": 1,
  1202            "properties": {
  1203              "query": {
  1204                "description": "The query in plain text that you want to ask the table",
  1205                "instillAcceptFormats": [
  1206                  "string"
  1207                ],
  1208                "instillUIMultiline": true,
  1209                "instillUIOrder": 0,
  1210                "instillUpstreamTypes": [
  1211                  "value",
  1212                  "reference"
  1213                ],
  1214                "title": "Query",
  1215                "type": "string"
  1216              },
  1217              "table": {
  1218                "description": "A table of data represented as a dict of list where entries are headers and the lists are all the values, all lists must have the same size.",
  1219                "instillAcceptFormats": [
  1220                  "*"
  1221                ],
  1222                "instillUIOrder": 1,
  1223                "instillUpstreamTypes": [
  1224                  "reference",
  1225                  "value"
  1226                ],
  1227                "required": [],
  1228                "title": "Table",
  1229                "type": "object"
  1230              }
  1231            },
  1232            "required": [
  1233              "query",
  1234              "table"
  1235            ],
  1236            "description": "Inputs",
  1237            "title": "Inputs",
  1238            "type": "object"
  1239          },
  1240          "model": {
  1241            "$ref": "#/$defs/model",
  1242            "instillUIOrder": 0
  1243          },
  1244          "options": {
  1245            "$ref": "#/$defs/options",
  1246            "instillUIOrder": 2
  1247          }
  1248        },
  1249        "required": [
  1250          "inputs",
  1251          "model"
  1252        ],
  1253        "title": "Input",
  1254        "type": "object"
  1255      },
  1256      "output": {
  1257        "instillUIOrder": 0,
  1258        "properties": {
  1259          "aggregator": {
  1260            "description": "The aggregator used to get the answer",
  1261            "instillFormat": "string",
  1262            "instillUIOrder": 0,
  1263            "title": "Aggregator",
  1264            "type": "string"
  1265          },
  1266          "answer": {
  1267            "description": "The plaintext answer",
  1268            "instillFormat": "string",
  1269            "instillUIMultiline": true,
  1270            "instillUIOrder": 1,
  1271            "title": "Answer",
  1272            "type": "string"
  1273          },
  1274          "cells": {
  1275            "description": "a list of coordinates of the cells contents",
  1276            "instillUIOrder": 2,
  1277            "instillFormat": "array:string",
  1278            "items": {
  1279              "description": "coordinate of the cell content",
  1280              "instillFormat": "string",
  1281              "instillUIMultiline": true,
  1282              "title": "Cell",
  1283              "type": "string"
  1284            },
  1285            "title": "Cells",
  1286            "type": "array"
  1287          },
  1288          "coordinates": {
  1289            "description": "a list of coordinates of the cells referenced in the answer",
  1290            "instillUIOrder": 3,
  1291            "items": {
  1292              "items": {
  1293                "instillFormat": "integer",
  1294                "description": "coordinate of the cell referenced in the answer",
  1295                "title": "Coordinate",
  1296                "type": "integer"
  1297              },
  1298              "instillFormat": "array:integer",
  1299              "type": "array"
  1300            },
  1301            "title": "Coordinates",
  1302            "type": "array"
  1303          }
  1304        },
  1305        "required": [
  1306          "answer"
  1307        ],
  1308        "title": "Output",
  1309        "type": "object"
  1310      }
  1311    },
  1312    "TASK_TEXT_CLASSIFICATION": {
  1313      "instillShortDescription": "Text Classification is the task of assigning a label or class to a given text.",
  1314      "description": "Text Classification is the task of assigning a label or class to a given text. Some use cases are sentiment analysis, natural language inference, and assessing grammatical correctness.",
  1315      "input": {
  1316        "instillUIOrder": 0,
  1317        "properties": {
  1318          "inputs": {
  1319            "$ref": "#/$defs/string_input",
  1320            "instillUIOrder": 1
  1321          },
  1322          "model": {
  1323            "$ref": "#/$defs/model",
  1324            "instillUIOrder": 0
  1325          },
  1326          "options": {
  1327            "$ref": "#/$defs/options",
  1328            "instillUIOrder": 2
  1329          }
  1330        },
  1331        "required": [
  1332          "inputs",
  1333          "model"
  1334        ],
  1335        "title": "Input",
  1336        "type": "object"
  1337      },
  1338      "output": {
  1339        "instillUIOrder": 0,
  1340        "properties": {
  1341          "results": {
  1342            "instillUIOrder": 0,
  1343            "items": {
  1344              "properties": {
  1345                "label": {
  1346                  "description": "The label for the class (model specific)",
  1347                  "instillFormat": "string",
  1348                  "instillUIOrder": 0,
  1349                  "title": "Label",
  1350                  "type": "string"
  1351                },
  1352                "score": {
  1353                  "description": "A floats that represents how likely is that the text belongs the this class.",
  1354                  "instillFormat": "number",
  1355                  "instillUIOrder": 1,
  1356                  "title": "Score",
  1357                  "type": "number"
  1358                }
  1359              },
  1360              "required": [
  1361                "label",
  1362                "score"
  1363              ],
  1364              "description": "Result",
  1365              "title": "Result",
  1366              "type": "object"
  1367            },
  1368            "description": "Results",
  1369            "title": "Results",
  1370            "type": "array"
  1371          }
  1372        },
  1373        "required": [
  1374          "results"
  1375        ],
  1376        "title": "Output",
  1377        "type": "object"
  1378      }
  1379    },
  1380    "TASK_TEXT_GENERATION": {
  1381      "instillShortDescription": "Generating text is the task of producing new text. These models can, for example, fill in incomplete text or paraphrase.",
  1382      "description": "Generating text is the task of producing new text. These models can, for example, fill in incomplete text or paraphrase.",
  1383      "input": {
  1384        "instillUIOrder": 0,
  1385        "properties": {
  1386          "inputs": {
  1387            "$ref": "#/$defs/string_input",
  1388            "instillUIOrder": 1
  1389          },
  1390          "model": {
  1391            "$ref": "#/$defs/model",
  1392            "instillUIOrder": 0
  1393          },
  1394          "options": {
  1395            "$ref": "#/$defs/options",
  1396            "instillUIOrder": 3
  1397          },
  1398          "parameters": {
  1399            "instillUIOrder": 2,
  1400            "properties": {
  1401              "do_sample": {
  1402                "description": "Whether or not to use sampling, use greedy decoding otherwise.",
  1403                "instillAcceptFormats": [
  1404                  "boolean"
  1405                ],
  1406                "instillUIOrder": 0,
  1407                "instillUpstreamTypes": [
  1408                  "value",
  1409                  "reference"
  1410                ],
  1411                "title": "Do Sample",
  1412                "type": "boolean"
  1413              },
  1414              "max_new_tokens": {
  1415                "description": "The amount of new tokens to be generated, this does not include the input length it is a estimate of the size of generated text you want. Each new tokens slows down the request, so look for balance between response times and length of text generated.",
  1416                "instillAcceptFormats": [
  1417                  "integer"
  1418                ],
  1419                "instillShortDescription": "The amount of new tokens to be generated.",
  1420                "instillUIOrder": 1,
  1421                "instillUpstreamTypes": [
  1422                  "value",
  1423                  "reference"
  1424                ],
  1425                "title": "Max New Tokens",
  1426                "type": "integer"
  1427              },
  1428              "max_time": {
  1429                "description": "The amount of time in seconds that the query should take maximum. Network can cause some overhead so it will be a soft limit. Use that in combination with max_new_tokens for best results.",
  1430                "instillAcceptFormats": [
  1431                  "number",
  1432                  "integer"
  1433                ],
  1434                "instillShortDescription": "The amount of time in seconds that the query should take maximum.",
  1435                "instillUIOrder": 2,
  1436                "instillUpstreamTypes": [
  1437                  "value",
  1438                  "reference"
  1439                ],
  1440                "title": "Max Time",
  1441                "type": "number"
  1442              },
  1443              "num_return_sequences": {
  1444                "description": "The number of proposition you want to be returned.",
  1445                "instillAcceptFormats": [
  1446                  "integer"
  1447                ],
  1448                "instillUIOrder": 3,
  1449                "instillUpstreamTypes": [
  1450                  "value",
  1451                  "reference"
  1452                ],
  1453                "title": "Num Return Sequences",
  1454                "type": "integer"
  1455              },
  1456              "repetition_penalty": {
  1457                "description": "The more a token is used within generation the more it is penalized to not be picked in successive generation passes.",
  1458                "instillAcceptFormats": [
  1459                  "number",
  1460                  "integer"
  1461                ],
  1462                "instillUIOrder": 4,
  1463                "instillUpstreamTypes": [
  1464                  "value",
  1465                  "reference"
  1466                ],
  1467                "title": "Repetition Penalty",
  1468                "type": "number"
  1469              },
  1470              "return_full_text": {
  1471                "description": "If set to False, the return results will not contain the original query making it easier for prompting.",
  1472                "instillAcceptFormats": [
  1473                  "boolean"
  1474                ],
  1475                "instillUIOrder": 5,
  1476                "instillUpstreamTypes": [
  1477                  "value",
  1478                  "reference"
  1479                ],
  1480                "title": "Return Full Text",
  1481                "type": "boolean"
  1482              },
  1483              "temperature": {
  1484                "description": "The temperature of the sampling operation. 1 means regular sampling, 0 means always take the highest score, 100.0 is getting closer to uniform probability.",
  1485                "instillAcceptFormats": [
  1486                  "number",
  1487                  "integer"
  1488                ],
  1489                "instillShortDescription": "The temperature of the sampling operation.",
  1490                "instillUIOrder": 6,
  1491                "instillUpstreamTypes": [
  1492                  "value",
  1493                  "reference"
  1494                ],
  1495                "title": "Temperature",
  1496                "type": "number"
  1497              },
  1498              "top_k": {
  1499                "description": "Integer to define the top tokens considered within the sample operation to create new text.",
  1500                "instillAcceptFormats": [
  1501                  "integer"
  1502                ],
  1503                "instillUIOrder": 7,
  1504                "instillUpstreamTypes": [
  1505                  "value",
  1506                  "reference"
  1507                ],
  1508                "title": "Top K",
  1509                "type": "integer"
  1510              },
  1511              "top_p": {
  1512                "description": "Float to define the tokens that are within the sample operation of text generation. Add tokens in the sample for more probable to least probable until the sum of the probabilities is greater than top_p.",
  1513                "instillAcceptFormats": [
  1514                  "number",
  1515                  "integer"
  1516                ],
  1517                "instillShortDescription": "Float to define the tokens that are within the sample operation of text generation.",
  1518                "instillUIOrder": 8,
  1519                "instillUpstreamTypes": [
  1520                  "value",
  1521                  "reference"
  1522                ],
  1523                "title": "Top P",
  1524                "type": "number"
  1525              }
  1526            },
  1527            "required": [],
  1528            "description": "Parameters",
  1529            "title": "Parameters",
  1530            "type": "object"
  1531          }
  1532        },
  1533        "required": [
  1534          "inputs",
  1535          "model"
  1536        ],
  1537        "title": "Input",
  1538        "type": "object"
  1539      },
  1540      "output": {
  1541        "instillUIOrder": 0,
  1542        "properties": {
  1543          "generated_text": {
  1544            "description": "The continuated string",
  1545            "instillFormat": "string",
  1546            "instillUIMultiline": true,
  1547            "instillUIOrder": 1,
  1548            "title": "Generated Text",
  1549            "type": "string"
  1550          }
  1551        },
  1552        "required": [
  1553          "generated_text"
  1554        ],
  1555        "title": "Output",
  1556        "type": "object"
  1557      }
  1558    },
  1559    "TASK_TEXT_TO_IMAGE": {
  1560      "instillShortDescription": "Generates images from input text.",
  1561      "description": "Generates images from input text. These models can be used to generate and modify images based on text prompts.",
  1562      "input": {
  1563        "instillUIOrder": 0,
  1564        "properties": {
  1565          "inputs": {
  1566            "$ref": "#/$defs/string_input",
  1567            "instillUIOrder": 1
  1568          },
  1569          "model": {
  1570            "$ref": "#/$defs/model",
  1571            "instillUIOrder": 0
  1572          },
  1573          "options": {
  1574            "$ref": "#/$defs/options",
  1575            "instillUIOrder": 3
  1576          },
  1577          "parameters": {
  1578            "instillUIOrder": 2,
  1579            "properties": {
  1580              "guidance_scale": {
  1581                "description": "Guidance scale",
  1582                "instillAcceptFormats": [
  1583                  "number",
  1584                  "integer"
  1585                ],
  1586                "instillUIOrder": 0,
  1587                "instillUpstreamTypes": [
  1588                  "value",
  1589                  "reference"
  1590                ],
  1591                "title": "Guidance Scale",
  1592                "type": "number"
  1593              },
  1594              "height": {
  1595                "description": "Image Height",
  1596                "instillAcceptFormats": [
  1597                  "integer"
  1598                ],
  1599                "instillUIOrder": 1,
  1600                "instillUpstreamTypes": [
  1601                  "value",
  1602                  "reference"
  1603                ],
  1604                "title": "Height",
  1605                "type": "integer"
  1606              },
  1607              "negative_prompt": {
  1608                "description": "Negative prompt for generating the image",
  1609                "instillAcceptFormats": [
  1610                  "string"
  1611                ],
  1612                "instillUIMultiline": true,
  1613                "instillUIOrder": 2,
  1614                "instillUpstreamTypes": [
  1615                  "value",
  1616                  "reference",
  1617                  "template"
  1618                ],
  1619                "title": "Negative Prompt",
  1620                "type": "string"
  1621              },
  1622              "num_inference_steps": {
  1623                "description": "Number of inference steps",
  1624                "instillAcceptFormats": [
  1625                  "integer"
  1626                ],
  1627                "instillUIOrder": 3,
  1628                "instillUpstreamTypes": [
  1629                  "value",
  1630                  "reference"
  1631                ],
  1632                "title": "Num Inference Steps",
  1633                "type": "integer"
  1634              },
  1635              "width": {
  1636                "description": "Image width",
  1637                "instillAcceptFormats": [
  1638                  "integer"
  1639                ],
  1640                "instillUIOrder": 4,
  1641                "instillUpstreamTypes": [
  1642                  "value",
  1643                  "reference"
  1644                ],
  1645                "title": "Width",
  1646                "type": "integer"
  1647              }
  1648            },
  1649            "required": [],
  1650            "description": "Parameters",
  1651            "title": "Parameters",
  1652            "type": "object"
  1653          }
  1654        },
  1655        "required": [
  1656          "inputs",
  1657          "model"
  1658        ],
  1659        "title": "Input",
  1660        "type": "object"
  1661      },
  1662      "output": {
  1663        "instillUIOrder": 0,
  1664        "properties": {
  1665          "image": {
  1666            "instillFormat": "image/jpeg",
  1667            "instillUIOrder": 0,
  1668            "description": "Image",
  1669            "title": "Image",
  1670            "type": "string"
  1671          }
  1672        },
  1673        "required": [
  1674          "image"
  1675        ],
  1676        "title": "Output",
  1677        "type": "object"
  1678      }
  1679    },
  1680    "TASK_TOKEN_CLASSIFICATION": {
  1681      "instillShortDescription": "Token classification is a natural language understanding task in which a label is assigned to some tokens in a text.",
  1682      "description": "Token classification is a natural language understanding task in which a label is assigned to some tokens in a text. Some popular token classification subtasks are Named Entity Recognition (NER) and Part-of-Speech (PoS) tagging. NER models could be trained to identify specific entities in a text, such as dates, individuals and places; and PoS tagging would identify, for example, which words in a text are verbs, nouns, and punctuation marks.",
  1683      "input": {
  1684        "instillUIOrder": 0,
  1685        "properties": {
  1686          "inputs": {
  1687            "$ref": "#/$defs/string_input",
  1688            "instillUIOrder": 1
  1689          },
  1690          "model": {
  1691            "$ref": "#/$defs/model",
  1692            "instillUIOrder": 0
  1693          },
  1694          "options": {
  1695            "$ref": "#/$defs/options",
  1696            "instillUIOrder": 3
  1697          },
  1698          "parameters": {
  1699            "instillUIOrder": 2,
  1700            "properties": {
  1701              "aggregation_strategy": {
  1702                "description": "There are several aggregation strategies:\nnone: Every token gets classified without further aggregation.\nsimple: Entities are grouped according to the default schema (B-, I- tags get merged when the tag is similar).\nfirst: Same as the simple strategy except words cannot end up with different tags. Words will use the tag of the first token when there is ambiguity.\naverage: Same as the simple strategy except words cannot end up with different tags. Scores are averaged across tokens and then the maximum label is applied.\nmax: Same as the simple strategy except words cannot end up with different tags. Word entity will be the token with the maximum score.",
  1703                "instillAcceptFormats": [
  1704                  "string"
  1705                ],
  1706                "instillShortDescription": "There are several aggregation strategies: none, simple, first, average, and max.",
  1707                "instillUIOrder": 0,
  1708                "instillUpstreamTypes": [
  1709                  "value",
  1710                  "reference",
  1711                  "template"
  1712                ],
  1713                "title": "Aggregation Strategy",
  1714                "type": "string"
  1715              }
  1716            },
  1717            "required": [],
  1718            "description": "Parameters",
  1719            "title": "Parameters",
  1720            "type": "object"
  1721          }
  1722        },
  1723        "required": [
  1724          "inputs",
  1725          "model"
  1726        ],
  1727        "title": "Input",
  1728        "type": "object"
  1729      },
  1730      "output": {
  1731        "instillUIOrder": 0,
  1732        "properties": {
  1733          "results": {
  1734            "instillUIOrder": 0,
  1735            "items": {
  1736              "properties": {
  1737                "end": {
  1738                  "description": "The offset stringwise where the answer is located. Useful to disambiguate if word occurs multiple times.",
  1739                  "instillFormat": "integer",
  1740                  "instillUIOrder": 0,
  1741                  "title": "End",
  1742                  "type": "integer"
  1743                },
  1744                "entity_group": {
  1745                  "description": "The type for the entity being recognized (model specific).",
  1746                  "instillFormat": "string",
  1747                  "instillUIOrder": 1,
  1748                  "title": "Entity Group",
  1749                  "type": "string"
  1750                },
  1751                "score": {
  1752                  "description": "How likely the entity was recognized.",
  1753                  "instillFormat": "number",
  1754                  "instillUIOrder": 2,
  1755                  "title": "Score",
  1756                  "type": "number"
  1757                },
  1758                "start": {
  1759                  "description": "The offset stringwise where the answer is located. Useful to disambiguate if word occurs multiple times.",
  1760                  "instillFormat": "integer",
  1761                  "instillUIOrder": 3,
  1762                  "title": "Start",
  1763                  "type": "integer"
  1764                },
  1765                "word": {
  1766                  "description": "The string that was captured",
  1767                  "instillFormat": "string",
  1768                  "instillUIMultiline": true,
  1769                  "instillUIOrder": 4,
  1770                  "title": "Word",
  1771                  "type": "string"
  1772                }
  1773              },
  1774              "required": [],
  1775              "title": "Result",
  1776              "type": "object"
  1777            },
  1778            "description": "Results",
  1779            "title": "Results",
  1780            "type": "array"
  1781          }
  1782        },
  1783        "required": [
  1784          "results"
  1785        ],
  1786        "title": "Output",
  1787        "type": "object"
  1788      }
  1789    },
  1790    "TASK_TRANSLATION": {
  1791      "instillShortDescription": "Translation is the task of converting text from one language to another.",
  1792      "input": {
  1793        "instillUIOrder": 0,
  1794        "properties": {
  1795          "inputs": {
  1796            "$ref": "#/$defs/string_input",
  1797            "instillUIOrder": 1
  1798          },
  1799          "model": {
  1800            "$ref": "#/$defs/model",
  1801            "instillUIOrder": 0
  1802          },
  1803          "options": {
  1804            "$ref": "#/$defs/options",
  1805            "instillUIOrder": 2
  1806          }
  1807        },
  1808        "required": [
  1809          "inputs",
  1810          "model"
  1811        ],
  1812        "title": "Input",
  1813        "type": "object"
  1814      },
  1815      "output": {
  1816        "instillUIOrder": 0,
  1817        "properties": {
  1818          "translation_text": {
  1819            "description": "The string after translation",
  1820            "instillFormat": "string",
  1821            "instillUIMultiline": true,
  1822            "instillUIOrder": 0,
  1823            "title": "Translation Text",
  1824            "type": "string"
  1825          }
  1826        },
  1827        "required": [
  1828          "translation_text"
  1829        ],
  1830        "title": "Output",
  1831        "type": "object"
  1832      }
  1833    },
  1834    "TASK_ZERO_SHOT_CLASSIFICATION": {
  1835      "instillShortDescription": "Zero-shot text classification is a task in natural language processing where a model is trained on a set of labeled examples but is then able to classify new examples from previously unseen classes.",
  1836      "input": {
  1837        "instillUIOrder": 0,
  1838        "properties": {
  1839          "inputs": {
  1840            "$ref": "#/$defs/string_input",
  1841            "instillUIOrder": 1
  1842          },
  1843          "model": {
  1844            "$ref": "#/$defs/model",
  1845            "instillUIOrder": 0
  1846          },
  1847          "options": {
  1848            "$ref": "#/$defs/options",
  1849            "instillUIOrder": 3
  1850          },
  1851          "parameters": {
  1852            "instillUIOrder": 2,
  1853            "properties": {
  1854              "candidate_labels": {
  1855                "description": "a list of strings that are potential classes for inputs. (max 10 candidate_labels, for more, simply run multiple requests, results are going to be misleading if using too many candidate_labels anyway. If you want to keep the exact same, you can simply run multi_label=True and do the scaling on your end. )",
  1856                "instillShortDescription": "a list of strings that are potential classes for inputs.",
  1857                "instillUIOrder": 0,
  1858                "instillUpstreamTypes": [
  1859                  "value",
  1860                  "reference"
  1861                ],
  1862                "items": {
  1863                  "description": "a string that are potential class for inputs.",
  1864                  "title": "candidate_label",
  1865                  "type": "string"
  1866                },
  1867                "title": "Candidate Labels",
  1868                "type": "array"
  1869              },
  1870              "multi_label": {
  1871                "description": "Boolean that is set to True if classes can overlap",
  1872                "instillAcceptFormats": [
  1873                  "boolean"
  1874                ],
  1875                "instillUIOrder": 1,
  1876                "instillUpstreamTypes": [
  1877                  "value",
  1878                  "reference"
  1879                ],
  1880                "title": "Multi Label",
  1881                "type": "boolean"
  1882              }
  1883            },
  1884            "required": [
  1885              "candidate_labels"
  1886            ],
  1887            "description": "Parameters",
  1888            "title": "Parameters",
  1889            "type": "object"
  1890          }
  1891        },
  1892        "required": [
  1893          "inputs",
  1894          "model"
  1895        ],
  1896        "title": "Input",
  1897        "type": "object"
  1898      },
  1899      "output": {
  1900        "instillUIOrder": 0,
  1901        "properties": {
  1902          "labels": {
  1903            "description": "The list of strings for labels that you sent (in order)",
  1904            "instillUIOrder": 1,
  1905            "instillFormat": "array:string",
  1906            "items": {
  1907              "instillFormat": "string",
  1908              "description": "The string for label that you sent (in order)",
  1909              "title": "Label",
  1910              "type": "string"
  1911            },
  1912            "title": "Labels",
  1913            "type": "array"
  1914          },
  1915          "scores": {
  1916            "description": "a list of floats that correspond the the probability of label, in the same order as labels.",
  1917            "instillUIOrder": 0,
  1918            "instillFormat": "array:number",
  1919            "items": {
  1920              "description": "float that correspond the the probability of label.",
  1921              "instillFormat": "number",
  1922              "title": "Score",
  1923              "type": "number"
  1924            },
  1925            "title": "Scores",
  1926            "type": "array"
  1927          },
  1928          "sequence": {
  1929            "description": "The string sent as an input",
  1930            "instillFormat": "string",
  1931            "instillUIMultiline": true,
  1932            "instillUIOrder": 1,
  1933            "title": "Sequence",
  1934            "type": "string"
  1935          }
  1936        },
  1937        "required": [
  1938          "labels",
  1939          "scores"
  1940        ],
  1941        "title": "Output",
  1942        "type": "object"
  1943      }
  1944    }
  1945  }