@huggingface/transformers 4.0.0-next.1 → 4.0.0-next.10

package/types/pipelines.d.ts

@@ -13,6 +13,7 @@
  * @param {T} task The task defining which pipeline will be returned. Currently accepted tasks are:
  *  - `"audio-classification"`: will return a `AudioClassificationPipeline`.
  *  - `"automatic-speech-recognition"`: will return a `AutomaticSpeechRecognitionPipeline`.
+ *  - `"background-removal"`: will return a `BackgroundRemovalPipeline`.
  *  - `"depth-estimation"`: will return a `DepthEstimationPipeline`.
  *  - `"document-question-answering"`: will return a `DocumentQuestionAnsweringPipeline`.
  *  - `"feature-extraction"`: will return a `FeatureExtractionPipeline`.
@@ -63,296 +64,55 @@ export type AliasTasks = { [K in AliasType]: InstanceType<(typeof SUPPORTED_TASK
  * A mapping from all pipeline names and aliases to their corresponding pipeline classes.
  */
 export type AllTasks = SupportedTasks & AliasTasks;
-import { TextClassificationPipeline } from './pipelines/text-classification.js';
-import { TokenClassificationPipeline } from './pipelines/token-classification.js';
-import { QuestionAnsweringPipeline } from './pipelines/question-answering.js';
-import { FillMaskPipeline } from './pipelines/fill-mask.js';
-import { SummarizationPipeline } from './pipelines/summarization.js';
-import { TranslationPipeline } from './pipelines/translation.js';
-import { Text2TextGenerationPipeline } from './pipelines/text2text-generation.js';
-import { TextGenerationPipeline } from './pipelines/text-generation.js';
-import { ZeroShotClassificationPipeline } from './pipelines/zero-shot-classification.js';
-import { AudioClassificationPipeline } from './pipelines/audio-classification.js';
-import { ZeroShotAudioClassificationPipeline } from './pipelines/zero-shot-audio-classification.js';
-import { AutomaticSpeechRecognitionPipeline } from './pipelines/automatic-speech-recognition.js';
-import { TextToAudioPipeline } from './pipelines/text-to-audio.js';
-import { ImageToTextPipeline } from './pipelines/image-to-text.js';
-import { ImageClassificationPipeline } from './pipelines/image-classification.js';
-import { ImageSegmentationPipeline } from './pipelines/image-segmentation.js';
-import { BackgroundRemovalPipeline } from './pipelines/background-removal.js';
-import { ZeroShotImageClassificationPipeline } from './pipelines/zero-shot-image-classification.js';
-import { ObjectDetectionPipeline } from './pipelines/object-detection.js';
-import { ZeroShotObjectDetectionPipeline } from './pipelines/zero-shot-object-detection.js';
-import { DocumentQuestionAnsweringPipeline } from './pipelines/document-question-answering.js';
-import { ImageToImagePipeline } from './pipelines/image-to-image.js';
-import { DepthEstimationPipeline } from './pipelines/depth-estimation.js';
-import { FeatureExtractionPipeline } from './pipelines/feature-extraction.js';
-import { ImageFeatureExtractionPipeline } from './pipelines/image-feature-extraction.js';
-declare const SUPPORTED_TASKS: Readonly<{
-    'text-classification': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof TextClassificationPipeline;
-        model: typeof AutoModelForSequenceClassification;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'token-classification': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof TokenClassificationPipeline;
-        model: typeof AutoModelForTokenClassification;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'question-answering': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof QuestionAnsweringPipeline;
-        model: typeof AutoModelForQuestionAnswering;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'fill-mask': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof FillMaskPipeline;
-        model: typeof AutoModelForMaskedLM;
-        default: {
-            model: string;
-            dtype: string;
-        };
-        type: string;
-    };
-    summarization: {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof SummarizationPipeline;
-        model: typeof AutoModelForSeq2SeqLM;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    translation: {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof TranslationPipeline;
-        model: typeof AutoModelForSeq2SeqLM;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'text2text-generation': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof Text2TextGenerationPipeline;
-        model: typeof AutoModelForSeq2SeqLM;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'text-generation': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof TextGenerationPipeline;
-        model: typeof AutoModelForCausalLM;
-        default: {
-            model: string;
-            dtype: string;
-        };
-        type: string;
-    };
-    'zero-shot-classification': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof ZeroShotClassificationPipeline;
-        model: typeof AutoModelForSequenceClassification;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'audio-classification': {
-        pipeline: typeof AudioClassificationPipeline;
-        model: typeof AutoModelForAudioClassification;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'zero-shot-audio-classification': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof ZeroShotAudioClassificationPipeline;
-        model: typeof AutoModel;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'automatic-speech-recognition': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof AutomaticSpeechRecognitionPipeline;
-        model: (typeof AutoModelForSpeechSeq2Seq)[];
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'text-to-audio': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof TextToAudioPipeline;
-        model: (typeof AutoModelForTextToSpectrogram)[];
-        processor: (typeof AutoProcessor)[];
-        default: {
-            model: string;
-            dtype: string;
-        };
-        type: string;
-    };
-    'image-to-text': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof ImageToTextPipeline;
-        model: typeof AutoModelForVision2Seq;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'image-classification': {
-        pipeline: typeof ImageClassificationPipeline;
-        model: typeof AutoModelForImageClassification;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'image-segmentation': {
-        pipeline: typeof ImageSegmentationPipeline;
-        model: (typeof AutoModelForImageSegmentation)[];
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'background-removal': {
-        pipeline: typeof BackgroundRemovalPipeline;
-        model: (typeof AutoModelForImageSegmentation)[];
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'zero-shot-image-classification': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof ZeroShotImageClassificationPipeline;
-        model: typeof AutoModel;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'object-detection': {
-        pipeline: typeof ObjectDetectionPipeline;
-        model: typeof AutoModelForObjectDetection;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'zero-shot-object-detection': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof ZeroShotObjectDetectionPipeline;
-        model: typeof AutoModelForZeroShotObjectDetection;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'document-question-answering': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof DocumentQuestionAnsweringPipeline;
-        model: typeof AutoModelForDocumentQuestionAnswering;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'image-to-image': {
-        pipeline: typeof ImageToImagePipeline;
-        model: typeof AutoModelForImageToImage;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'depth-estimation': {
-        pipeline: typeof DepthEstimationPipeline;
-        model: typeof AutoModelForDepthEstimation;
-        processor: typeof AutoProcessor;
-        default: {
-            model: string;
-        };
-        type: string;
-    };
-    'feature-extraction': {
-        tokenizer: typeof AutoTokenizer;
-        pipeline: typeof FeatureExtractionPipeline;
-        model: typeof AutoModel;
-        default: {
-            model: string;
-            dtype: string;
-        };
-        type: string;
-    };
-    'image-feature-extraction': {
-        processor: typeof AutoProcessor;
-        pipeline: typeof ImageFeatureExtractionPipeline;
-        model: (typeof AutoModel)[];
-        default: {
-            model: string;
-            dtype: string;
-        };
-        type: string;
-    };
-}>;
-declare const TASK_ALIASES: Readonly<{
-    'sentiment-analysis': "text-classification";
-    ner: "token-classification";
-    asr: "automatic-speech-recognition";
-    'text-to-speech': "text-to-audio";
-    embeddings: "feature-extraction";
-}>;
-import { AutoTokenizer } from './models/auto/tokenization_auto.js';
-import { AutoModelForSequenceClassification } from './models/auto/modeling_auto.js';
-import { AutoModelForTokenClassification } from './models/auto/modeling_auto.js';
-import { AutoModelForQuestionAnswering } from './models/auto/modeling_auto.js';
-import { AutoModelForMaskedLM } from './models/auto/modeling_auto.js';
-import { AutoModelForSeq2SeqLM } from './models/auto/modeling_auto.js';
-import { AutoModelForCausalLM } from './models/auto/modeling_auto.js';
-import { AutoModelForAudioClassification } from './models/auto/modeling_auto.js';
-import { AutoProcessor } from './models/auto/processing_auto.js';
-import { AutoModel } from './models/auto/modeling_auto.js';
-import { AutoModelForSpeechSeq2Seq } from './models/auto/modeling_auto.js';
-import { AutoModelForTextToSpectrogram } from './models/auto/modeling_auto.js';
-import { AutoModelForVision2Seq } from './models/auto/modeling_auto.js';
-import { AutoModelForImageClassification } from './models/auto/modeling_auto.js';
-import { AutoModelForImageSegmentation } from './models/auto/modeling_auto.js';
-import { AutoModelForObjectDetection } from './models/auto/modeling_auto.js';
-import { AutoModelForZeroShotObjectDetection } from './models/auto/modeling_auto.js';
-import { AutoModelForDocumentQuestionAnswering } from './models/auto/modeling_auto.js';
-import { AutoModelForImageToImage } from './models/auto/modeling_auto.js';
-import { AutoModelForDepthEstimation } from './models/auto/modeling_auto.js';
+export type FillMaskOutput = import("./pipelines/fill-mask.js").FillMaskOutput;
+export type TextClassificationOutput = import("./pipelines/text-classification.js").TextClassificationOutput;
+export type TokenClassificationOutput = import("./pipelines/token-classification.js").TokenClassificationOutput;
+export type QuestionAnsweringOutput = import("./pipelines/question-answering.js").QuestionAnsweringOutput;
+export type SummarizationOutput = import("./pipelines/summarization.js").SummarizationOutput;
+export type TranslationOutput = import("./pipelines/translation.js").TranslationOutput;
+export type Text2TextGenerationOutput = import("./pipelines/text2text-generation.js").Text2TextGenerationOutput;
+export type TextGenerationOutput = import("./pipelines/text-generation.js").TextGenerationOutput;
+export type TextGenerationStringOutput = import("./pipelines/text-generation.js").TextGenerationStringOutput;
+export type TextGenerationChatOutput = import("./pipelines/text-generation.js").TextGenerationChatOutput;
+export type ZeroShotClassificationOutput = import("./pipelines/zero-shot-classification.js").ZeroShotClassificationOutput;
+export type AudioClassificationOutput = import("./pipelines/audio-classification.js").AudioClassificationOutput;
+export type ZeroShotAudioClassificationOutput = import("./pipelines/zero-shot-audio-classification.js").ZeroShotAudioClassificationOutput;
+export type AutomaticSpeechRecognitionOutput = import("./pipelines/automatic-speech-recognition.js").AutomaticSpeechRecognitionOutput;
+export type TextToAudioOutput = import("./pipelines/text-to-audio.js").TextToAudioOutput;
+export type ImageClassificationOutput = import("./pipelines/image-classification.js").ImageClassificationOutput;
+export type ImageSegmentationOutput = import("./pipelines/image-segmentation.js").ImageSegmentationOutput;
+export type ImageToTextOutput = import("./pipelines/image-to-text.js").ImageToTextOutput;
+export type ObjectDetectionOutput = import("./pipelines/object-detection.js").ObjectDetectionOutput;
+export type ZeroShotObjectDetectionOutput = import("./pipelines/zero-shot-object-detection.js").ZeroShotObjectDetectionOutput;
+export type ZeroShotImageClassificationOutput = import("./pipelines/zero-shot-image-classification.js").ZeroShotImageClassificationOutput;
+export type DocumentQuestionAnsweringOutput = import("./pipelines/document-question-answering.js").DocumentQuestionAnsweringOutput;
+export type DepthEstimationOutput = import("./pipelines/depth-estimation.js").DepthEstimationOutput;
+import { TextClassificationPipeline } from './pipelines/index.js';
+import { TokenClassificationPipeline } from './pipelines/index.js';
+import { QuestionAnsweringPipeline } from './pipelines/index.js';
+import { FillMaskPipeline } from './pipelines/index.js';
+import { SummarizationPipeline } from './pipelines/index.js';
+import { TranslationPipeline } from './pipelines/index.js';
+import { Text2TextGenerationPipeline } from './pipelines/index.js';
+import { TextGenerationPipeline } from './pipelines/index.js';
+import { ZeroShotClassificationPipeline } from './pipelines/index.js';
+import { AudioClassificationPipeline } from './pipelines/index.js';
+import { ZeroShotAudioClassificationPipeline } from './pipelines/index.js';
+import { AutomaticSpeechRecognitionPipeline } from './pipelines/index.js';
+import { TextToAudioPipeline } from './pipelines/index.js';
+import { ImageToTextPipeline } from './pipelines/index.js';
+import { ImageClassificationPipeline } from './pipelines/index.js';
+import { ImageSegmentationPipeline } from './pipelines/index.js';
+import { BackgroundRemovalPipeline } from './pipelines/index.js';
+import { ZeroShotImageClassificationPipeline } from './pipelines/index.js';
+import { ObjectDetectionPipeline } from './pipelines/index.js';
+import { ZeroShotObjectDetectionPipeline } from './pipelines/index.js';
+import { DocumentQuestionAnsweringPipeline } from './pipelines/index.js';
+import { ImageToImagePipeline } from './pipelines/index.js';
+import { DepthEstimationPipeline } from './pipelines/index.js';
+import { FeatureExtractionPipeline } from './pipelines/index.js';
+import { ImageFeatureExtractionPipeline } from './pipelines/index.js';
+import { SUPPORTED_TASKS } from './pipelines/index.js';
+import { TASK_ALIASES } from './pipelines/index.js';
 export { TextClassificationPipeline, TokenClassificationPipeline, QuestionAnsweringPipeline, FillMaskPipeline, SummarizationPipeline, TranslationPipeline, Text2TextGenerationPipeline, TextGenerationPipeline, ZeroShotClassificationPipeline, AudioClassificationPipeline, ZeroShotAudioClassificationPipeline, AutomaticSpeechRecognitionPipeline, TextToAudioPipeline, ImageToTextPipeline, ImageClassificationPipeline, ImageSegmentationPipeline, BackgroundRemovalPipeline, ZeroShotImageClassificationPipeline, ObjectDetectionPipeline, ZeroShotObjectDetectionPipeline, DocumentQuestionAnsweringPipeline, ImageToImagePipeline, DepthEstimationPipeline, FeatureExtractionPipeline, ImageFeatureExtractionPipeline };
 //# sourceMappingURL=pipelines.d.ts.map

package/types/pipelines.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../src/pipelines.js"],"names":[],"mappings":"AAoXA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yBA7B4B,CAAC,SAAf,YAAa,QAChB,CAAC,UAuBD,MAAM,gKACN,OAAO,gBAAgB,EAAE,sBAAsB,GAC7C,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAyEhC;uBA9GY,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;;;;6BACpB,GAAE,CAAC,IAAI,QAAQ,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe,EAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAC;;;;yBACtE,GAAE,CAAC,IAAI,SAAS,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe;;;;;;MAAiB,CAAC,UAAU,CAAC,CAAC,GAAC;;;;uBACrF,cAAc,GAAG,UAAU;2CA7UG,oCAAoC;4CACnC,qCAAqC;0CACvC,mCAAmC;iCAC5C,0BAA0B;sCACrB,8BAA8B;oCAChC,4BAA4B;4CACpB,qCAAqC;uCAC1C,gCAAgC;+CACxB,yCAAyC;4CAC5C,qCAAqC;oDAC7B,+CAA+C;mDAChD,6CAA6C;oCAC5D,8BAA8B;oCAC9B,8BAA8B;4CACtB,qCAAqC;0CACvC,mCAAmC;0CACnC,mCAAmC;oDACzB,+CAA+C;wCAC3D,iCAAiC;gDACzB,2CAA2C;kDACzC,4CAA4C;qCACzD,+BAA+B;wCAC5B,iCAAiC;0CAC/B,mCAAmC;+CAC9B,yCAAyC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+RG;AAGH;;;;;;GASG;8BAnW2B,oCAAoC;mDA0B3D,gCAAgC;gDAAhC,gCAAgC;8CAAhC,gCAAgC;qCAAhC,gCAAgC;sCAAhC,gCAAgC;qCAAhC,gCAAgC;gDAAhC,gCAAgC;8BAzBT,kCAAkC;0BAyBzD,gCAAgC;0CAAhC,gCAAgC;8CAAhC,gCAAgC;uCAAhC,gCAAgC;gDAAhC,gCAAgC;8CAAhC,gCAAgC;4CAAhC,gCAAgC;oDAAhC,gCAAgC;sDAAhC,gCAAgC;yCAAhC,gCAAgC;4CAAhC,gCAAgC"}
+{"version":3,"file":"pipelines.d.ts","sourceRoot":"","sources":["../src/pipelines.js"],"names":[],"mappings":"AAsDA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yBA9B4B,CAAC,SAAf,YAAa,QAChB,CAAC,UAwBD,MAAM,gKACN,OAAO,gBAAgB,EAAE,sBAAsB,GAC7C,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CA2IhC;uBAjLY,MAAM,OAAO,eAAe;wBAC5B,MAAM,OAAO,YAAY;;;;2BACzB,QAAQ,GAAG,SAAS;;;;6BACpB,GAAE,CAAC,IAAI,QAAQ,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe,EAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,GAAC;;;;yBACtE,GAAE,CAAC,IAAI,SAAS,GAAG,YAAY,CAAC,CAAA,OAAO,eAAe;;;;;;MAAiB,CAAC,UAAU,CAAC,CAAC,GAAC;;;;uBACrF,cAAc,GAAG,UAAU;6BA4M3B,OAAO,0BAA0B,EAAE,cAAc;uCACjD,OAAO,oCAAoC,EAAE,wBAAwB;wCACrE,OAAO,qCAAqC,EAAE,yBAAyB;sCACvE,OAAO,mCAAmC,EAAE,uBAAuB;kCACnE,OAAO,8BAA8B,EAAE,mBAAmB;gCAC1D,OAAO,4BAA4B,EAAE,iBAAiB;wCACtD,OAAO,qCAAqC,EAAE,yBAAyB;mCACvE,OAAO,gCAAgC,EAAE,oBAAoB;yCAC7D,OAAO,gCAAgC,EAAE,0BAA0B;uCACnE,OAAO,gCAAgC,EAAE,wBAAwB;2CACjE,OAAO,yCAAyC,EAAE,4BAA4B;wCAC9E,OAAO,qCAAqC,EAAE,yBAAyB;gDACvE,OAAO,+CAA+C,EAAE,iCAAiC;+CACzF,OAAO,6CAA6C,EAAE,gCAAgC;gCACtF,OAAO,8BAA8B,EAAE,iBAAiB;wCACxD,OAAO,qCAAqC,EAAE,yBAAyB;sCACvE,OAAO,mCAAmC,EAAE,uBAAuB;gCACnE,OAAO,8BAA8B,EAAE,iBAAiB;oCACxD,OAAO,iCAAiC,EAAE,qBAAqB;4CAC/D,OAAO,2CAA2C,EAAE,6BAA6B;gDACjF,OAAO,+CAA+C,EAAE,iCAAiC;8CACzF,OAAO,4CAA4C,EAAE,+BAA+B;oCACpF,OAAO,iCAAiC,EAAE,qBAAqB;2CA5OrE,sBAAsB;4CAAtB,sBAAsB;0CAAtB,sBAAsB;iCAAtB,sBAAsB;sCAAtB,sBAAsB;oCAAtB,sBAAsB;4CAAtB,sBAAsB;uCAAtB,sBAAsB;+CAAtB,sBAAsB;4CAAtB,sBAAsB;oDAAtB,sBAAsB;mDAAtB,sBAAsB;oCAAtB,sBAAsB;oCAAtB,sBAAsB;4CAAtB,sBAAsB;0CAAtB,sBAAsB;0CAAtB,sBAAsB;oDAAtB,sBAAsB;wCAAtB,sBAAsB;gDAAtB,sBAAsB;kDAAtB,sBAAsB;qCAAtB,sBAAsB;wCAAtB,sBAAsB;0CAAtB,sBAAsB;+CAAtB,sBAAsB;gCAAtB,sBAAsB;6BAAtB,sBAAsB"}

package/types/tokenization_utils.d.ts

@@ -93,20 +93,20 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * @param {string|string[]} [options.text_pair=null] Optional second sequence to be encoded. If set, must be the same type as text.
      * @param {boolean|'max_length'} [options.padding=false] Whether to pad the input sequences.
      * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-     * @param {boolean} [options.truncation=null] Whether to truncate the input sequences.
-     * @param {number} [options.max_length=null] Maximum length of the returned list and optionally padding length.
+     * @param {boolean|null} [options.truncation=null] Whether to truncate the input sequences.
+     * @param {number|null} [options.max_length=null] Maximum length of the returned list and optionally padding length.
      * @param {boolean} [options.return_tensor=true] Whether to return the results as Tensors or arrays.
-     * @param {boolean} [options.return_token_type_ids=null] Whether to return the token type ids.
+     * @param {boolean|null} [options.return_token_type_ids=null] Whether to return the token type ids.
      * @returns {BatchEncoding} Object to be passed to the model.
      */
     _call(text: string | string[], { text_pair, add_special_tokens, padding, truncation, max_length, return_tensor, return_token_type_ids, }?: {
         text_pair?: string | string[];
         padding?: boolean | "max_length";
         add_special_tokens?: boolean;
-        truncation?: boolean;
-        max_length?: number;
+        truncation?: boolean | null;
+        max_length?: number | null;
         return_tensor?: boolean;
-        return_token_type_ids?: boolean;
+        return_token_type_ids?: boolean | null;
     }): {
         /**
          * List of token ids to be fed to a model.
@@ -133,9 +133,9 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      *
      * @param {string} text The text to encode.
      * @param {Object} options An optional object containing the following properties:
-     * @param {string} [options.text_pair=null] The optional second text to encode.
+     * @param {string|null} [options.text_pair=null] The optional second text to encode.
      * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-     * @param {boolean} [options.return_token_type_ids=null] Whether to return token_type_ids.
+     * @param {boolean|null} [options.return_token_type_ids=null] Whether to return token_type_ids.
      * @returns {{input_ids: number[], attention_mask: number[], token_type_ids?: number[]}} An object containing the encoded text.
      * @private
      */
@@ -144,12 +144,12 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * Converts a string into a sequence of tokens.
      * @param {string} text The sequence to be encoded.
      * @param {Object} options An optional object containing the following properties:
-     * @param {string} [options.pair] A second sequence to be encoded with the first.
+     * @param {string|null} [options.pair] A second sequence to be encoded with the first.
      * @param {boolean} [options.add_special_tokens=false] Whether or not to add the special tokens associated with the corresponding model.
      * @returns {string[]} The list of tokens.
      */
     tokenize(text: string, { pair, add_special_tokens }?: {
-        pair?: string;
+        pair?: string | null;
         add_special_tokens?: boolean;
     }): string[];
     /**
@@ -157,15 +157,15 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      *
      * @param {string} text The text to encode.
      * @param {Object} options An optional object containing the following properties:
-     * @param {string} [options.text_pair=null] The optional second text to encode.
+     * @param {string|null} [options.text_pair=null] The optional second text to encode.
      * @param {boolean} [options.add_special_tokens=true] Whether or not to add the special tokens associated with the corresponding model.
-     * @param {boolean} [options.return_token_type_ids=null] Whether to return token_type_ids.
+     * @param {boolean|null} [options.return_token_type_ids=null] Whether to return token_type_ids.
      * @returns {number[]} An array of token IDs representing the encoded text(s).
      */
     encode(text: string, { text_pair, add_special_tokens, return_token_type_ids }?: {
-        text_pair?: string;
+        text_pair?: string | null;
         add_special_tokens?: boolean;
-        return_token_type_ids?: boolean;
+        return_token_type_ids?: boolean | null;
     }): number[];
     /**
      * Decode a batch of tokenized sequences.
@@ -194,13 +194,13 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * @param {number[]|bigint[]} token_ids List of token ids to decode
      * @param {Object} decode_args Optional arguments for decoding
      * @param {boolean} [decode_args.skip_special_tokens=false] Whether to skip special tokens during decoding
-     * @param {boolean} [decode_args.clean_up_tokenization_spaces=null] Whether to clean up tokenization spaces during decoding.
+     * @param {boolean|null} [decode_args.clean_up_tokenization_spaces=null] Whether to clean up tokenization spaces during decoding.
      * If null, the value is set to `this.decoder.cleanup` if it exists, falling back to `this.clean_up_tokenization_spaces` if it exists, falling back to `true`.
      * @returns {string} The decoded string
      */
     decode_single(token_ids: number[] | bigint[], { skip_special_tokens, clean_up_tokenization_spaces }: {
         skip_special_tokens?: boolean;
-        clean_up_tokenization_spaces?: boolean;
+        clean_up_tokenization_spaces?: boolean | null;
     }): string;
     /**
      * Retrieve the chat template string used for tokenizing chat messages. This template is used
@@ -208,7 +208,7 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * template for better generation tracking.
      *
      * @param {Object} options An optional object containing the following properties:
-     * @param {string} [options.chat_template=null]
+     * @param {string|null} [options.chat_template=null]
      * A Jinja template or the name of a template to use for this conversion.
      * It is usually not necessary to pass anything to this argument,
      * as the model's template will be used by default.
@@ -221,7 +221,7 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * @returns {string} The chat template string.
      */
     get_chat_template({ chat_template, tools }?: {
-        chat_template?: string;
+        chat_template?: string | null;
         tools?: any[];
     }): string;
     /**
@@ -254,7 +254,7 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * @param {Message[]} conversation A list of message objects with `"role"` and `"content"` keys,
      * representing the chat history so far.
      * @param {Object} options An optional object containing the following properties:
-     * @param {string} [options.chat_template=null] A Jinja template to use for this conversion. If
+     * @param {string|null} [options.chat_template=null] A Jinja template to use for this conversion. If
      * this is not passed, the model's chat template will be used instead.
      * @param {Object[]} [options.tools=null]
      * A list of tools (callable functions) that will be accessible to the model. If the template does not
@@ -275,7 +275,7 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * @param {boolean} [options.tokenize=true] Whether to tokenize the output. If false, the output will be a string.
      * @param {boolean} [options.padding=false] Whether to pad sequences to the maximum length. Has no effect if tokenize is false.
      * @param {boolean} [options.truncation=false] Whether to truncate sequences to the maximum length. Has no effect if tokenize is false.
-     * @param {number} [options.max_length=null] Maximum length (in tokens) to use for padding or truncation. Has no effect if tokenize is false.
+     * @param {number|null} [options.max_length=null] Maximum length (in tokens) to use for padding or truncation. Has no effect if tokenize is false.
      * If not specified, the tokenizer's `max_length` attribute will be used as a default.
      * @param {boolean} [options.return_tensor=true] Whether to return the output as a Tensor or an Array. Has no effect if tokenize is false.
      * @param {boolean} [options.return_dict=true] Whether to return a dictionary with named outputs. Has no effect if tokenize is false.
@@ -283,14 +283,14 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
      * @returns {string | Tensor | number[]| number[][]|BatchEncoding} The tokenized output.
      */
     apply_chat_template(conversation: Message[], { tools, documents, chat_template, add_generation_prompt, tokenize, padding, truncation, max_length, return_tensor, return_dict, tokenizer_kwargs, ...kwargs }?: {
-        chat_template?: string;
+        chat_template?: string | null;
         tools?: any[];
         documents?: Record<string, string>[];
         add_generation_prompt?: boolean;
         tokenize?: boolean;
         padding?: boolean;
         truncation?: boolean;
-        max_length?: number;
+        max_length?: number | null;
         return_tensor?: boolean;
         return_dict?: boolean;
         tokenizer_kwargs?: any;
@@ -310,15 +310,33 @@ export class PreTrainedTokenizer extends PreTrainedTokenizer_base {
     };
 }
 export type PretrainedTokenizerOptions = import("./utils/hub.js").PretrainedOptions;
+export type TextContent = {
+    type: "text";
+    text: string;
+    [key: string]: any;
+};
+export type ImageContent = {
+    type: "image";
+    image?: string | import("./utils/image.js").RawImage;
+    [key: string]: any;
+};
+/**
+ * Base type for message content. This is a discriminated union that can be extended with additional content types.
+ * Example: `@typedef {TextContent | ImageContent | AudioContent} MessageContent`
+ */
+export type MessageContent = TextContent | ImageContent | {
+    type: string & {};
+    [key: string]: any;
+};
 export type Message = {
     /**
-     * The role of the message (e.g., "user" or "assistant" or "system").
+     * The role of the message.
      */
-    role: string;
+    role: "user" | "assistant" | "system" | (string & {});
     /**
-     * The content of the message.
+     * The content of the message. Can be a simple string or an array of content objects.
      */
-    content: string;
+    content: string | MessageContent[];
 };
 import { Tensor } from './utils/tensor.js';
 import { Tokenizer } from '@huggingface/tokenizers';

package/types/tokenization_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokenization_utils.d.ts","sourceRoot":"","sources":["../src/tokenization_utils.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"tokenization_utils.d.ts","sourceRoot":"","sources":["../src/tokenization_utils.js"],"names":[],"mappings":"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"}

package/types/transformers.d.ts

@@ -1,4 +1,3 @@
-export { env } from "./env.js";
 export * from "./pipelines.js";
 export * from "./models/models.js";
 export * from "./models/auto/modeling_auto.js";
@@ -14,11 +13,18 @@ export * from "./generation/streamers.js";
 export * from "./generation/stopping_criteria.js";
 export * from "./generation/logits_process.js";
 export * from "./utils/tensor.js";
+export { random } from "./utils/random.js";
+export { DynamicCache } from "./cache_utils.js";
+export { ModelRegistry } from "./utils/model_registry/ModelRegistry.js";
 export type PretrainedModelOptions = import("./utils/hub.js").PretrainedModelOptions;
 export type PretrainedProcessorOptions = import("./processing_utils.js").PretrainedProcessorOptions;
+export type Message = import("./tokenization_utils.js").Message;
 export type PretrainedTokenizerOptions = import("./tokenization_utils.js").PretrainedTokenizerOptions;
 export type DataType = import("./utils/dtypes.js").DataType;
 export type DeviceType = import("./utils/devices.js").DeviceType;
+export type ProgressCallback = import("./utils/core.js").ProgressCallback;
+export type ProgressInfo = import("./utils/core.js").ProgressInfo;
+export { env, LogLevel } from "./env.js";
 export { PretrainedConfig, AutoConfig } from "./configs.js";
 export { read_audio, RawAudio } from "./utils/audio.js";
 export { load_image, RawImage } from "./utils/image.js";

package/types/transformers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../src/transformers.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;qCAwDa,OAAO,gBAAgB,EAAE,sBAAsB;yCAC/C,OAAO,uBAAuB,EAAE,0BAA0B;yCAC1D,OAAO,yBAAyB,EAAE,0BAA0B;uBAC5D,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,oBAAoB,EAAE,UAAU"}
+{"version":3,"file":"transformers.d.ts","sourceRoot":"","sources":["../src/transformers.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;qCA8Da,OAAO,gBAAgB,EAAE,sBAAsB;yCAC/C,OAAO,uBAAuB,EAAE,0BAA0B;sBAC1D,OAAO,yBAAyB,EAAE,OAAO;yCACzC,OAAO,yBAAyB,EAAE,0BAA0B;uBAC5D,OAAO,mBAAmB,EAAE,QAAQ;yBACpC,OAAO,oBAAoB,EAAE,UAAU;+BACvC,OAAO,iBAAiB,EAAE,gBAAgB;2BAC1C,OAAO,iBAAiB,EAAE,YAAY"}

package/types/utils/audio.d.ts

@@ -76,8 +76,10 @@ export function mel_filter_bank(num_frequency_bins: number, num_mel_filters: num
  * If supplied, applies this filter bank to create a mel spectrogram.
  * @param {number} [options.mel_floor=1e-10] Minimum value of mel frequency banks.
  * @param {string} [options.log_mel=null] How to convert the spectrogram to log scale. Possible options are:
- * `null` (don't convert), `"log"` (take the natural logarithm) `"log10"` (take the base-10 logarithm), `"dB"` (convert to decibels).
+ * `null` (don't convert), `"log"` (take the natural logarithm), `"log10"` (take the base-10 logarithm), `"dB"` (convert to decibels),
+ * `"log10_max_norm"` (take `log10`, then apply `(max(x, maxVal - 8) + 4) / 4` normalization, where `maxVal` is computed from data or given by `max_log_mel`).
  * Can only be used when `power` is not `null`.
+ * @param {number} [options.max_log_mel=null] When `log_mel` is `"log10_max_norm"`, use this fixed value as the max instead of computing from data.
  * @param {number} [options.reference=1.0] Sets the input spectrogram value that corresponds to 0 dB. For example, use `max(spectrogram)[0]` to set
  * the loudest part to 0 dB. Must be greater than zero.
  * @param {number} [options.min_value=1e-10] The spectrogram will be clipped to this minimum value before conversion to decibels, to avoid taking `log(0)`.
@@ -94,7 +96,7 @@ export function mel_filter_bank(num_frequency_bins: number, num_mel_filters: num
  * @param {number} [options.mel_offset=0] Offset to add to the mel spectrogram to avoid taking the log of zero.
  * @returns {Promise<Tensor>} Spectrogram of shape `(num_frequency_bins, length)` (regular spectrogram) or shape `(num_mel_filters, length)` (mel spectrogram).
  */
-export function spectrogram(waveform: Float32Array | Float64Array, window: Float32Array | Float64Array, frame_length: number, hop_length: number, { fft_length, power, center, pad_mode, onesided, preemphasis, preemphasis_htk_flavor, mel_filters, mel_floor, log_mel, reference, min_value, db_range, remove_dc_offset, min_num_frames, max_num_frames, do_pad, transpose, mel_offset, }?: {
+export function spectrogram(waveform: Float32Array | Float64Array, window: Float32Array | Float64Array, frame_length: number, hop_length: number, { fft_length, power, center, pad_mode, onesided, preemphasis, preemphasis_htk_flavor, mel_filters, mel_floor, log_mel, max_log_mel, reference, min_value, db_range, remove_dc_offset, min_num_frames, max_num_frames, do_pad, transpose, mel_offset, }?: {
     fft_length?: number;
     power?: number;
     center?: boolean;
@@ -105,6 +107,7 @@ export function spectrogram(waveform: Float32Array | Float64Array, window: Float
     mel_filters?: number[][];
     mel_floor?: number;
     log_mel?: string;
+    max_log_mel?: number;
     reference?: number;
     min_value?: number;
     db_range?: number;